fix(migration): only backfill endedAt for terminal executions

- Only set endedAt for COMPLETED, FAILED, TERMINATED statuses
- Leave endedAt as NULL for QUEUED, RUNNING, INCOMPLETE, REVIEW
- Add proper schema prefix "platform"
- Prevents incorrectly marking in-progress executions as ended

.branchlet.json

@@ -1,37 +0,0 @@
-{
-  "worktreeCopyPatterns": [
-    ".env*",
-    ".vscode/**",
-    ".auth/**",
-    ".claude/**",
-    "autogpt_platform/.env*",
-    "autogpt_platform/backend/.env*",
-    "autogpt_platform/frontend/.env*",
-    "autogpt_platform/frontend/.auth/**",
-    "autogpt_platform/db/docker/.env*"
-  ],
-  "worktreeCopyIgnores": [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/.git/**",
-    "**/Thumbs.db",
-    "**/.DS_Store",
-    "**/.next/**",
-    "**/__pycache__/**",
-    "**/.ruff_cache/**",
-    "**/.pytest_cache/**",
-    "**/*.pyc",
-    "**/playwright-report/**",
-    "**/logs/**",
-    "**/site/**"
-  ],
-  "worktreePathTemplate": "$BASE_PATH.worktree",
-  "postCreateCmd": [
-    "cd autogpt_platform/autogpt_libs && poetry install",
-    "cd autogpt_platform/backend && poetry install && poetry run prisma generate",
-    "cd autogpt_platform/frontend && pnpm install",
-    "cd docs && pip install -r requirements.txt"
-  ],
-  "terminalCommand": "code .",
-  "deleteBranchWithWorktree": false
-}

.dockerignore

@@ -16,7 +16,6 @@
 !autogpt_platform/backend/poetry.lock
 !autogpt_platform/backend/README.md
 !autogpt_platform/backend/.env
-!autogpt_platform/backend/gen_prisma_types_stub.py
 
 # Platform - Market
 !autogpt_platform/market/market/

.github/workflows/claude-dependabot.yml

@@ -74,7 +74,7 @@ jobs:
 
       - name: Generate Prisma Client
         working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
+        run: poetry run prisma generate
 
       # Frontend Node.js/pnpm setup (mirrors platform-frontend-ci.yml)
       - name: Set up Node.js

.github/workflows/claude.yml

@@ -90,7 +90,7 @@ jobs:
 
       - name: Generate Prisma Client
         working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
+        run: poetry run prisma generate
 
       # Frontend Node.js/pnpm setup (mirrors platform-frontend-ci.yml)
       - name: Set up Node.js

.github/workflows/copilot-setup-steps.yml

@@ -72,7 +72,7 @@ jobs:
 
       - name: Generate Prisma Client
         working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
+        run: poetry run prisma generate
 
       # Frontend Node.js/pnpm setup (mirrors platform-frontend-ci.yml)
       - name: Set up Node.js
@@ -108,16 +108,6 @@ jobs:
       #   run: pnpm playwright install --with-deps chromium
 
       # Docker setup for development environment
-      - name: Free up disk space
-        run: |
-          # Remove large unused tools to free disk space for Docker builds
-          sudo rm -rf /usr/share/dotnet
-          sudo rm -rf /usr/local/lib/android
-          sudo rm -rf /opt/ghc
-          sudo rm -rf /opt/hostedtoolcache/CodeQL
-          sudo docker system prune -af
-          df -h
-
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 

.github/workflows/platform-backend-ci.yml

@@ -134,7 +134,7 @@ jobs:
         run: poetry install
 
       - name: Generate Prisma Client
-        run: poetry run prisma generate && poetry run gen-prisma-stub
+        run: poetry run prisma generate
 
       - id: supabase
         name: Start Supabase
@@ -176,7 +176,7 @@ jobs:
           }
 
       - name: Run Database Migrations
-        run: poetry run prisma migrate deploy
+        run: poetry run prisma migrate dev --name updates
         env:
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
           DIRECT_URL: ${{ steps.supabase.outputs.DB_URL }}

autogpt_platform/Makefile

@@ -12,7 +12,6 @@ reset-db:
 	rm -rf db/docker/volumes/db/data
 	cd backend && poetry run prisma migrate deploy
 	cd backend && poetry run prisma generate
-	cd backend && poetry run gen-prisma-stub
 	
 # View logs for core services
 logs-core:
@@ -34,7 +33,6 @@ init-env:
 migrate:
 	cd backend && poetry run prisma migrate deploy
 	cd backend && poetry run prisma generate
-	cd backend && poetry run gen-prisma-stub
 
 run-backend:
 	cd backend && poetry run app

autogpt_platform/backend/Dockerfile

@@ -48,8 +48,7 @@ RUN poetry install --no-ansi --no-root
 # Generate Prisma client
 COPY autogpt_platform/backend/schema.prisma ./
 COPY autogpt_platform/backend/backend/data/partial_types.py ./backend/data/partial_types.py
-COPY autogpt_platform/backend/gen_prisma_types_stub.py ./
-RUN poetry run prisma generate && poetry run gen-prisma-stub
+RUN poetry run prisma generate
 
 FROM debian:13-slim AS server_dependencies
 

autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py

@@ -28,6 +28,7 @@ from backend.executor.manager import get_db_async_client
 from backend.util.settings import Settings
 
 logger = logging.getLogger(__name__)
+settings = Settings()
 
 
 class ExecutionAnalyticsRequest(BaseModel):
@@ -63,6 +64,8 @@ class ExecutionAnalyticsResult(BaseModel):
     score: Optional[float]
     status: str  # "success", "failed", "skipped"
     error_message: Optional[str] = None
+    started_at: Optional[datetime] = None
+    ended_at: Optional[datetime] = None
 
 
 class ExecutionAnalyticsResponse(BaseModel):
@@ -224,11 +227,6 @@ async def generate_execution_analytics(
     )
 
     try:
-        # Validate model configuration
-        settings = Settings()
-        if not settings.secrets.openai_internal_api_key:
-            raise HTTPException(status_code=500, detail="OpenAI API key not configured")
-
         # Get database client
         db_client = get_db_async_client()
 
@@ -320,6 +318,8 @@ async def generate_execution_analytics(
                     ),
                     status="skipped",
                     error_message=None,  # Not an error - just already processed
+                    started_at=execution.started_at,
+                    ended_at=execution.ended_at,
                 )
             )
 
@@ -349,6 +349,9 @@ async def _process_batch(
 ) -> list[ExecutionAnalyticsResult]:
     """Process a batch of executions concurrently."""
 
+    if not settings.secrets.openai_internal_api_key:
+        raise HTTPException(status_code=500, detail="OpenAI API key not configured")
+
     async def process_single_execution(execution) -> ExecutionAnalyticsResult:
         try:
             # Generate activity status and score using the specified model
@@ -387,6 +390,8 @@ async def _process_batch(
                     score=None,
                     status="skipped",
                     error_message="Activity generation returned None",
+                    started_at=execution.started_at,
+                    ended_at=execution.ended_at,
                 )
 
             # Update the execution stats
@@ -416,6 +421,8 @@ async def _process_batch(
                 summary_text=activity_response["activity_status"],
                 score=activity_response["correctness_score"],
                 status="success",
+                started_at=execution.started_at,
+                ended_at=execution.ended_at,
             )
 
         except Exception as e:
@@ -429,6 +436,8 @@ async def _process_batch(
                 score=None,
                 status="failed",
                 error_message=str(e),
+                started_at=execution.started_at,
+                ended_at=execution.ended_at,
             )
 
     # Process all executions in the batch concurrently

autogpt_platform/backend/backend/api/features/chat/tools/run_agent_test.py

@@ -1,5 +1,4 @@
 import uuid
-from unittest.mock import AsyncMock, patch
 
 import orjson
 import pytest
@@ -18,17 +17,6 @@ setup_test_data = setup_test_data
 setup_firecrawl_test_data = setup_firecrawl_test_data
 
 
-@pytest.fixture(scope="session", autouse=True)
-def mock_embedding_functions():
-    """Mock embedding functions for all tests to avoid database/API dependencies."""
-    with patch(
-        "backend.api.features.store.db.ensure_embedding",
-        new_callable=AsyncMock,
-        return_value=True,
-    ):
-        yield
-
-
 @pytest.mark.asyncio(scope="session")
 async def test_run_agent(setup_test_data):
     """Test that the run_agent tool successfully executes an approved agent"""

autogpt_platform/backend/backend/api/features/library/db.py

@@ -489,7 +489,7 @@ async def update_agent_version_in_library(
     agent_graph_version: int,
 ) -> library_model.LibraryAgent:
     """
-    Updates the agent version in the library for any agent owned by the user.
+    Updates the agent version in the library if useGraphIsActiveVersion is True.
 
     Args:
         user_id: Owner of the LibraryAgent.
@@ -498,31 +498,20 @@ async def update_agent_version_in_library(
 
     Raises:
         DatabaseError: If there's an error with the update.
-        NotFoundError: If no library agent is found for this user and agent.
     """
     logger.debug(
         f"Updating agent version in library for user #{user_id}, "
         f"agent #{agent_graph_id} v{agent_graph_version}"
     )
-    async with transaction() as tx:
-        library_agent = await prisma.models.LibraryAgent.prisma(tx).find_first_or_raise(
+    try:
+        library_agent = await prisma.models.LibraryAgent.prisma().find_first_or_raise(
             where={
                 "userId": user_id,
                 "agentGraphId": agent_graph_id,
+                "useGraphIsActiveVersion": True,
             },
         )
-
-        # Delete any conflicting LibraryAgent for the target version
-        await prisma.models.LibraryAgent.prisma(tx).delete_many(
-            where={
-                "userId": user_id,
-                "agentGraphId": agent_graph_id,
-                "agentGraphVersion": agent_graph_version,
-                "id": {"not": library_agent.id},
-            }
-        )
-
-        lib = await prisma.models.LibraryAgent.prisma(tx).update(
+        lib = await prisma.models.LibraryAgent.prisma().update(
             where={"id": library_agent.id},
             data={
                 "AgentGraph": {
@@ -536,13 +525,13 @@ async def update_agent_version_in_library(
             },
             include={"AgentGraph": True},
         )
+        if lib is None:
+            raise NotFoundError(f"Library agent {library_agent.id} not found")
 
-    if lib is None:
-        raise NotFoundError(
-            f"Failed to update library agent for {agent_graph_id} v{agent_graph_version}"
-        )
-
-    return library_model.LibraryAgent.from_db(lib)
+        return library_model.LibraryAgent.from_db(lib)
+    except prisma.errors.PrismaError as e:
+        logger.error(f"Database error updating agent version in library: {e}")
+        raise DatabaseError("Failed to update agent version in library") from e
 
 
 async def update_library_agent(
@@ -836,7 +825,6 @@ async def add_store_agent_to_library(
                     }
                 },
                 "isCreatedByUser": False,
-                "useGraphIsActiveVersion": False,
                 "settings": SafeJson(
                     _initialize_graph_settings(graph_model).model_dump()
                 ),

autogpt_platform/backend/backend/api/features/library/model.py

@@ -48,7 +48,6 @@ class LibraryAgent(pydantic.BaseModel):
     id: str
     graph_id: str
     graph_version: int
-    owner_user_id: str  # ID of user who owns/created this agent graph
 
     image_url: str | None
 
@@ -164,7 +163,6 @@ class LibraryAgent(pydantic.BaseModel):
             id=agent.id,
             graph_id=agent.agentGraphId,
             graph_version=agent.agentGraphVersion,
-            owner_user_id=agent.userId,
             image_url=agent.imageUrl,
             creator_name=creator_name,
             creator_image_url=creator_image_url,

autogpt_platform/backend/backend/api/features/library/routes_test.py

@@ -42,7 +42,6 @@ async def test_get_library_agents_success(
                 id="test-agent-1",
                 graph_id="test-agent-1",
                 graph_version=1,
-                owner_user_id=test_user_id,
                 name="Test Agent 1",
                 description="Test Description 1",
                 image_url=None,
@@ -65,7 +64,6 @@ async def test_get_library_agents_success(
                 id="test-agent-2",
                 graph_id="test-agent-2",
                 graph_version=1,
-                owner_user_id=test_user_id,
                 name="Test Agent 2",
                 description="Test Description 2",
                 image_url=None,
@@ -140,7 +138,6 @@ async def test_get_favorite_library_agents_success(
                 id="test-agent-1",
                 graph_id="test-agent-1",
                 graph_version=1,
-                owner_user_id=test_user_id,
                 name="Favorite Agent 1",
                 description="Test Favorite Description 1",
                 image_url=None,
@@ -208,7 +205,6 @@ def test_add_agent_to_library_success(
         id="test-library-agent-id",
         graph_id="test-agent-1",
         graph_version=1,
-        owner_user_id=test_user_id,
         name="Test Agent 1",
         description="Test Description 1",
         image_url=None,

autogpt_platform/backend/backend/api/features/store/backfill_embeddings.py

@@ -1,104 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI script to backfill embeddings for store agents.
-
-Usage:
-    poetry run python -m backend.api.features.store.backfill_embeddings [--batch-size N]
-"""
-
-import argparse
-import asyncio
-import logging
-import sys
-
-import prisma
-
-from backend.api.features.store.embeddings import (
-    backfill_missing_embeddings,
-    get_embedding_stats,
-)
-
-logger = logging.getLogger(__name__)
-
-
-async def main(batch_size: int = 100) -> int:
-    """Run the backfill process - processes ALL missing embeddings in batches."""
-    client = prisma.Prisma()
-    await client.connect()
-    prisma.register(client)
-
-    try:
-        stats = await get_embedding_stats()
-
-        # Check for error from get_embedding_stats() first
-        if "error" in stats:
-            logger.error(f"Failed to get embedding stats: {stats['error']}")
-            return 1
-
-        logger.info(
-            f"Current coverage: {stats['with_embeddings']}/{stats['total_approved']} "
-            f"({stats['coverage_percent']}%)"
-        )
-
-        if stats["without_embeddings"] == 0:
-            logger.info("All agents have embeddings - nothing to backfill")
-            return 0
-
-        logger.info(
-            f"Backfilling {stats['without_embeddings']} missing embeddings "
-            f"(batch size: {batch_size})"
-        )
-
-        total_processed = 0
-        total_success = 0
-        total_failed = 0
-
-        while True:
-            result = await backfill_missing_embeddings(batch_size=batch_size)
-            if result["processed"] == 0:
-                break
-
-            total_processed += result["processed"]
-            total_success += result["success"]
-            total_failed += result["failed"]
-
-            logger.info(
-                f"Batch complete: {result['success']}/{result['processed']} succeeded"
-            )
-
-            await asyncio.sleep(1)
-
-        # Final stats
-        stats = await get_embedding_stats()
-        logger.info(
-            f"Backfill complete: {total_success}/{total_processed} succeeded, "
-            f"{total_failed} failed"
-        )
-        if "error" not in stats:
-            logger.info(f"Final coverage: {stats['coverage_percent']}%")
-        else:
-            logger.warning("Could not retrieve final coverage stats")
-
-        return 0 if total_failed == 0 else 1
-
-    finally:
-        await client.disconnect()
-
-
-if __name__ == "__main__":
-    # Configure logging for CLI usage
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(levelname)s: %(message)s",
-    )
-
-    parser = argparse.ArgumentParser(description="Backfill embeddings for store agents")
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=100,
-        help="Number of embeddings to generate per batch (default: 100)",
-    )
-    args = parser.parse_args()
-
-    sys.exit(asyncio.run(main(batch_size=args.batch_size)))

autogpt_platform/backend/backend/api/features/store/db.py

@@ -1,7 +1,8 @@
 import asyncio
 import logging
+import typing
 from datetime import datetime, timezone
-from typing import Any, Literal
+from typing import Literal
 
 import fastapi
 import prisma.enums
@@ -9,7 +10,7 @@ import prisma.errors
 import prisma.models
 import prisma.types
 
-from backend.data.db import transaction
+from backend.data.db import query_raw_with_schema, transaction
 from backend.data.graph import (
     GraphMeta,
     GraphModel,
@@ -29,8 +30,6 @@ from backend.util.settings import Settings
 
 from . import exceptions as store_exceptions
 from . import model as store_model
-from .embeddings import ensure_embedding
-from .hybrid_search import hybrid_search
 
 logger = logging.getLogger(__name__)
 settings = Settings()
@@ -51,77 +50,128 @@ async def get_store_agents(
     page_size: int = 20,
 ) -> store_model.StoreAgentsResponse:
     """
-    Get PUBLIC store agents from the StoreAgent view.
-
-    Search behavior:
-    - With search_query: Uses hybrid search (semantic + lexical)
-    - Fallback: If embeddings unavailable, gracefully degrades to lexical-only
-    - Rationale: User-facing endpoint prioritizes availability over accuracy
-
-    Note: Admin operations (approval) use fail-fast to prevent inconsistent state.
+    Get PUBLIC store agents from the StoreAgent view
     """
     logger.debug(
         f"Getting store agents. featured={featured}, creators={creators}, sorted_by={sorted_by}, search={search_query}, category={category}, page={page}"
     )
 
-    search_used_hybrid = False
-    store_agents: list[store_model.StoreAgent] = []
-    agents: list[dict[str, Any]] = []
-    total = 0
-    total_pages = 0
-
     try:
-        # If search_query is provided, use hybrid search (embeddings + tsvector)
+        # If search_query is provided, use full-text search
         if search_query:
-            # Try hybrid search combining semantic and lexical signals
-            # Falls back to lexical-only if OpenAI unavailable (user-facing, high SLA)
-            try:
-                agents, total = await hybrid_search(
-                    query=search_query,
-                    featured=featured,
-                    creators=creators,
-                    category=category,
-                    sorted_by="relevance",  # Use hybrid scoring for relevance
-                    page=page,
-                    page_size=page_size,
-                )
-                search_used_hybrid = True
-            except Exception as e:
-                # Log error but fall back to lexical search for better UX
-                logger.error(
-                    f"Hybrid search failed (likely OpenAI unavailable), "
-                    f"falling back to lexical search: {e}"
-                )
-                # search_used_hybrid remains False, will use fallback path below
+            offset = (page - 1) * page_size
 
-            # Convert hybrid search results (dict format) if hybrid succeeded
-            if search_used_hybrid:
-                total_pages = (total + page_size - 1) // page_size
-                store_agents: list[store_model.StoreAgent] = []
-                for agent in agents:
-                    try:
-                        store_agent = store_model.StoreAgent(
-                            slug=agent["slug"],
-                            agent_name=agent["agent_name"],
-                            agent_image=(
-                                agent["agent_image"][0] if agent["agent_image"] else ""
-                            ),
-                            creator=agent["creator_username"] or "Needs Profile",
-                            creator_avatar=agent["creator_avatar"] or "",
-                            sub_heading=agent["sub_heading"],
-                            description=agent["description"],
-                            runs=agent["runs"],
-                            rating=agent["rating"],
-                        )
-                        store_agents.append(store_agent)
-                    except Exception as e:
-                        logger.error(
-                            f"Error parsing Store agent from hybrid search results: {e}"
-                        )
-                        continue
+            # Whitelist allowed order_by columns
+            ALLOWED_ORDER_BY = {
+                "rating": "rating DESC, rank DESC",
+                "runs": "runs DESC, rank DESC",
+                "name": "agent_name ASC, rank ASC",
+                "updated_at": "updated_at DESC, rank DESC",
+            }
 
-        if not search_used_hybrid:
-            # Fallback path - use basic search or no search
+            # Validate and get order clause
+            if sorted_by and sorted_by in ALLOWED_ORDER_BY:
+                order_by_clause = ALLOWED_ORDER_BY[sorted_by]
+            else:
+                order_by_clause = "updated_at DESC, rank DESC"
+
+            # Build WHERE conditions and parameters list
+            where_parts: list[str] = []
+            params: list[typing.Any] = [search_query]  # $1 - search term
+            param_index = 2  # Start at $2 for next parameter
+
+            # Always filter for available agents
+            where_parts.append("is_available = true")
+
+            if featured:
+                where_parts.append("featured = true")
+
+            if creators and creators:
+                # Use ANY with array parameter
+                where_parts.append(f"creator_username = ANY(${param_index})")
+                params.append(creators)
+                param_index += 1
+
+            if category and category:
+                where_parts.append(f"${param_index} = ANY(categories)")
+                params.append(category)
+                param_index += 1
+
+            sql_where_clause: str = " AND ".join(where_parts) if where_parts else "1=1"
+
+            # Add pagination params
+            params.extend([page_size, offset])
+            limit_param = f"${param_index}"
+            offset_param = f"${param_index + 1}"
+
+            # Execute full-text search query with parameterized values
+            sql_query = f"""
+                SELECT
+                    slug,
+                    agent_name,
+                    agent_image,
+                    creator_username,
+                    creator_avatar,
+                    sub_heading,
+                    description,
+                    runs,
+                    rating,
+                    categories,
+                    featured,
+                    is_available,
+                    updated_at,
+                    ts_rank_cd(search, query) AS rank
+                FROM {{schema_prefix}}"StoreAgent",
+                    plainto_tsquery('english', $1) AS query
+                WHERE {sql_where_clause}
+                    AND search @@ query
+                ORDER BY {order_by_clause}
+                LIMIT {limit_param} OFFSET {offset_param}
+            """
+
+            # Count query for pagination - only uses search term parameter
+            count_query = f"""
+                SELECT COUNT(*) as count
+                FROM {{schema_prefix}}"StoreAgent",
+                    plainto_tsquery('english', $1) AS query
+                WHERE {sql_where_clause}
+                    AND search @@ query
+            """
+
+            # Execute both queries with parameters
+            agents = await query_raw_with_schema(sql_query, *params)
+
+            # For count, use params without pagination (last 2 params)
+            count_params = params[:-2]
+            count_result = await query_raw_with_schema(count_query, *count_params)
+
+            total = count_result[0]["count"] if count_result else 0
+            total_pages = (total + page_size - 1) // page_size
+
+            # Convert raw results to StoreAgent models
+            store_agents: list[store_model.StoreAgent] = []
+            for agent in agents:
+                try:
+                    store_agent = store_model.StoreAgent(
+                        slug=agent["slug"],
+                        agent_name=agent["agent_name"],
+                        agent_image=(
+                            agent["agent_image"][0] if agent["agent_image"] else ""
+                        ),
+                        creator=agent["creator_username"] or "Needs Profile",
+                        creator_avatar=agent["creator_avatar"] or "",
+                        sub_heading=agent["sub_heading"],
+                        description=agent["description"],
+                        runs=agent["runs"],
+                        rating=agent["rating"],
+                    )
+                    store_agents.append(store_agent)
+                except Exception as e:
+                    logger.error(f"Error parsing Store agent from search results: {e}")
+                    continue
+
+        else:
+            # Non-search query path (original logic)
             where_clause: prisma.types.StoreAgentWhereInput = {"is_available": True}
             if featured:
                 where_clause["featured"] = featured
@@ -130,14 +180,6 @@ async def get_store_agents(
             if category:
                 where_clause["categories"] = {"has": category}
 
-            # Add basic text search if search_query provided but hybrid failed
-            if search_query:
-                where_clause["OR"] = [
-                    {"agent_name": {"contains": search_query, "mode": "insensitive"}},
-                    {"sub_heading": {"contains": search_query, "mode": "insensitive"}},
-                    {"description": {"contains": search_query, "mode": "insensitive"}},
-                ]
-
             order_by = []
             if sorted_by == "rating":
                 order_by.append({"rating": "desc"})
@@ -146,7 +188,7 @@ async def get_store_agents(
             elif sorted_by == "name":
                 order_by.append({"agent_name": "asc"})
 
-            db_agents = await prisma.models.StoreAgent.prisma().find_many(
+            agents = await prisma.models.StoreAgent.prisma().find_many(
                 where=where_clause,
                 order=order_by,
                 skip=(page - 1) * page_size,
@@ -157,7 +199,7 @@ async def get_store_agents(
             total_pages = (total + page_size - 1) // page_size
 
             store_agents: list[store_model.StoreAgent] = []
-            for agent in db_agents:
+            for agent in agents:
                 try:
                     # Create the StoreAgent object safely
                     store_agent = store_model.StoreAgent(
@@ -572,7 +614,6 @@ async def get_store_submissions(
         submission_models = []
         for sub in submissions:
             submission_model = store_model.StoreSubmission(
-                listing_id=sub.listing_id,
                 agent_id=sub.agent_id,
                 agent_version=sub.agent_version,
                 name=sub.name,
@@ -626,48 +667,35 @@ async def delete_store_submission(
     submission_id: str,
 ) -> bool:
     """
-    Delete a store submission version as the submitting user.
+    Delete a store listing submission as the submitting user.
 
     Args:
         user_id: ID of the authenticated user
-        submission_id: StoreListingVersion ID to delete
+        submission_id: ID of the submission to be deleted
 
     Returns:
-        bool: True if successfully deleted
+        bool: True if the submission was successfully deleted, False otherwise
     """
+    logger.debug(f"Deleting store submission {submission_id} for user {user_id}")
+
     try:
-        # Find the submission version with ownership check
-        version = await prisma.models.StoreListingVersion.prisma().find_first(
-            where={"id": submission_id}, include={"StoreListing": True}
+        # Verify the submission belongs to this user
+        submission = await prisma.models.StoreListing.prisma().find_first(
+            where={"agentGraphId": submission_id, "owningUserId": user_id}
         )
 
-        if (
-            not version
-            or not version.StoreListing
-            or version.StoreListing.owningUserId != user_id
-        ):
-            raise store_exceptions.SubmissionNotFoundError("Submission not found")
-
-        # Prevent deletion of approved submissions
-        if version.submissionStatus == prisma.enums.SubmissionStatus.APPROVED:
-            raise store_exceptions.InvalidOperationError(
-                "Cannot delete approved submissions"
+        if not submission:
+            logger.warning(f"Submission not found for user {user_id}: {submission_id}")
+            raise store_exceptions.SubmissionNotFoundError(
+                f"Submission not found for this user. User ID: {user_id}, Submission ID: {submission_id}"
             )
 
-        # Delete the version
-        await prisma.models.StoreListingVersion.prisma().delete(
-            where={"id": version.id}
-        )
+        # Delete the submission
+        await prisma.models.StoreListing.prisma().delete(where={"id": submission.id})
 
-        # Clean up empty listing if this was the last version
-        remaining = await prisma.models.StoreListingVersion.prisma().count(
-            where={"storeListingId": version.storeListingId}
+        logger.debug(
+            f"Successfully deleted submission {submission_id} for user {user_id}"
         )
-        if remaining == 0:
-            await prisma.models.StoreListing.prisma().delete(
-                where={"id": version.storeListingId}
-            )
-
         return True
 
     except Exception as e:
@@ -731,15 +759,9 @@ async def create_store_submission(
             logger.warning(
                 f"Agent not found for user {user_id}: {agent_id} v{agent_version}"
             )
-            # Provide more user-friendly error message when agent_id is empty
-            if not agent_id or agent_id.strip() == "":
-                raise store_exceptions.AgentNotFoundError(
-                    "No agent selected. Please select an agent before submitting to the store."
-                )
-            else:
-                raise store_exceptions.AgentNotFoundError(
-                    f"Agent not found for this user. User ID: {user_id}, Agent ID: {agent_id}, Version: {agent_version}"
-                )
+            raise store_exceptions.AgentNotFoundError(
+                f"Agent not found for this user. User ID: {user_id}, Agent ID: {agent_id}, Version: {agent_version}"
+            )
 
         # Check if listing already exists for this agent
         existing_listing = await prisma.models.StoreListing.prisma().find_first(
@@ -811,7 +833,6 @@ async def create_store_submission(
         logger.debug(f"Created store listing for agent {agent_id}")
         # Return submission details
         return store_model.StoreSubmission(
-            listing_id=listing.id,
             agent_id=agent_id,
             agent_version=agent_version,
             name=name,
@@ -923,56 +944,81 @@ async def edit_store_submission(
         # Currently we are not allowing user to update the agent associated with a submission
         # If we allow it in future, then we need a check here to verify the agent belongs to this user.
 
-        # Only allow editing of PENDING submissions
-        if current_version.submissionStatus != prisma.enums.SubmissionStatus.PENDING:
+        # Check if we can edit this submission
+        if current_version.submissionStatus == prisma.enums.SubmissionStatus.REJECTED:
             raise store_exceptions.InvalidOperationError(
-                f"Cannot edit a {current_version.submissionStatus.value.lower()} submission. Only pending submissions can be edited."
+                "Cannot edit a rejected submission"
+            )
+
+        # For APPROVED submissions, we need to create a new version
+        if current_version.submissionStatus == prisma.enums.SubmissionStatus.APPROVED:
+            # Create a new version for the existing listing
+            return await create_store_version(
+                user_id=user_id,
+                agent_id=current_version.agentGraphId,
+                agent_version=current_version.agentGraphVersion,
+                store_listing_id=current_version.storeListingId,
+                name=name,
+                video_url=video_url,
+                agent_output_demo_url=agent_output_demo_url,
+                image_urls=image_urls,
+                description=description,
+                sub_heading=sub_heading,
+                categories=categories,
+                changes_summary=changes_summary,
+                recommended_schedule_cron=recommended_schedule_cron,
+                instructions=instructions,
             )
 
         # For PENDING submissions, we can update the existing version
-        # Update the existing version
-        updated_version = await prisma.models.StoreListingVersion.prisma().update(
-            where={"id": store_listing_version_id},
-            data=prisma.types.StoreListingVersionUpdateInput(
+        elif current_version.submissionStatus == prisma.enums.SubmissionStatus.PENDING:
+            # Update the existing version
+            updated_version = await prisma.models.StoreListingVersion.prisma().update(
+                where={"id": store_listing_version_id},
+                data=prisma.types.StoreListingVersionUpdateInput(
+                    name=name,
+                    videoUrl=video_url,
+                    agentOutputDemoUrl=agent_output_demo_url,
+                    imageUrls=image_urls,
+                    description=description,
+                    categories=categories,
+                    subHeading=sub_heading,
+                    changesSummary=changes_summary,
+                    recommendedScheduleCron=recommended_schedule_cron,
+                    instructions=instructions,
+                ),
+            )
+
+            logger.debug(
+                f"Updated existing version {store_listing_version_id} for agent {current_version.agentGraphId}"
+            )
+
+            if not updated_version:
+                raise DatabaseError("Failed to update store listing version")
+            return store_model.StoreSubmission(
+                agent_id=current_version.agentGraphId,
+                agent_version=current_version.agentGraphVersion,
                 name=name,
-                videoUrl=video_url,
-                agentOutputDemoUrl=agent_output_demo_url,
-                imageUrls=image_urls,
+                sub_heading=sub_heading,
+                slug=current_version.StoreListing.slug,
                 description=description,
-                categories=categories,
-                subHeading=sub_heading,
-                changesSummary=changes_summary,
-                recommendedScheduleCron=recommended_schedule_cron,
                 instructions=instructions,
-            ),
-        )
+                image_urls=image_urls,
+                date_submitted=updated_version.submittedAt or updated_version.createdAt,
+                status=updated_version.submissionStatus,
+                runs=0,
+                rating=0.0,
+                store_listing_version_id=updated_version.id,
+                changes_summary=changes_summary,
+                video_url=video_url,
+                categories=categories,
+                version=updated_version.version,
+            )
 
-        logger.debug(
-            f"Updated existing version {store_listing_version_id} for agent {current_version.agentGraphId}"
-        )
-
-        if not updated_version:
-            raise DatabaseError("Failed to update store listing version")
-        return store_model.StoreSubmission(
-            listing_id=current_version.StoreListing.id,
-            agent_id=current_version.agentGraphId,
-            agent_version=current_version.agentGraphVersion,
-            name=name,
-            sub_heading=sub_heading,
-            slug=current_version.StoreListing.slug,
-            description=description,
-            instructions=instructions,
-            image_urls=image_urls,
-            date_submitted=updated_version.submittedAt or updated_version.createdAt,
-            status=updated_version.submissionStatus,
-            runs=0,
-            rating=0.0,
-            store_listing_version_id=updated_version.id,
-            changes_summary=changes_summary,
-            video_url=video_url,
-            categories=categories,
-            version=updated_version.version,
-        )
+        else:
+            raise store_exceptions.InvalidOperationError(
+                f"Cannot edit submission with status: {current_version.submissionStatus}"
+            )
 
     except (
         store_exceptions.SubmissionNotFoundError,
@@ -1051,78 +1097,38 @@ async def create_store_version(
                 f"Agent not found for this user. User ID: {user_id}, Agent ID: {agent_id}, Version: {agent_version}"
             )
 
-        # Check if there's already a PENDING submission for this agent (any version)
-        existing_pending_submission = (
-            await prisma.models.StoreListingVersion.prisma().find_first(
-                where=prisma.types.StoreListingVersionWhereInput(
-                    storeListingId=store_listing_id,
-                    agentGraphId=agent_id,
-                    submissionStatus=prisma.enums.SubmissionStatus.PENDING,
-                    isDeleted=False,
-                )
+        # Get the latest version number
+        latest_version = listing.Versions[0] if listing.Versions else None
+
+        next_version = (latest_version.version + 1) if latest_version else 1
+
+        # Create a new version for the existing listing
+        new_version = await prisma.models.StoreListingVersion.prisma().create(
+            data=prisma.types.StoreListingVersionCreateInput(
+                version=next_version,
+                agentGraphId=agent_id,
+                agentGraphVersion=agent_version,
+                name=name,
+                videoUrl=video_url,
+                agentOutputDemoUrl=agent_output_demo_url,
+                imageUrls=image_urls,
+                description=description,
+                instructions=instructions,
+                categories=categories,
+                subHeading=sub_heading,
+                submissionStatus=prisma.enums.SubmissionStatus.PENDING,
+                submittedAt=datetime.now(),
+                changesSummary=changes_summary,
+                recommendedScheduleCron=recommended_schedule_cron,
+                storeListingId=store_listing_id,
             )
         )
 
-        # Handle existing pending submission and create new one atomically
-        async with transaction() as tx:
-            # Get the latest version number first
-            latest_listing = await prisma.models.StoreListing.prisma(tx).find_first(
-                where=prisma.types.StoreListingWhereInput(
-                    id=store_listing_id, owningUserId=user_id
-                ),
-                include={"Versions": {"order_by": {"version": "desc"}, "take": 1}},
-            )
-
-            if not latest_listing:
-                raise store_exceptions.ListingNotFoundError(
-                    f"Store listing not found. User ID: {user_id}, Listing ID: {store_listing_id}"
-                )
-
-            latest_version = (
-                latest_listing.Versions[0] if latest_listing.Versions else None
-            )
-            next_version = (latest_version.version + 1) if latest_version else 1
-
-            # If there's an existing pending submission, delete it atomically before creating new one
-            if existing_pending_submission:
-                logger.info(
-                    f"Found existing PENDING submission for agent {agent_id} (was v{existing_pending_submission.agentGraphVersion}, now v{agent_version}), replacing existing submission instead of creating duplicate"
-                )
-                await prisma.models.StoreListingVersion.prisma(tx).delete(
-                    where={"id": existing_pending_submission.id}
-                )
-                logger.debug(
-                    f"Deleted existing pending submission {existing_pending_submission.id}"
-                )
-
-            # Create a new version for the existing listing
-            new_version = await prisma.models.StoreListingVersion.prisma(tx).create(
-                data=prisma.types.StoreListingVersionCreateInput(
-                    version=next_version,
-                    agentGraphId=agent_id,
-                    agentGraphVersion=agent_version,
-                    name=name,
-                    videoUrl=video_url,
-                    agentOutputDemoUrl=agent_output_demo_url,
-                    imageUrls=image_urls,
-                    description=description,
-                    instructions=instructions,
-                    categories=categories,
-                    subHeading=sub_heading,
-                    submissionStatus=prisma.enums.SubmissionStatus.PENDING,
-                    submittedAt=datetime.now(),
-                    changesSummary=changes_summary,
-                    recommendedScheduleCron=recommended_schedule_cron,
-                    storeListingId=store_listing_id,
-                )
-            )
-
         logger.debug(
             f"Created new version for listing {store_listing_id} of agent {agent_id}"
         )
         # Return submission details
         return store_model.StoreSubmission(
-            listing_id=listing.id,
             agent_id=agent_id,
             agent_version=agent_version,
             name=name,
@@ -1535,7 +1541,7 @@ async def review_store_submission(
                 )
 
                 # Update the AgentGraph with store listing data
-                await prisma.models.AgentGraph.prisma(tx).update(
+                await prisma.models.AgentGraph.prisma().update(
                     where={
                         "graphVersionId": {
                             "id": store_listing_version.agentGraphId,
@@ -1550,23 +1556,6 @@ async def review_store_submission(
                     },
                 )
 
-                # Generate embedding for approved listing (blocking - admin operation)
-                # Inside transaction: if embedding fails, entire transaction rolls back
-                embedding_success = await ensure_embedding(
-                    version_id=store_listing_version_id,
-                    name=store_listing_version.name,
-                    description=store_listing_version.description,
-                    sub_heading=store_listing_version.subHeading,
-                    categories=store_listing_version.categories or [],
-                    tx=tx,
-                )
-                if not embedding_success:
-                    raise ValueError(
-                        f"Failed to generate embedding for listing {store_listing_version_id}. "
-                        "This is likely due to OpenAI API being unavailable. "
-                        "Please try again later or contact support if the issue persists."
-                    )
-
                 await prisma.models.StoreListing.prisma(tx).update(
                     where={"id": store_listing_version.StoreListing.id},
                     data={
@@ -1719,12 +1708,15 @@ async def review_store_submission(
 
         # Convert to Pydantic model for consistency
         return store_model.StoreSubmission(
-            listing_id=(submission.StoreListing.id if submission.StoreListing else ""),
             agent_id=submission.agentGraphId,
             agent_version=submission.agentGraphVersion,
             name=submission.name,
             sub_heading=submission.subHeading,
-            slug=(submission.StoreListing.slug if submission.StoreListing else ""),
+            slug=(
+                submission.StoreListing.slug
+                if hasattr(submission, "storeListing") and submission.StoreListing
+                else ""
+            ),
             description=submission.description,
             instructions=submission.instructions,
             image_urls=submission.imageUrls or [],
@@ -1826,7 +1818,9 @@ async def get_admin_listings_with_versions(
         where = prisma.types.StoreListingWhereInput(**where_dict)
         include = prisma.types.StoreListingInclude(
             Versions=prisma.types.FindManyStoreListingVersionArgsFromStoreListing(
-                order_by={"version": "desc"}
+                order_by=prisma.types._StoreListingVersion_version_OrderByInput(
+                    version="desc"
+                )
             ),
             OwningUser=True,
         )
@@ -1851,7 +1845,6 @@ async def get_admin_listings_with_versions(
             # If we have versions, turn them into StoreSubmission models
             for version in listing.Versions or []:
                 version_model = store_model.StoreSubmission(
-                    listing_id=listing.id,
                     agent_id=version.agentGraphId,
                     agent_version=version.agentGraphVersion,
                     name=version.name,

autogpt_platform/backend/backend/api/features/store/embeddings.py

@@ -1,533 +0,0 @@
-"""
-Unified Content Embeddings Service
-
-Handles generation and storage of OpenAI embeddings for all content types
-(store listings, blocks, documentation, library agents) to enable semantic/hybrid search.
-"""
-
-import asyncio
-import logging
-import time
-from typing import Any
-
-import prisma
-from prisma.enums import ContentType
-
-from backend.data.db import execute_raw_with_schema, query_raw_with_schema
-from backend.util.clients import get_openai_client
-from backend.util.json import dumps
-
-logger = logging.getLogger(__name__)
-
-
-# OpenAI embedding model configuration
-EMBEDDING_MODEL = "text-embedding-3-small"
-
-
-def build_searchable_text(
-    name: str,
-    description: str,
-    sub_heading: str,
-    categories: list[str],
-) -> str:
-    """
-    Build searchable text from listing version fields.
-
-    Combines relevant fields into a single string for embedding.
-    """
-    parts = []
-
-    # Name is important - include it
-    if name:
-        parts.append(name)
-
-    # Sub-heading provides context
-    if sub_heading:
-        parts.append(sub_heading)
-
-    # Description is the main content
-    if description:
-        parts.append(description)
-
-    # Categories help with semantic matching
-    if categories:
-        parts.append(" ".join(categories))
-
-    return " ".join(parts)
-
-
-async def generate_embedding(text: str) -> list[float] | None:
-    """
-    Generate embedding for text using OpenAI API.
-
-    Returns None if embedding generation fails.
-    Fail-fast: no retries to maintain consistency with approval flow.
-    """
-    try:
-        client = get_openai_client()
-        if not client:
-            logger.error("openai_internal_api_key not set, cannot generate embedding")
-            return None
-
-        # Truncate text to avoid token limits (~32k chars for safety)
-        truncated_text = text[:32000]
-
-        start_time = time.time()
-        response = await client.embeddings.create(
-            model=EMBEDDING_MODEL,
-            input=truncated_text,
-        )
-        latency_ms = (time.time() - start_time) * 1000
-
-        embedding = response.data[0].embedding
-        logger.info(
-            f"Generated embedding: {len(embedding)} dims, "
-            f"{len(truncated_text)} chars, {latency_ms:.0f}ms"
-        )
-        return embedding
-
-    except Exception as e:
-        logger.error(f"Failed to generate embedding: {e}")
-        return None
-
-
-async def store_embedding(
-    version_id: str,
-    embedding: list[float],
-    tx: prisma.Prisma | None = None,
-) -> bool:
-    """
-    Store embedding in the database.
-
-    BACKWARD COMPATIBILITY: Maintained for existing store listing usage.
-    DEPRECATED: Use ensure_embedding() instead (includes searchable_text).
-    """
-    return await store_content_embedding(
-        content_type=ContentType.STORE_AGENT,
-        content_id=version_id,
-        embedding=embedding,
-        searchable_text="",  # Empty for backward compat; ensure_embedding() populates this
-        metadata=None,
-        user_id=None,  # Store agents are public
-        tx=tx,
-    )
-
-
-async def store_content_embedding(
-    content_type: ContentType,
-    content_id: str,
-    embedding: list[float],
-    searchable_text: str,
-    metadata: dict | None = None,
-    user_id: str | None = None,
-    tx: prisma.Prisma | None = None,
-) -> bool:
-    """
-    Store embedding in the unified content embeddings table.
-
-    New function for unified content embedding storage.
-    Uses raw SQL since Prisma doesn't natively support pgvector.
-    """
-    try:
-        client = tx if tx else prisma.get_client()
-
-        # Convert embedding to PostgreSQL vector format
-        embedding_str = embedding_to_vector_string(embedding)
-        metadata_json = dumps(metadata or {})
-
-        # Upsert the embedding
-        await execute_raw_with_schema(
-            """
-            INSERT INTO {schema_prefix}"UnifiedContentEmbedding" (
-                "id", "contentType", "contentId", "userId", "embedding", "searchableText", "metadata", "createdAt", "updatedAt"
-            )
-            VALUES (gen_random_uuid()::text, $1::{schema_prefix}"ContentType", $2, $3, $4::vector, $5, $6::jsonb, NOW(), NOW())
-            ON CONFLICT ("contentType", "contentId", "userId")
-            DO UPDATE SET
-                "embedding" = $4::vector,
-                "searchableText" = $5,
-                "metadata" = $6::jsonb,
-                "updatedAt" = NOW()
-            """,
-            content_type,
-            content_id,
-            user_id,
-            embedding_str,
-            searchable_text,
-            metadata_json,
-            client=client,
-        )
-
-        logger.info(f"Stored embedding for {content_type}:{content_id}")
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to store embedding for {content_type}:{content_id}: {e}")
-        return False
-
-
-async def get_embedding(version_id: str) -> dict[str, Any] | None:
-    """
-    Retrieve embedding record for a listing version.
-
-    BACKWARD COMPATIBILITY: Maintained for existing store listing usage.
-    Returns dict with storeListingVersionId, embedding, timestamps or None if not found.
-    """
-    result = await get_content_embedding(
-        ContentType.STORE_AGENT, version_id, user_id=None
-    )
-    if result:
-        # Transform to old format for backward compatibility
-        return {
-            "storeListingVersionId": result["contentId"],
-            "embedding": result["embedding"],
-            "createdAt": result["createdAt"],
-            "updatedAt": result["updatedAt"],
-        }
-    return None
-
-
-async def get_content_embedding(
-    content_type: ContentType, content_id: str, user_id: str | None = None
-) -> dict[str, Any] | None:
-    """
-    Retrieve embedding record for any content type.
-
-    New function for unified content embedding retrieval.
-    Returns dict with contentType, contentId, embedding, timestamps or None if not found.
-    """
-    try:
-        result = await query_raw_with_schema(
-            """
-            SELECT
-                "contentType",
-                "contentId",
-                "userId",
-                "embedding"::text as "embedding",
-                "searchableText",
-                "metadata",
-                "createdAt",
-                "updatedAt"
-            FROM {schema_prefix}"UnifiedContentEmbedding"
-            WHERE "contentType" = $1::{schema_prefix}"ContentType" AND "contentId" = $2 AND ("userId" = $3 OR ($3 IS NULL AND "userId" IS NULL))
-            """,
-            content_type,
-            content_id,
-            user_id,
-        )
-
-        if result and len(result) > 0:
-            return result[0]
-        return None
-
-    except Exception as e:
-        logger.error(f"Failed to get embedding for {content_type}:{content_id}: {e}")
-        return None
-
-
-async def ensure_embedding(
-    version_id: str,
-    name: str,
-    description: str,
-    sub_heading: str,
-    categories: list[str],
-    force: bool = False,
-    tx: prisma.Prisma | None = None,
-) -> bool:
-    """
-    Ensure an embedding exists for the listing version.
-
-    Creates embedding if missing. Use force=True to regenerate.
-    Backward-compatible wrapper for store listings.
-
-    Args:
-        version_id: The StoreListingVersion ID
-        name: Agent name
-        description: Agent description
-        sub_heading: Agent sub-heading
-        categories: Agent categories
-        force: Force regeneration even if embedding exists
-        tx: Optional transaction client
-
-    Returns:
-        True if embedding exists/was created, False on failure
-    """
-    try:
-        # Check if embedding already exists
-        if not force:
-            existing = await get_embedding(version_id)
-            if existing and existing.get("embedding"):
-                logger.debug(f"Embedding for version {version_id} already exists")
-                return True
-
-        # Build searchable text for embedding
-        searchable_text = build_searchable_text(
-            name, description, sub_heading, categories
-        )
-
-        # Generate new embedding
-        embedding = await generate_embedding(searchable_text)
-        if embedding is None:
-            logger.warning(f"Could not generate embedding for version {version_id}")
-            return False
-
-        # Store the embedding with metadata using new function
-        metadata = {
-            "name": name,
-            "subHeading": sub_heading,
-            "categories": categories,
-        }
-        return await store_content_embedding(
-            content_type=ContentType.STORE_AGENT,
-            content_id=version_id,
-            embedding=embedding,
-            searchable_text=searchable_text,
-            metadata=metadata,
-            user_id=None,  # Store agents are public
-            tx=tx,
-        )
-
-    except Exception as e:
-        logger.error(f"Failed to ensure embedding for version {version_id}: {e}")
-        return False
-
-
-async def delete_embedding(version_id: str) -> bool:
-    """
-    Delete embedding for a listing version.
-
-    BACKWARD COMPATIBILITY: Maintained for existing store listing usage.
-    Note: This is usually handled automatically by CASCADE delete,
-    but provided for manual cleanup if needed.
-    """
-    return await delete_content_embedding(ContentType.STORE_AGENT, version_id)
-
-
-async def delete_content_embedding(content_type: ContentType, content_id: str) -> bool:
-    """
-    Delete embedding for any content type.
-
-    New function for unified content embedding deletion.
-    Note: This is usually handled automatically by CASCADE delete,
-    but provided for manual cleanup if needed.
-    """
-    try:
-        client = prisma.get_client()
-
-        await execute_raw_with_schema(
-            """
-            DELETE FROM {schema_prefix}"UnifiedContentEmbedding"
-            WHERE "contentType" = $1::{schema_prefix}"ContentType" AND "contentId" = $2
-            """,
-            content_type,
-            content_id,
-            client=client,
-        )
-
-        logger.info(f"Deleted embedding for {content_type}:{content_id}")
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to delete embedding for {content_type}:{content_id}: {e}")
-        return False
-
-
-async def get_embedding_stats() -> dict[str, Any]:
-    """
-    Get statistics about embedding coverage.
-
-    Returns counts of:
-    - Total approved listing versions
-    - Versions with embeddings
-    - Versions without embeddings
-    """
-    try:
-        # Count approved versions
-        approved_result = await query_raw_with_schema(
-            """
-            SELECT COUNT(*) as count
-            FROM {schema_prefix}"StoreListingVersion"
-            WHERE "submissionStatus" = 'APPROVED'
-            AND "isDeleted" = false
-            """
-        )
-        total_approved = approved_result[0]["count"] if approved_result else 0
-
-        # Count versions with embeddings
-        embedded_result = await query_raw_with_schema(
-            """
-            SELECT COUNT(*) as count
-            FROM {schema_prefix}"StoreListingVersion" slv
-            JOIN {schema_prefix}"UnifiedContentEmbedding" uce ON slv.id = uce."contentId" AND uce."contentType" = 'STORE_AGENT'
-            WHERE slv."submissionStatus" = 'APPROVED'
-            AND slv."isDeleted" = false
-            """
-        )
-        with_embeddings = embedded_result[0]["count"] if embedded_result else 0
-
-        return {
-            "total_approved": total_approved,
-            "with_embeddings": with_embeddings,
-            "without_embeddings": total_approved - with_embeddings,
-            "coverage_percent": (
-                round(with_embeddings / total_approved * 100, 1)
-                if total_approved > 0
-                else 0
-            ),
-        }
-
-    except Exception as e:
-        logger.error(f"Failed to get embedding stats: {e}")
-        return {
-            "total_approved": 0,
-            "with_embeddings": 0,
-            "without_embeddings": 0,
-            "coverage_percent": 0,
-            "error": str(e),
-        }
-
-
-async def backfill_missing_embeddings(batch_size: int = 10) -> dict[str, Any]:
-    """
-    Generate embeddings for approved listings that don't have them.
-
-    Args:
-        batch_size: Number of embeddings to generate in one call
-
-    Returns:
-        Dict with success/failure counts
-    """
-    try:
-        # Find approved versions without embeddings
-        missing = await query_raw_with_schema(
-            """
-            SELECT
-                slv.id,
-                slv.name,
-                slv.description,
-                slv."subHeading",
-                slv.categories
-            FROM {schema_prefix}"StoreListingVersion" slv
-            LEFT JOIN {schema_prefix}"UnifiedContentEmbedding" uce
-                ON slv.id = uce."contentId" AND uce."contentType" = 'STORE_AGENT'
-            WHERE slv."submissionStatus" = 'APPROVED'
-            AND slv."isDeleted" = false
-            AND uce."contentId" IS NULL
-            LIMIT $1
-            """,
-            batch_size,
-        )
-
-        if not missing:
-            return {
-                "processed": 0,
-                "success": 0,
-                "failed": 0,
-                "message": "No missing embeddings",
-            }
-
-        # Process embeddings concurrently for better performance
-        embedding_tasks = [
-            ensure_embedding(
-                version_id=row["id"],
-                name=row["name"],
-                description=row["description"],
-                sub_heading=row["subHeading"],
-                categories=row["categories"] or [],
-            )
-            for row in missing
-        ]
-
-        results = await asyncio.gather(*embedding_tasks, return_exceptions=True)
-
-        success = sum(1 for result in results if result is True)
-        failed = len(results) - success
-
-        return {
-            "processed": len(missing),
-            "success": success,
-            "failed": failed,
-            "message": f"Backfilled {success} embeddings, {failed} failed",
-        }
-
-    except Exception as e:
-        logger.error(f"Failed to backfill embeddings: {e}")
-        return {
-            "processed": 0,
-            "success": 0,
-            "failed": 0,
-            "error": str(e),
-        }
-
-
-async def embed_query(query: str) -> list[float] | None:
-    """
-    Generate embedding for a search query.
-
-    Same as generate_embedding but with clearer intent.
-    """
-    return await generate_embedding(query)
-
-
-def embedding_to_vector_string(embedding: list[float]) -> str:
-    """Convert embedding list to PostgreSQL vector string format."""
-    return "[" + ",".join(str(x) for x in embedding) + "]"
-
-
-async def ensure_content_embedding(
-    content_type: ContentType,
-    content_id: str,
-    searchable_text: str,
-    metadata: dict | None = None,
-    user_id: str | None = None,
-    force: bool = False,
-    tx: prisma.Prisma | None = None,
-) -> bool:
-    """
-    Ensure an embedding exists for any content type.
-
-    Generic function for creating embeddings for store agents, blocks, docs, etc.
-
-    Args:
-        content_type: ContentType enum value (STORE_AGENT, BLOCK, etc.)
-        content_id: Unique identifier for the content
-        searchable_text: Combined text for embedding generation
-        metadata: Optional metadata to store with embedding
-        force: Force regeneration even if embedding exists
-        tx: Optional transaction client
-
-    Returns:
-        True if embedding exists/was created, False on failure
-    """
-    try:
-        # Check if embedding already exists
-        if not force:
-            existing = await get_content_embedding(content_type, content_id, user_id)
-            if existing and existing.get("embedding"):
-                logger.debug(
-                    f"Embedding for {content_type}:{content_id} already exists"
-                )
-                return True
-
-        # Generate new embedding
-        embedding = await generate_embedding(searchable_text)
-        if embedding is None:
-            logger.warning(
-                f"Could not generate embedding for {content_type}:{content_id}"
-            )
-            return False
-
-        # Store the embedding
-        return await store_content_embedding(
-            content_type=content_type,
-            content_id=content_id,
-            embedding=embedding,
-            searchable_text=searchable_text,
-            metadata=metadata or {},
-            user_id=user_id,
-            tx=tx,
-        )
-
-    except Exception as e:
-        logger.error(f"Failed to ensure embedding for {content_type}:{content_id}: {e}")
-        return False

autogpt_platform/backend/backend/api/features/store/embeddings_schema_test.py

@@ -1,329 +0,0 @@
-"""
-Integration tests for embeddings with schema handling.
-
-These tests verify that embeddings operations work correctly across different database schemas.
-"""
-
-from unittest.mock import AsyncMock, patch
-
-import pytest
-from prisma.enums import ContentType
-
-from backend.api.features.store import embeddings
-
-# Schema prefix tests removed - functionality moved to db.raw_with_schema() helper
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_store_content_embedding_with_schema():
-    """Test storing embeddings with proper schema handling."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch("prisma.get_client") as mock_get_client:
-            mock_client = AsyncMock()
-            mock_get_client.return_value = mock_client
-
-            result = await embeddings.store_content_embedding(
-                content_type=ContentType.STORE_AGENT,
-                content_id="test-id",
-                embedding=[0.1] * 1536,
-                searchable_text="test text",
-                metadata={"test": "data"},
-                user_id=None,
-            )
-
-            # Verify the query was called
-            assert mock_client.execute_raw.called
-
-            # Get the SQL query that was executed
-            call_args = mock_client.execute_raw.call_args
-            sql_query = call_args[0][0]
-
-            # Verify schema prefix is in the query
-            assert '"platform"."UnifiedContentEmbedding"' in sql_query
-
-            # Verify result
-            assert result is True
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_get_content_embedding_with_schema():
-    """Test retrieving embeddings with proper schema handling."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch("prisma.get_client") as mock_get_client:
-            mock_client = AsyncMock()
-            mock_client.query_raw.return_value = [
-                {
-                    "contentType": "STORE_AGENT",
-                    "contentId": "test-id",
-                    "userId": None,
-                    "embedding": "[0.1, 0.2]",
-                    "searchableText": "test",
-                    "metadata": {},
-                    "createdAt": "2024-01-01",
-                    "updatedAt": "2024-01-01",
-                }
-            ]
-            mock_get_client.return_value = mock_client
-
-            result = await embeddings.get_content_embedding(
-                ContentType.STORE_AGENT,
-                "test-id",
-                user_id=None,
-            )
-
-            # Verify the query was called
-            assert mock_client.query_raw.called
-
-            # Get the SQL query that was executed
-            call_args = mock_client.query_raw.call_args
-            sql_query = call_args[0][0]
-
-            # Verify schema prefix is in the query
-            assert '"platform"."UnifiedContentEmbedding"' in sql_query
-
-            # Verify result
-            assert result is not None
-            assert result["contentId"] == "test-id"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_delete_content_embedding_with_schema():
-    """Test deleting embeddings with proper schema handling."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch("prisma.get_client") as mock_get_client:
-            mock_client = AsyncMock()
-            mock_get_client.return_value = mock_client
-
-            result = await embeddings.delete_content_embedding(
-                ContentType.STORE_AGENT,
-                "test-id",
-            )
-
-            # Verify the query was called
-            assert mock_client.execute_raw.called
-
-            # Get the SQL query that was executed
-            call_args = mock_client.execute_raw.call_args
-            sql_query = call_args[0][0]
-
-            # Verify schema prefix is in the query
-            assert '"platform"."UnifiedContentEmbedding"' in sql_query
-
-            # Verify result
-            assert result is True
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_get_embedding_stats_with_schema():
-    """Test embedding statistics with proper schema handling."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch("prisma.get_client") as mock_get_client:
-            mock_client = AsyncMock()
-            # Mock both query results
-            mock_client.query_raw.side_effect = [
-                [{"count": 100}],  # total_approved
-                [{"count": 80}],  # with_embeddings
-            ]
-            mock_get_client.return_value = mock_client
-
-            result = await embeddings.get_embedding_stats()
-
-            # Verify both queries were called
-            assert mock_client.query_raw.call_count == 2
-
-            # Get both SQL queries
-            first_call = mock_client.query_raw.call_args_list[0]
-            second_call = mock_client.query_raw.call_args_list[1]
-
-            first_sql = first_call[0][0]
-            second_sql = second_call[0][0]
-
-            # Verify schema prefix in both queries
-            assert '"platform"."StoreListingVersion"' in first_sql
-            assert '"platform"."StoreListingVersion"' in second_sql
-            assert '"platform"."UnifiedContentEmbedding"' in second_sql
-
-            # Verify results
-            assert result["total_approved"] == 100
-            assert result["with_embeddings"] == 80
-            assert result["without_embeddings"] == 20
-            assert result["coverage_percent"] == 80.0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_backfill_missing_embeddings_with_schema():
-    """Test backfilling embeddings with proper schema handling."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch("prisma.get_client") as mock_get_client:
-            mock_client = AsyncMock()
-            # Mock missing embeddings query
-            mock_client.query_raw.return_value = [
-                {
-                    "id": "version-1",
-                    "name": "Test Agent",
-                    "description": "Test description",
-                    "subHeading": "Test heading",
-                    "categories": ["test"],
-                }
-            ]
-            mock_get_client.return_value = mock_client
-
-            with patch(
-                "backend.api.features.store.embeddings.ensure_embedding"
-            ) as mock_ensure:
-                mock_ensure.return_value = True
-
-                result = await embeddings.backfill_missing_embeddings(batch_size=10)
-
-                # Verify the query was called
-                assert mock_client.query_raw.called
-
-                # Get the SQL query
-                call_args = mock_client.query_raw.call_args
-                sql_query = call_args[0][0]
-
-                # Verify schema prefix in query
-                assert '"platform"."StoreListingVersion"' in sql_query
-                assert '"platform"."UnifiedContentEmbedding"' in sql_query
-
-                # Verify ensure_embedding was called
-                assert mock_ensure.called
-
-                # Verify results
-                assert result["processed"] == 1
-                assert result["success"] == 1
-                assert result["failed"] == 0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_ensure_content_embedding_with_schema():
-    """Test ensuring embeddings exist with proper schema handling."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch(
-            "backend.api.features.store.embeddings.get_content_embedding"
-        ) as mock_get:
-            # Simulate no existing embedding
-            mock_get.return_value = None
-
-            with patch(
-                "backend.api.features.store.embeddings.generate_embedding"
-            ) as mock_generate:
-                mock_generate.return_value = [0.1] * 1536
-
-                with patch(
-                    "backend.api.features.store.embeddings.store_content_embedding"
-                ) as mock_store:
-                    mock_store.return_value = True
-
-                    result = await embeddings.ensure_content_embedding(
-                        content_type=ContentType.STORE_AGENT,
-                        content_id="test-id",
-                        searchable_text="test text",
-                        metadata={"test": "data"},
-                        user_id=None,
-                        force=False,
-                    )
-
-                    # Verify the flow
-                    assert mock_get.called
-                    assert mock_generate.called
-                    assert mock_store.called
-                    assert result is True
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_backward_compatibility_store_embedding():
-    """Test backward compatibility wrapper for store_embedding."""
-    with patch(
-        "backend.api.features.store.embeddings.store_content_embedding"
-    ) as mock_store:
-        mock_store.return_value = True
-
-        result = await embeddings.store_embedding(
-            version_id="test-version-id",
-            embedding=[0.1] * 1536,
-            tx=None,
-        )
-
-        # Verify it calls the new function with correct parameters
-        assert mock_store.called
-        call_args = mock_store.call_args
-
-        assert call_args[1]["content_type"] == ContentType.STORE_AGENT
-        assert call_args[1]["content_id"] == "test-version-id"
-        assert call_args[1]["user_id"] is None
-        assert result is True
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_backward_compatibility_get_embedding():
-    """Test backward compatibility wrapper for get_embedding."""
-    with patch(
-        "backend.api.features.store.embeddings.get_content_embedding"
-    ) as mock_get:
-        mock_get.return_value = {
-            "contentType": "STORE_AGENT",
-            "contentId": "test-version-id",
-            "embedding": "[0.1, 0.2]",
-            "createdAt": "2024-01-01",
-            "updatedAt": "2024-01-01",
-        }
-
-        result = await embeddings.get_embedding("test-version-id")
-
-        # Verify it calls the new function
-        assert mock_get.called
-
-        # Verify it transforms to old format
-        assert result is not None
-        assert result["storeListingVersionId"] == "test-version-id"
-        assert "embedding" in result
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_schema_handling_error_cases():
-    """Test error handling in schema-aware operations."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch("prisma.get_client") as mock_get_client:
-            mock_client = AsyncMock()
-            mock_client.execute_raw.side_effect = Exception("Database error")
-            mock_get_client.return_value = mock_client
-
-            result = await embeddings.store_content_embedding(
-                content_type=ContentType.STORE_AGENT,
-                content_id="test-id",
-                embedding=[0.1] * 1536,
-                searchable_text="test",
-                metadata=None,
-                user_id=None,
-            )
-
-            # Should return False on error, not raise
-            assert result is False
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v", "-s"])

autogpt_platform/backend/backend/api/features/store/embeddings_test.py

@@ -1,348 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import prisma
-import pytest
-from prisma import Prisma
-from prisma.enums import ContentType
-
-from backend.api.features.store import embeddings
-
-
-@pytest.fixture(autouse=True)
-async def setup_prisma():
-    """Setup Prisma client for tests."""
-    try:
-        Prisma()
-    except prisma.errors.ClientAlreadyRegisteredError:
-        pass
-    yield
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_build_searchable_text():
-    """Test searchable text building from listing fields."""
-    result = embeddings.build_searchable_text(
-        name="AI Assistant",
-        description="A helpful AI assistant for productivity",
-        sub_heading="Boost your productivity",
-        categories=["AI", "Productivity"],
-    )
-
-    expected = "AI Assistant Boost your productivity A helpful AI assistant for productivity AI Productivity"
-    assert result == expected
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_build_searchable_text_empty_fields():
-    """Test searchable text building with empty fields."""
-    result = embeddings.build_searchable_text(
-        name="", description="Test description", sub_heading="", categories=[]
-    )
-
-    assert result == "Test description"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.util.clients.get_openai_client")
-async def test_generate_embedding_success(mock_get_client):
-    """Test successful embedding generation."""
-    # Mock OpenAI response
-    mock_client = MagicMock()
-    mock_response = MagicMock()
-    mock_response.data = [MagicMock()]
-    mock_response.data[0].embedding = [0.1, 0.2, 0.3] * 512  # 1536 dimensions
-    mock_client.embeddings.create.return_value = mock_response
-    mock_get_client.return_value = mock_client
-
-    result = await embeddings.generate_embedding("test text")
-
-    assert result is not None
-    assert len(result) == 1536
-    assert result[0] == 0.1
-
-    mock_client.embeddings.create.assert_called_once_with(
-        model="text-embedding-3-small", input="test text"
-    )
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.util.clients.get_openai_client")
-async def test_generate_embedding_no_api_key(mock_get_client):
-    """Test embedding generation without API key."""
-    mock_get_client.return_value = None
-
-    result = await embeddings.generate_embedding("test text")
-
-    assert result is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.util.clients.get_openai_client")
-async def test_generate_embedding_api_error(mock_get_client):
-    """Test embedding generation with API error."""
-    mock_client = MagicMock()
-    mock_client.embeddings.create.side_effect = Exception("API Error")
-    mock_get_client.return_value = mock_client
-
-    result = await embeddings.generate_embedding("test text")
-
-    assert result is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.util.clients.get_openai_client")
-async def test_generate_embedding_text_truncation(mock_get_client):
-    """Test that long text is properly truncated."""
-    mock_client = MagicMock()
-    mock_response = MagicMock()
-    mock_response.data = [MagicMock()]
-    mock_response.data[0].embedding = [0.1] * 1536
-    mock_client.embeddings.create.return_value = mock_response
-    mock_get_client.return_value = mock_client
-
-    # Create text longer than 32k chars
-    long_text = "a" * 35000
-
-    await embeddings.generate_embedding(long_text)
-
-    # Verify truncated text was sent to API
-    call_args = mock_client.embeddings.create.call_args
-    assert len(call_args.kwargs["input"]) == 32000
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_embedding_success(mocker):
-    """Test successful embedding storage."""
-    mock_client = mocker.AsyncMock()
-    mock_client.execute_raw = mocker.AsyncMock()
-
-    embedding = [0.1, 0.2, 0.3]
-
-    result = await embeddings.store_embedding(
-        version_id="test-version-id", embedding=embedding, tx=mock_client
-    )
-
-    assert result is True
-    mock_client.execute_raw.assert_called_once()
-    call_args = mock_client.execute_raw.call_args[0]
-    assert "test-version-id" in call_args
-    assert "[0.1,0.2,0.3]" in call_args
-    assert None in call_args  # userId should be None for store agents
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_embedding_database_error(mocker):
-    """Test embedding storage with database error."""
-    mock_client = mocker.AsyncMock()
-    mock_client.execute_raw.side_effect = Exception("Database error")
-
-    embedding = [0.1, 0.2, 0.3]
-
-    result = await embeddings.store_embedding(
-        version_id="test-version-id", embedding=embedding, tx=mock_client
-    )
-
-    assert result is False
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_get_embedding_success(mocker):
-    """Test successful embedding retrieval."""
-    mock_client = mocker.AsyncMock()
-    mock_result = [
-        {
-            "contentType": "STORE_AGENT",
-            "contentId": "test-version-id",
-            "embedding": "[0.1,0.2,0.3]",
-            "searchableText": "Test text",
-            "metadata": {},
-            "createdAt": "2024-01-01T00:00:00Z",
-            "updatedAt": "2024-01-01T00:00:00Z",
-        }
-    ]
-    mock_client.query_raw.return_value = mock_result
-
-    with patch("prisma.get_client", return_value=mock_client):
-        result = await embeddings.get_embedding("test-version-id")
-
-        assert result is not None
-        assert result["storeListingVersionId"] == "test-version-id"
-        assert result["embedding"] == "[0.1,0.2,0.3]"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_get_embedding_not_found(mocker):
-    """Test embedding retrieval when not found."""
-    mock_client = mocker.AsyncMock()
-    mock_client.query_raw.return_value = []
-
-    with patch("prisma.get_client", return_value=mock_client):
-        result = await embeddings.get_embedding("test-version-id")
-
-        assert result is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.api.features.store.embeddings.generate_embedding")
-@patch("backend.api.features.store.embeddings.store_embedding")
-@patch("backend.api.features.store.embeddings.get_embedding")
-async def test_ensure_embedding_already_exists(mock_get, mock_store, mock_generate):
-    """Test ensure_embedding when embedding already exists."""
-    mock_get.return_value = {"embedding": "[0.1,0.2,0.3]"}
-
-    result = await embeddings.ensure_embedding(
-        version_id="test-id",
-        name="Test",
-        description="Test description",
-        sub_heading="Test heading",
-        categories=["test"],
-    )
-
-    assert result is True
-    mock_generate.assert_not_called()
-    mock_store.assert_not_called()
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.api.features.store.embeddings.generate_embedding")
-@patch("backend.api.features.store.embeddings.store_content_embedding")
-@patch("backend.api.features.store.embeddings.get_embedding")
-async def test_ensure_embedding_create_new(mock_get, mock_store, mock_generate):
-    """Test ensure_embedding creating new embedding."""
-    mock_get.return_value = None
-    mock_generate.return_value = [0.1, 0.2, 0.3]
-    mock_store.return_value = True
-
-    result = await embeddings.ensure_embedding(
-        version_id="test-id",
-        name="Test",
-        description="Test description",
-        sub_heading="Test heading",
-        categories=["test"],
-    )
-
-    assert result is True
-    mock_generate.assert_called_once_with("Test Test heading Test description test")
-    mock_store.assert_called_once_with(
-        content_type=ContentType.STORE_AGENT,
-        content_id="test-id",
-        embedding=[0.1, 0.2, 0.3],
-        searchable_text="Test Test heading Test description test",
-        metadata={"name": "Test", "subHeading": "Test heading", "categories": ["test"]},
-        user_id=None,
-        tx=None,
-    )
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.api.features.store.embeddings.generate_embedding")
-@patch("backend.api.features.store.embeddings.get_embedding")
-async def test_ensure_embedding_generation_fails(mock_get, mock_generate):
-    """Test ensure_embedding when generation fails."""
-    mock_get.return_value = None
-    mock_generate.return_value = None
-
-    result = await embeddings.ensure_embedding(
-        version_id="test-id",
-        name="Test",
-        description="Test description",
-        sub_heading="Test heading",
-        categories=["test"],
-    )
-
-    assert result is False
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_get_embedding_stats(mocker):
-    """Test embedding statistics retrieval."""
-    mock_client = mocker.AsyncMock()
-
-    # Mock approved count query
-    mock_approved_result = [{"count": 100}]
-    # Mock embedded count query
-    mock_embedded_result = [{"count": 75}]
-
-    mock_client.query_raw.side_effect = [mock_approved_result, mock_embedded_result]
-
-    with patch("prisma.get_client", return_value=mock_client):
-        result = await embeddings.get_embedding_stats()
-
-        assert result["total_approved"] == 100
-        assert result["with_embeddings"] == 75
-        assert result["without_embeddings"] == 25
-        assert result["coverage_percent"] == 75.0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.api.features.store.embeddings.ensure_embedding")
-async def test_backfill_missing_embeddings_success(mock_ensure, mocker):
-    """Test backfill with successful embedding generation."""
-    mock_client = mocker.AsyncMock()
-
-    # Mock missing embeddings query
-    mock_missing = [
-        {
-            "id": "version-1",
-            "name": "Agent 1",
-            "description": "Description 1",
-            "subHeading": "Heading 1",
-            "categories": ["AI"],
-        },
-        {
-            "id": "version-2",
-            "name": "Agent 2",
-            "description": "Description 2",
-            "subHeading": "Heading 2",
-            "categories": ["Productivity"],
-        },
-    ]
-    mock_client.query_raw.return_value = mock_missing
-
-    # Mock ensure_embedding to succeed for first, fail for second
-    mock_ensure.side_effect = [True, False]
-
-    with patch("prisma.get_client", return_value=mock_client):
-        result = await embeddings.backfill_missing_embeddings(batch_size=5)
-
-        assert result["processed"] == 2
-        assert result["success"] == 1
-        assert result["failed"] == 1
-        assert mock_ensure.call_count == 2
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_backfill_missing_embeddings_no_missing(mocker):
-    """Test backfill when no embeddings are missing."""
-    mock_client = mocker.AsyncMock()
-    mock_client.query_raw.return_value = []
-
-    with patch("prisma.get_client", return_value=mock_client):
-        result = await embeddings.backfill_missing_embeddings(batch_size=5)
-
-        assert result["processed"] == 0
-        assert result["success"] == 0
-        assert result["failed"] == 0
-        assert result["message"] == "No missing embeddings"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_embedding_to_vector_string():
-    """Test embedding to PostgreSQL vector string conversion."""
-    embedding = [0.1, 0.2, 0.3, -0.4]
-    result = embeddings.embedding_to_vector_string(embedding)
-    assert result == "[0.1,0.2,0.3,-0.4]"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_embed_query():
-    """Test embed_query function (alias for generate_embedding)."""
-    with patch(
-        "backend.api.features.store.embeddings.generate_embedding"
-    ) as mock_generate:
-        mock_generate.return_value = [0.1, 0.2, 0.3]
-
-        result = await embeddings.embed_query("test query")
-
-        assert result == [0.1, 0.2, 0.3]
-        mock_generate.assert_called_once_with("test query")

autogpt_platform/backend/backend/api/features/store/hybrid_search.py

@@ -1,388 +0,0 @@
-"""
-Hybrid Search for Store Agents
-
-Combines semantic (embedding) search with lexical (tsvector) search
-for improved relevance in marketplace agent discovery.
-"""
-
-import logging
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Literal
-
-from backend.api.features.store.embeddings import (
-    embed_query,
-    embedding_to_vector_string,
-)
-from backend.data.db import query_raw_with_schema
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class HybridSearchWeights:
-    """Weights for combining search signals."""
-
-    semantic: float = 0.30  # Embedding cosine similarity
-    lexical: float = 0.30  # tsvector ts_rank_cd score
-    category: float = 0.20  # Category match boost
-    recency: float = 0.10  # Newer agents ranked higher
-    popularity: float = 0.10  # Agent usage/runs (PageRank-like)
-
-    def __post_init__(self):
-        """Validate weights are non-negative and sum to approximately 1.0."""
-        total = (
-            self.semantic
-            + self.lexical
-            + self.category
-            + self.recency
-            + self.popularity
-        )
-
-        if any(
-            w < 0
-            for w in [
-                self.semantic,
-                self.lexical,
-                self.category,
-                self.recency,
-                self.popularity,
-            ]
-        ):
-            raise ValueError("All weights must be non-negative")
-
-        if not (0.99 <= total <= 1.01):
-            raise ValueError(f"Weights must sum to ~1.0, got {total:.3f}")
-
-
-DEFAULT_WEIGHTS = HybridSearchWeights()
-
-# Minimum relevance score threshold - agents below this are filtered out
-# With weights (0.30 semantic + 0.30 lexical + 0.20 category + 0.10 recency + 0.10 popularity):
-# - 0.20 means at least ~60% semantic match OR strong lexical match required
-# - Ensures only genuinely relevant results are returned
-# - Recency/popularity alone (0.10 each) won't pass the threshold
-DEFAULT_MIN_SCORE = 0.20
-
-
-@dataclass
-class HybridSearchResult:
-    """A single search result with score breakdown."""
-
-    slug: str
-    agent_name: str
-    agent_image: str
-    creator_username: str
-    creator_avatar: str
-    sub_heading: str
-    description: str
-    runs: int
-    rating: float
-    categories: list[str]
-    featured: bool
-    is_available: bool
-    updated_at: datetime
-
-    # Score breakdown (for debugging/tuning)
-    combined_score: float
-    semantic_score: float = 0.0
-    lexical_score: float = 0.0
-    category_score: float = 0.0
-    recency_score: float = 0.0
-    popularity_score: float = 0.0
-
-
-async def hybrid_search(
-    query: str,
-    featured: bool = False,
-    creators: list[str] | None = None,
-    category: str | None = None,
-    sorted_by: (
-        Literal["relevance", "rating", "runs", "name", "updated_at"] | None
-    ) = None,
-    page: int = 1,
-    page_size: int = 20,
-    weights: HybridSearchWeights | None = None,
-    min_score: float | None = None,
-) -> tuple[list[dict[str, Any]], int]:
-    """
-    Perform hybrid search combining semantic and lexical signals.
-
-    Args:
-        query: Search query string
-        featured: Filter for featured agents only
-        creators: Filter by creator usernames
-        category: Filter by category
-        sorted_by: Sort order (relevance uses hybrid scoring)
-        page: Page number (1-indexed)
-        page_size: Results per page
-        weights: Custom weights for search signals
-        min_score: Minimum relevance score threshold (0-1). Results below
-                   this score are filtered out. Defaults to DEFAULT_MIN_SCORE.
-
-    Returns:
-        Tuple of (results list, total count). Returns empty list if no
-        results meet the minimum relevance threshold.
-    """
-    # Validate inputs
-    query = query.strip()
-    if not query:
-        return [], 0  # Empty query returns no results
-
-    if page < 1:
-        page = 1
-    if page_size < 1:
-        page_size = 1
-    if page_size > 100:  # Cap at reasonable limit to prevent performance issues
-        page_size = 100
-
-    if weights is None:
-        weights = DEFAULT_WEIGHTS
-    if min_score is None:
-        min_score = DEFAULT_MIN_SCORE
-
-    offset = (page - 1) * page_size
-
-    # Generate query embedding
-    query_embedding = await embed_query(query)
-
-    # Build WHERE clause conditions
-    where_parts: list[str] = ["sa.is_available = true"]
-    params: list[Any] = []
-    param_index = 1
-
-    # Add search query for lexical matching
-    params.append(query)
-    query_param = f"${param_index}"
-    param_index += 1
-
-    # Add lowercased query for category matching
-    params.append(query.lower())
-    query_lower_param = f"${param_index}"
-    param_index += 1
-
-    if featured:
-        where_parts.append("sa.featured = true")
-
-    if creators:
-        where_parts.append(f"sa.creator_username = ANY(${param_index})")
-        params.append(creators)
-        param_index += 1
-
-    if category:
-        where_parts.append(f"${param_index} = ANY(sa.categories)")
-        params.append(category)
-        param_index += 1
-
-    # Safe: where_parts only contains hardcoded strings with $N parameter placeholders
-    # No user input is concatenated directly into the SQL string
-    where_clause = " AND ".join(where_parts)
-
-    # Embedding is required for hybrid search - fail fast if unavailable
-    if query_embedding is None:
-        # Log detailed error server-side
-        logger.error(
-            "Failed to generate query embedding. "
-            "Check that openai_internal_api_key is configured and OpenAI API is accessible."
-        )
-        # Raise generic error to client
-        raise ValueError("Search service temporarily unavailable")
-
-    # Add embedding parameter
-    embedding_str = embedding_to_vector_string(query_embedding)
-    params.append(embedding_str)
-    embedding_param = f"${param_index}"
-    param_index += 1
-
-    # Add weight parameters for SQL calculation
-    params.append(weights.semantic)
-    weight_semantic_param = f"${param_index}"
-    param_index += 1
-
-    params.append(weights.lexical)
-    weight_lexical_param = f"${param_index}"
-    param_index += 1
-
-    params.append(weights.category)
-    weight_category_param = f"${param_index}"
-    param_index += 1
-
-    params.append(weights.recency)
-    weight_recency_param = f"${param_index}"
-    param_index += 1
-
-    params.append(weights.popularity)
-    weight_popularity_param = f"${param_index}"
-    param_index += 1
-
-    # Add min_score parameter
-    params.append(min_score)
-    min_score_param = f"${param_index}"
-    param_index += 1
-
-    # Optimized hybrid search query:
-    # 1. Direct join to UnifiedContentEmbedding via contentId=storeListingVersionId (no redundant JOINs)
-    # 2. UNION approach (deduplicates agents matching both branches)
-    # 3. COUNT(*) OVER() to get total count in single query
-    # 4. Optimized category matching with EXISTS + unnest
-    # 5. Pre-calculated max values for lexical and popularity normalization
-    # 6. Simplified recency calculation with linear decay
-    # 7. Logarithmic popularity scaling to prevent viral agents from dominating
-    sql_query = f"""
-            WITH candidates AS (
-                -- Lexical matches (uses GIN index on search column)
-                SELECT sa."storeListingVersionId"
-                FROM {{schema_prefix}}"StoreAgent" sa
-                WHERE {where_clause}
-                AND sa.search @@ plainto_tsquery('english', {query_param})
-
-                UNION
-
-                -- Semantic matches (uses HNSW index on embedding with KNN)
-                SELECT sa."storeListingVersionId"
-                FROM {{schema_prefix}}"StoreAgent" sa
-                INNER JOIN {{schema_prefix}}"UnifiedContentEmbedding" uce
-                    ON sa."storeListingVersionId" = uce."contentId" AND uce."contentType" = 'STORE_AGENT'
-                WHERE {where_clause}
-                ORDER BY uce.embedding <=> {embedding_param}::vector
-                LIMIT 200
-            ),
-            search_scores AS (
-                SELECT
-                    sa.slug,
-                    sa.agent_name,
-                    sa.agent_image,
-                    sa.creator_username,
-                    sa.creator_avatar,
-                    sa.sub_heading,
-                    sa.description,
-                    sa.runs,
-                    sa.rating,
-                    sa.categories,
-                    sa.featured,
-                    sa.is_available,
-                    sa.updated_at,
-                    -- Semantic score: cosine similarity (1 - distance)
-                    COALESCE(1 - (uce.embedding <=> {embedding_param}::vector), 0) as semantic_score,
-                    -- Lexical score: ts_rank_cd (will be normalized later)
-                    COALESCE(ts_rank_cd(sa.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
-                    -- Category match: optimized with unnest for better performance
-                    CASE
-                        WHEN EXISTS (
-                            SELECT 1 FROM unnest(sa.categories) cat
-                            WHERE LOWER(cat) LIKE '%' || {query_lower_param} || '%'
-                        )
-                        THEN 1.0
-                        ELSE 0.0
-                    END as category_score,
-                    -- Recency score: linear decay over 90 days (simpler than exponential)
-                    GREATEST(0, 1 - EXTRACT(EPOCH FROM (NOW() - sa.updated_at)) / (90 * 24 * 3600)) as recency_score,
-                    -- Popularity raw: agent runs count (will be normalized with log scaling)
-                    sa.runs as popularity_raw
-                FROM candidates c
-                INNER JOIN {{schema_prefix}}"StoreAgent" sa
-                    ON c."storeListingVersionId" = sa."storeListingVersionId"
-                LEFT JOIN {{schema_prefix}}"UnifiedContentEmbedding" uce
-                    ON sa."storeListingVersionId" = uce."contentId" AND uce."contentType" = 'STORE_AGENT'
-            ),
-            max_lexical AS (
-                SELECT MAX(lexical_raw) as max_val FROM search_scores
-            ),
-            max_popularity AS (
-                SELECT MAX(popularity_raw) as max_val FROM search_scores
-            ),
-            normalized AS (
-                SELECT
-                    ss.*,
-                    -- Normalize lexical score by pre-calculated max
-                    CASE
-                        WHEN ml.max_val > 0
-                        THEN ss.lexical_raw / ml.max_val
-                        ELSE 0
-                    END as lexical_score,
-                    -- Normalize popularity with logarithmic scaling to prevent viral agents from dominating
-                    -- LOG(1 + runs) / LOG(1 + max_runs) ensures score is 0-1 range
-                    CASE
-                        WHEN mp.max_val > 0 AND ss.popularity_raw > 0
-                        THEN LN(1 + ss.popularity_raw) / LN(1 + mp.max_val)
-                        ELSE 0
-                    END as popularity_score
-                FROM search_scores ss
-                CROSS JOIN max_lexical ml
-                CROSS JOIN max_popularity mp
-            ),
-            scored AS (
-                SELECT
-                    slug,
-                    agent_name,
-                    agent_image,
-                    creator_username,
-                    creator_avatar,
-                    sub_heading,
-                    description,
-                    runs,
-                    rating,
-                    categories,
-                    featured,
-                    is_available,
-                    updated_at,
-                    semantic_score,
-                    lexical_score,
-                    category_score,
-                    recency_score,
-                    popularity_score,
-                    (
-                        {weight_semantic_param} * semantic_score +
-                        {weight_lexical_param} * lexical_score +
-                        {weight_category_param} * category_score +
-                        {weight_recency_param} * recency_score +
-                        {weight_popularity_param} * popularity_score
-                    ) as combined_score
-                FROM normalized
-            ),
-            filtered AS (
-                SELECT
-                    *,
-                    COUNT(*) OVER () as total_count
-                FROM scored
-                WHERE combined_score >= {min_score_param}
-            )
-            SELECT * FROM filtered
-            ORDER BY combined_score DESC
-            LIMIT ${param_index} OFFSET ${param_index + 1}
-    """
-
-    # Add pagination params
-    params.extend([page_size, offset])
-
-    # Execute search query - includes total_count via window function
-    results = await query_raw_with_schema(sql_query, *params)
-
-    # Extract total count from first result (all rows have same count)
-    total = results[0]["total_count"] if results else 0
-
-    # Remove total_count from results before returning
-    for result in results:
-        result.pop("total_count", None)
-
-    # Log without sensitive query content
-    logger.info(f"Hybrid search: {len(results)} results, {total} total")
-
-    return results, total
-
-
-async def hybrid_search_simple(
-    query: str,
-    page: int = 1,
-    page_size: int = 20,
-) -> tuple[list[dict[str, Any]], int]:
-    """
-    Simplified hybrid search for common use cases.
-
-    Uses default weights and no filters.
-    """
-    return await hybrid_search(
-        query=query,
-        page=page,
-        page_size=page_size,
-    )

autogpt_platform/backend/backend/api/features/store/hybrid_search_test.py

@@ -1,334 +0,0 @@
-"""
-Integration tests for hybrid search with schema handling.
-
-These tests verify that hybrid search works correctly across different database schemas.
-"""
-
-from unittest.mock import patch
-
-import pytest
-
-from backend.api.features.store.hybrid_search import HybridSearchWeights, hybrid_search
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_with_schema_handling():
-    """Test that hybrid search correctly handles database schema prefixes."""
-    # Test with a mock query to ensure schema handling works
-    query = "test agent"
-
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        # Mock the query result
-        mock_query.return_value = [
-            {
-                "slug": "test/agent",
-                "agent_name": "Test Agent",
-                "agent_image": "test.png",
-                "creator_username": "test",
-                "creator_avatar": "avatar.png",
-                "sub_heading": "Test sub-heading",
-                "description": "Test description",
-                "runs": 10,
-                "rating": 4.5,
-                "categories": ["test"],
-                "featured": False,
-                "is_available": True,
-                "updated_at": "2024-01-01T00:00:00Z",
-                "combined_score": 0.8,
-                "semantic_score": 0.7,
-                "lexical_score": 0.6,
-                "category_score": 0.5,
-                "recency_score": 0.4,
-                "total_count": 1,
-            }
-        ]
-
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_embed.return_value = [0.1] * 1536  # Mock embedding
-
-            results, total = await hybrid_search(
-                query=query,
-                page=1,
-                page_size=20,
-            )
-
-            # Verify the query was called
-            assert mock_query.called
-            # Verify the SQL template uses schema_prefix placeholder
-            call_args = mock_query.call_args
-            sql_template = call_args[0][0]
-            assert "{schema_prefix}" in sql_template
-
-            # Verify results
-            assert len(results) == 1
-            assert total == 1
-            assert results[0]["slug"] == "test/agent"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_with_public_schema():
-    """Test hybrid search when using public schema (no prefix needed)."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "public"
-
-        with patch(
-            "backend.api.features.store.hybrid_search.query_raw_with_schema"
-        ) as mock_query:
-            mock_query.return_value = []
-
-            with patch(
-                "backend.api.features.store.hybrid_search.embed_query"
-            ) as mock_embed:
-                mock_embed.return_value = [0.1] * 1536
-
-                results, total = await hybrid_search(
-                    query="test",
-                    page=1,
-                    page_size=20,
-                )
-
-                # Verify the mock was set up correctly
-                assert mock_schema.return_value == "public"
-
-                # Results should work even with empty results
-                assert results == []
-                assert total == 0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_with_custom_schema():
-    """Test hybrid search when using custom schema (e.g., 'platform')."""
-    with patch("backend.data.db.get_database_schema") as mock_schema:
-        mock_schema.return_value = "platform"
-
-        with patch(
-            "backend.api.features.store.hybrid_search.query_raw_with_schema"
-        ) as mock_query:
-            mock_query.return_value = []
-
-            with patch(
-                "backend.api.features.store.hybrid_search.embed_query"
-            ) as mock_embed:
-                mock_embed.return_value = [0.1] * 1536
-
-                results, total = await hybrid_search(
-                    query="test",
-                    page=1,
-                    page_size=20,
-                )
-
-                # Verify the mock was set up correctly
-                assert mock_schema.return_value == "platform"
-
-                assert results == []
-                assert total == 0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_without_embeddings():
-    """Test hybrid search fails fast when embeddings are unavailable."""
-    # Patch where the function is used, not where it's defined
-    with patch("backend.api.features.store.hybrid_search.embed_query") as mock_embed:
-        # Simulate embedding failure
-        mock_embed.return_value = None
-
-        # Should raise ValueError with helpful message
-        with pytest.raises(ValueError) as exc_info:
-            await hybrid_search(
-                query="test",
-                page=1,
-                page_size=20,
-            )
-
-        # Verify error message is generic (doesn't leak implementation details)
-        assert "Search service temporarily unavailable" in str(exc_info.value)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_with_filters():
-    """Test hybrid search with various filters."""
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        mock_query.return_value = []
-
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_embed.return_value = [0.1] * 1536
-
-            # Test with featured filter
-            results, total = await hybrid_search(
-                query="test",
-                featured=True,
-                creators=["user1", "user2"],
-                category="productivity",
-                page=1,
-                page_size=10,
-            )
-
-            # Verify filters were applied in the query
-            call_args = mock_query.call_args
-            params = call_args[0][1:]  # Skip SQL template
-
-            # Should have query, query_lower, creators array, category
-            assert len(params) >= 4
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_weights():
-    """Test hybrid search with custom weights."""
-    custom_weights = HybridSearchWeights(
-        semantic=0.5,
-        lexical=0.3,
-        category=0.1,
-        recency=0.1,
-        popularity=0.0,
-    )
-
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        mock_query.return_value = []
-
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_embed.return_value = [0.1] * 1536
-
-            results, total = await hybrid_search(
-                query="test",
-                weights=custom_weights,
-                page=1,
-                page_size=20,
-            )
-
-            # Verify custom weights were used in the query
-            call_args = mock_query.call_args
-            sql_template = call_args[0][0]
-            params = call_args[0][1:]  # Get all parameters passed
-
-            # Check that SQL uses parameterized weights (not f-string interpolation)
-            assert "$" in sql_template  # Verify parameterization is used
-
-            # Check that custom weights are in the params
-            assert 0.5 in params  # semantic weight
-            assert 0.3 in params  # lexical weight
-            assert 0.1 in params  # category and recency weights
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_min_score_filtering():
-    """Test hybrid search minimum score threshold."""
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        # Return results with varying scores
-        mock_query.return_value = [
-            {
-                "slug": "high-score/agent",
-                "agent_name": "High Score Agent",
-                "combined_score": 0.8,
-                "total_count": 1,
-                # ... other fields
-            }
-        ]
-
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_embed.return_value = [0.1] * 1536
-
-            # Test with custom min_score
-            results, total = await hybrid_search(
-                query="test",
-                min_score=0.5,  # High threshold
-                page=1,
-                page_size=20,
-            )
-
-            # Verify min_score was applied in query
-            call_args = mock_query.call_args
-            sql_template = call_args[0][0]
-            params = call_args[0][1:]  # Get all parameters
-
-            # Check that SQL uses parameterized min_score
-            assert "combined_score >=" in sql_template
-            assert "$" in sql_template  # Verify parameterization
-
-            # Check that custom min_score is in the params
-            assert 0.5 in params
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_pagination():
-    """Test hybrid search pagination."""
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        mock_query.return_value = []
-
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_embed.return_value = [0.1] * 1536
-
-            # Test page 2 with page_size 10
-            results, total = await hybrid_search(
-                query="test",
-                page=2,
-                page_size=10,
-            )
-
-            # Verify pagination parameters
-            call_args = mock_query.call_args
-            params = call_args[0]
-
-            # Last two params should be LIMIT and OFFSET
-            limit = params[-2]
-            offset = params[-1]
-
-            assert limit == 10  # page_size
-            assert offset == 10  # (page - 1) * page_size = (2 - 1) * 10
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_hybrid_search_error_handling():
-    """Test hybrid search error handling."""
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        # Simulate database error
-        mock_query.side_effect = Exception("Database connection error")
-
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_embed.return_value = [0.1] * 1536
-
-            # Should raise exception
-            with pytest.raises(Exception) as exc_info:
-                await hybrid_search(
-                    query="test",
-                    page=1,
-                    page_size=20,
-                )
-
-            assert "Database connection error" in str(exc_info.value)
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v", "-s"])

autogpt_platform/backend/backend/api/features/store/model.py

@@ -110,7 +110,6 @@ class Profile(pydantic.BaseModel):
 
 
 class StoreSubmission(pydantic.BaseModel):
-    listing_id: str
     agent_id: str
     agent_version: int
     name: str
@@ -165,12 +164,8 @@ class StoreListingsWithVersionsResponse(pydantic.BaseModel):
 
 
 class StoreSubmissionRequest(pydantic.BaseModel):
-    agent_id: str = pydantic.Field(
-        ..., min_length=1, description="Agent ID cannot be empty"
-    )
-    agent_version: int = pydantic.Field(
-        ..., gt=0, description="Agent version must be greater than 0"
-    )
+    agent_id: str
+    agent_version: int
     slug: str
     name: str
     sub_heading: str

autogpt_platform/backend/backend/api/features/store/model_test.py

@@ -138,7 +138,6 @@ def test_creator_details():
 
 def test_store_submission():
     submission = store_model.StoreSubmission(
-        listing_id="listing123",
         agent_id="agent123",
         agent_version=1,
         sub_heading="Test subheading",
@@ -160,7 +159,6 @@ def test_store_submissions_response():
     response = store_model.StoreSubmissionsResponse(
         submissions=[
             store_model.StoreSubmission(
-                listing_id="listing123",
                 agent_id="agent123",
                 agent_version=1,
                 sub_heading="Test subheading",

autogpt_platform/backend/backend/api/features/store/routes_test.py

@@ -521,7 +521,6 @@ def test_get_submissions_success(
     mocked_value = store_model.StoreSubmissionsResponse(
         submissions=[
             store_model.StoreSubmission(
-                listing_id="test-listing-id",
                 name="Test Agent",
                 description="Test agent description",
                 image_urls=["test.jpg"],

autogpt_platform/backend/backend/blocks/airtable/_webhook.py

@@ -6,9 +6,6 @@ import hashlib
 import hmac
 import logging
 from enum import Enum
-from typing import cast
-
-from prisma.types import Serializable
 
 from backend.sdk import (
     BaseWebhooksManager,
@@ -87,9 +84,7 @@ class AirtableWebhookManager(BaseWebhooksManager):
         # update webhook config
         await update_webhook(
             webhook.id,
-            config=cast(
-                dict[str, Serializable], {"base_id": base_id, "cursor": response.cursor}
-            ),
+            config={"base_id": base_id, "cursor": response.cursor},
         )
 
         event_type = "notification"

autogpt_platform/backend/backend/blocks/helpers/review.py

@@ -1,184 +0,0 @@
-"""
-Shared helpers for Human-In-The-Loop (HITL) review functionality.
-Used by both the dedicated HumanInTheLoopBlock and blocks that require human review.
-"""
-
-import logging
-from typing import Any, Optional
-
-from prisma.enums import ReviewStatus
-from pydantic import BaseModel
-
-from backend.data.execution import ExecutionContext, ExecutionStatus
-from backend.data.human_review import ReviewResult
-from backend.executor.manager import async_update_node_execution_status
-from backend.util.clients import get_database_manager_async_client
-
-logger = logging.getLogger(__name__)
-
-
-class ReviewDecision(BaseModel):
-    """Result of a review decision."""
-
-    should_proceed: bool
-    message: str
-    review_result: ReviewResult
-
-
-class HITLReviewHelper:
-    """Helper class for Human-In-The-Loop review operations."""
-
-    @staticmethod
-    async def get_or_create_human_review(**kwargs) -> Optional[ReviewResult]:
-        """Create or retrieve a human review from the database."""
-        return await get_database_manager_async_client().get_or_create_human_review(
-            **kwargs
-        )
-
-    @staticmethod
-    async def update_node_execution_status(**kwargs) -> None:
-        """Update the execution status of a node."""
-        await async_update_node_execution_status(
-            db_client=get_database_manager_async_client(), **kwargs
-        )
-
-    @staticmethod
-    async def update_review_processed_status(
-        node_exec_id: str, processed: bool
-    ) -> None:
-        """Update the processed status of a review."""
-        return await get_database_manager_async_client().update_review_processed_status(
-            node_exec_id, processed
-        )
-
-    @staticmethod
-    async def _handle_review_request(
-        input_data: Any,
-        user_id: str,
-        node_exec_id: str,
-        graph_exec_id: str,
-        graph_id: str,
-        graph_version: int,
-        execution_context: ExecutionContext,
-        block_name: str = "Block",
-        editable: bool = False,
-    ) -> Optional[ReviewResult]:
-        """
-        Handle a review request for a block that requires human review.
-
-        Args:
-            input_data: The input data to be reviewed
-            user_id: ID of the user requesting the review
-            node_exec_id: ID of the node execution
-            graph_exec_id: ID of the graph execution
-            graph_id: ID of the graph
-            graph_version: Version of the graph
-            execution_context: Current execution context
-            block_name: Name of the block requesting review
-            editable: Whether the reviewer can edit the data
-
-        Returns:
-            ReviewResult if review is complete, None if waiting for human input
-
-        Raises:
-            Exception: If review creation or status update fails
-        """
-        # Skip review if safe mode is disabled - return auto-approved result
-        if not execution_context.safe_mode:
-            logger.info(
-                f"Block {block_name} skipping review for node {node_exec_id} - safe mode disabled"
-            )
-            return ReviewResult(
-                data=input_data,
-                status=ReviewStatus.APPROVED,
-                message="Auto-approved (safe mode disabled)",
-                processed=True,
-                node_exec_id=node_exec_id,
-            )
-
-        result = await HITLReviewHelper.get_or_create_human_review(
-            user_id=user_id,
-            node_exec_id=node_exec_id,
-            graph_exec_id=graph_exec_id,
-            graph_id=graph_id,
-            graph_version=graph_version,
-            input_data=input_data,
-            message=f"Review required for {block_name} execution",
-            editable=editable,
-        )
-
-        if result is None:
-            logger.info(
-                f"Block {block_name} pausing execution for node {node_exec_id} - awaiting human review"
-            )
-            await HITLReviewHelper.update_node_execution_status(
-                exec_id=node_exec_id,
-                status=ExecutionStatus.REVIEW,
-            )
-            return None  # Signal that execution should pause
-
-        # Mark review as processed if not already done
-        if not result.processed:
-            await HITLReviewHelper.update_review_processed_status(
-                node_exec_id=node_exec_id, processed=True
-            )
-
-        return result
-
-    @staticmethod
-    async def handle_review_decision(
-        input_data: Any,
-        user_id: str,
-        node_exec_id: str,
-        graph_exec_id: str,
-        graph_id: str,
-        graph_version: int,
-        execution_context: ExecutionContext,
-        block_name: str = "Block",
-        editable: bool = False,
-    ) -> Optional[ReviewDecision]:
-        """
-        Handle a review request and return the decision in a single call.
-
-        Args:
-            input_data: The input data to be reviewed
-            user_id: ID of the user requesting the review
-            node_exec_id: ID of the node execution
-            graph_exec_id: ID of the graph execution
-            graph_id: ID of the graph
-            graph_version: Version of the graph
-            execution_context: Current execution context
-            block_name: Name of the block requesting review
-            editable: Whether the reviewer can edit the data
-
-        Returns:
-            ReviewDecision if review is complete (approved/rejected),
-            None if execution should pause (awaiting review)
-        """
-        review_result = await HITLReviewHelper._handle_review_request(
-            input_data=input_data,
-            user_id=user_id,
-            node_exec_id=node_exec_id,
-            graph_exec_id=graph_exec_id,
-            graph_id=graph_id,
-            graph_version=graph_version,
-            execution_context=execution_context,
-            block_name=block_name,
-            editable=editable,
-        )
-
-        if review_result is None:
-            # Still awaiting review - return None to pause execution
-            return None
-
-        # Review is complete, determine outcome
-        should_proceed = review_result.status == ReviewStatus.APPROVED
-        message = review_result.message or (
-            "Execution approved by reviewer"
-            if should_proceed
-            else "Execution rejected by reviewer"
-        )
-
-        return ReviewDecision(
-            should_proceed=should_proceed, message=message, review_result=review_result
-        )

autogpt_platform/backend/backend/blocks/human_in_the_loop.py

@@ -3,7 +3,6 @@ from typing import Any
 
 from prisma.enums import ReviewStatus
 
-from backend.blocks.helpers.review import HITLReviewHelper
 from backend.data.block import (
     Block,
     BlockCategory,
@@ -12,9 +11,11 @@ from backend.data.block import (
     BlockSchemaOutput,
     BlockType,
 )
-from backend.data.execution import ExecutionContext
+from backend.data.execution import ExecutionContext, ExecutionStatus
 from backend.data.human_review import ReviewResult
 from backend.data.model import SchemaField
+from backend.executor.manager import async_update_node_execution_status
+from backend.util.clients import get_database_manager_async_client
 
 logger = logging.getLogger(__name__)
 
@@ -71,26 +72,32 @@ class HumanInTheLoopBlock(Block):
                 ("approved_data", {"name": "John Doe", "age": 30}),
             ],
             test_mock={
-                "handle_review_decision": lambda **kwargs: type(
-                    "ReviewDecision",
-                    (),
-                    {
-                        "should_proceed": True,
-                        "message": "Test approval message",
-                        "review_result": ReviewResult(
-                            data={"name": "John Doe", "age": 30},
-                            status=ReviewStatus.APPROVED,
-                            message="",
-                            processed=False,
-                            node_exec_id="test-node-exec-id",
-                        ),
-                    },
-                )(),
+                "get_or_create_human_review": lambda *_args, **_kwargs: ReviewResult(
+                    data={"name": "John Doe", "age": 30},
+                    status=ReviewStatus.APPROVED,
+                    message="",
+                    processed=False,
+                    node_exec_id="test-node-exec-id",
+                ),
+                "update_node_execution_status": lambda *_args, **_kwargs: None,
+                "update_review_processed_status": lambda *_args, **_kwargs: None,
             },
         )
 
-    async def handle_review_decision(self, **kwargs):
-        return await HITLReviewHelper.handle_review_decision(**kwargs)
+    async def get_or_create_human_review(self, **kwargs):
+        return await get_database_manager_async_client().get_or_create_human_review(
+            **kwargs
+        )
+
+    async def update_node_execution_status(self, **kwargs):
+        return await async_update_node_execution_status(
+            db_client=get_database_manager_async_client(), **kwargs
+        )
+
+    async def update_review_processed_status(self, node_exec_id: str, processed: bool):
+        return await get_database_manager_async_client().update_review_processed_status(
+            node_exec_id, processed
+        )
 
     async def run(
         self,
@@ -102,7 +109,7 @@ class HumanInTheLoopBlock(Block):
         graph_id: str,
         graph_version: int,
         execution_context: ExecutionContext,
-        **_kwargs,
+        **kwargs,
     ) -> BlockOutput:
         if not execution_context.safe_mode:
             logger.info(
@@ -112,28 +119,48 @@ class HumanInTheLoopBlock(Block):
             yield "review_message", "Auto-approved (safe mode disabled)"
             return
 
-        decision = await self.handle_review_decision(
-            input_data=input_data.data,
-            user_id=user_id,
-            node_exec_id=node_exec_id,
-            graph_exec_id=graph_exec_id,
-            graph_id=graph_id,
-            graph_version=graph_version,
-            execution_context=execution_context,
-            block_name=self.name,
-            editable=input_data.editable,
-        )
+        try:
+            result = await self.get_or_create_human_review(
+                user_id=user_id,
+                node_exec_id=node_exec_id,
+                graph_exec_id=graph_exec_id,
+                graph_id=graph_id,
+                graph_version=graph_version,
+                input_data=input_data.data,
+                message=input_data.name,
+                editable=input_data.editable,
+            )
+        except Exception as e:
+            logger.error(f"Error in HITL block for node {node_exec_id}: {str(e)}")
+            raise
 
-        if decision is None:
-            return
+        if result is None:
+            logger.info(
+                f"HITL block pausing execution for node {node_exec_id} - awaiting human review"
+            )
+            try:
+                await self.update_node_execution_status(
+                    exec_id=node_exec_id,
+                    status=ExecutionStatus.REVIEW,
+                )
+                return
+            except Exception as e:
+                logger.error(
+                    f"Failed to update node status for HITL block {node_exec_id}: {str(e)}"
+                )
+                raise
 
-        status = decision.review_result.status
-        if status == ReviewStatus.APPROVED:
-            yield "approved_data", decision.review_result.data
-        elif status == ReviewStatus.REJECTED:
-            yield "rejected_data", decision.review_result.data
-        else:
-            raise RuntimeError(f"Unexpected review status: {status}")
+        if not result.processed:
+            await self.update_review_processed_status(
+                node_exec_id=node_exec_id, processed=True
+            )
 
-        if decision.message:
-            yield "review_message", decision.message
+            if result.status == ReviewStatus.APPROVED:
+                yield "approved_data", result.data
+                if result.message:
+                    yield "review_message", result.message
+
+            elif result.status == ReviewStatus.REJECTED:
+                yield "rejected_data", result.data
+                if result.message:
+                    yield "review_message", result.message

autogpt_platform/backend/backend/blocks/search.py

@@ -18,7 +18,6 @@ from backend.data.model import (
     SchemaField,
 )
 from backend.integrations.providers import ProviderName
-from backend.util.request import DEFAULT_USER_AGENT
 
 
 class GetWikipediaSummaryBlock(Block, GetRequest):
@@ -40,27 +39,17 @@ class GetWikipediaSummaryBlock(Block, GetRequest):
             output_schema=GetWikipediaSummaryBlock.Output,
             test_input={"topic": "Artificial Intelligence"},
             test_output=("summary", "summary content"),
-            test_mock={
-                "get_request": lambda url, headers, json: {"extract": "summary content"}
-            },
+            test_mock={"get_request": lambda url, json: {"extract": "summary content"}},
         )
 
     async def run(self, input_data: Input, **kwargs) -> BlockOutput:
         topic = input_data.topic
-        # URL-encode the topic to handle spaces and special characters
-        encoded_topic = quote(topic, safe="")
-        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{encoded_topic}"
-
-        # Set headers per Wikimedia robot policy (https://w.wiki/4wJS)
-        # - User-Agent: Required, must identify the bot
-        # - Accept-Encoding: gzip recommended to reduce bandwidth
-        headers = {
-            "User-Agent": DEFAULT_USER_AGENT,
-            "Accept-Encoding": "gzip, deflate",
-        }
+        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{topic}"
 
+        # Note: User-Agent is now automatically set by the request library
+        # to comply with Wikimedia's robot policy (https://w.wiki/4wJS)
         try:
-            response = await self.get_request(url, headers=headers, json=True)
+            response = await self.get_request(url, json=True)
             if "extract" not in response:
                 raise ValueError(f"Unable to parse Wikipedia response: {response}")
             yield "summary", response["extract"]

autogpt_platform/backend/backend/blocks/smart_decision_maker.py

@@ -391,12 +391,8 @@ class SmartDecisionMakerBlock(Block):
         """
         block = sink_node.block
 
-        # Use custom name from node metadata if set, otherwise fall back to block.name
-        custom_name = sink_node.metadata.get("customized_name")
-        tool_name = custom_name if custom_name else block.name
-
         tool_function: dict[str, Any] = {
-            "name": SmartDecisionMakerBlock.cleanup(tool_name),
+            "name": SmartDecisionMakerBlock.cleanup(block.name),
             "description": block.description,
         }
         sink_block_input_schema = block.input_schema
@@ -493,12 +489,8 @@ class SmartDecisionMakerBlock(Block):
                 f"Sink graph metadata not found: {graph_id} {graph_version}"
             )
 
-        # Use custom name from node metadata if set, otherwise fall back to graph name
-        custom_name = sink_node.metadata.get("customized_name")
-        tool_name = custom_name if custom_name else sink_graph_meta.name
-
         tool_function: dict[str, Any] = {
-            "name": SmartDecisionMakerBlock.cleanup(tool_name),
+            "name": SmartDecisionMakerBlock.cleanup(sink_graph_meta.name),
             "description": sink_graph_meta.description,
         }
 
@@ -989,28 +981,10 @@ class SmartDecisionMakerBlock(Block):
         graph_version: int,
         execution_context: ExecutionContext,
         execution_processor: "ExecutionProcessor",
-        nodes_to_skip: set[str] | None = None,
         **kwargs,
     ) -> BlockOutput:
 
         tool_functions = await self._create_tool_node_signatures(node_id)
-        original_tool_count = len(tool_functions)
-
-        # Filter out tools for nodes that should be skipped (e.g., missing optional credentials)
-        if nodes_to_skip:
-            tool_functions = [
-                tf
-                for tf in tool_functions
-                if tf.get("function", {}).get("_sink_node_id") not in nodes_to_skip
-            ]
-
-            # Only raise error if we had tools but they were all filtered out
-            if original_tool_count > 0 and not tool_functions:
-                raise ValueError(
-                    "No available tools to execute - all downstream nodes are unavailable "
-                    "(possibly due to missing optional credentials)"
-                )
-
         yield "tool_functions", json.dumps(tool_functions)
 
         conversation_history = input_data.conversation_history or []

autogpt_platform/backend/backend/blocks/test/test_smart_decision_maker.py

@@ -1057,153 +1057,3 @@ async def test_smart_decision_maker_traditional_mode_default():
         )  # Should yield individual tool parameters
         assert "tools_^_test-sink-node-id_~_max_keyword_difficulty" in outputs
         assert "conversations" in outputs
-
-
-@pytest.mark.asyncio
-async def test_smart_decision_maker_uses_customized_name_for_blocks():
-    """Test that SmartDecisionMakerBlock uses customized_name from node metadata for tool names."""
-    from unittest.mock import MagicMock
-
-    from backend.blocks.basic import StoreValueBlock
-    from backend.blocks.smart_decision_maker import SmartDecisionMakerBlock
-    from backend.data.graph import Link, Node
-
-    # Create a mock node with customized_name in metadata
-    mock_node = MagicMock(spec=Node)
-    mock_node.id = "test-node-id"
-    mock_node.block_id = StoreValueBlock().id
-    mock_node.metadata = {"customized_name": "My Custom Tool Name"}
-    mock_node.block = StoreValueBlock()
-
-    # Create a mock link
-    mock_link = MagicMock(spec=Link)
-    mock_link.sink_name = "input"
-
-    # Call the function directly
-    result = await SmartDecisionMakerBlock._create_block_function_signature(
-        mock_node, [mock_link]
-    )
-
-    # Verify the tool name uses the customized name (cleaned up)
-    assert result["type"] == "function"
-    assert result["function"]["name"] == "my_custom_tool_name"  # Cleaned version
-    assert result["function"]["_sink_node_id"] == "test-node-id"
-
-
-@pytest.mark.asyncio
-async def test_smart_decision_maker_falls_back_to_block_name():
-    """Test that SmartDecisionMakerBlock falls back to block.name when no customized_name."""
-    from unittest.mock import MagicMock
-
-    from backend.blocks.basic import StoreValueBlock
-    from backend.blocks.smart_decision_maker import SmartDecisionMakerBlock
-    from backend.data.graph import Link, Node
-
-    # Create a mock node without customized_name
-    mock_node = MagicMock(spec=Node)
-    mock_node.id = "test-node-id"
-    mock_node.block_id = StoreValueBlock().id
-    mock_node.metadata = {}  # No customized_name
-    mock_node.block = StoreValueBlock()
-
-    # Create a mock link
-    mock_link = MagicMock(spec=Link)
-    mock_link.sink_name = "input"
-
-    # Call the function directly
-    result = await SmartDecisionMakerBlock._create_block_function_signature(
-        mock_node, [mock_link]
-    )
-
-    # Verify the tool name uses the block's default name
-    assert result["type"] == "function"
-    assert result["function"]["name"] == "storevalueblock"  # Default block name cleaned
-    assert result["function"]["_sink_node_id"] == "test-node-id"
-
-
-@pytest.mark.asyncio
-async def test_smart_decision_maker_uses_customized_name_for_agents():
-    """Test that SmartDecisionMakerBlock uses customized_name from metadata for agent nodes."""
-    from unittest.mock import AsyncMock, MagicMock, patch
-
-    from backend.blocks.smart_decision_maker import SmartDecisionMakerBlock
-    from backend.data.graph import Link, Node
-
-    # Create a mock node with customized_name in metadata
-    mock_node = MagicMock(spec=Node)
-    mock_node.id = "test-agent-node-id"
-    mock_node.metadata = {"customized_name": "My Custom Agent"}
-    mock_node.input_default = {
-        "graph_id": "test-graph-id",
-        "graph_version": 1,
-        "input_schema": {"properties": {"test_input": {"description": "Test input"}}},
-    }
-
-    # Create a mock link
-    mock_link = MagicMock(spec=Link)
-    mock_link.sink_name = "test_input"
-
-    # Mock the database client
-    mock_graph_meta = MagicMock()
-    mock_graph_meta.name = "Original Agent Name"
-    mock_graph_meta.description = "Agent description"
-
-    mock_db_client = AsyncMock()
-    mock_db_client.get_graph_metadata.return_value = mock_graph_meta
-
-    with patch(
-        "backend.blocks.smart_decision_maker.get_database_manager_async_client",
-        return_value=mock_db_client,
-    ):
-        result = await SmartDecisionMakerBlock._create_agent_function_signature(
-            mock_node, [mock_link]
-        )
-
-    # Verify the tool name uses the customized name (cleaned up)
-    assert result["type"] == "function"
-    assert result["function"]["name"] == "my_custom_agent"  # Cleaned version
-    assert result["function"]["_sink_node_id"] == "test-agent-node-id"
-
-
-@pytest.mark.asyncio
-async def test_smart_decision_maker_agent_falls_back_to_graph_name():
-    """Test that agent node falls back to graph name when no customized_name."""
-    from unittest.mock import AsyncMock, MagicMock, patch
-
-    from backend.blocks.smart_decision_maker import SmartDecisionMakerBlock
-    from backend.data.graph import Link, Node
-
-    # Create a mock node without customized_name
-    mock_node = MagicMock(spec=Node)
-    mock_node.id = "test-agent-node-id"
-    mock_node.metadata = {}  # No customized_name
-    mock_node.input_default = {
-        "graph_id": "test-graph-id",
-        "graph_version": 1,
-        "input_schema": {"properties": {"test_input": {"description": "Test input"}}},
-    }
-
-    # Create a mock link
-    mock_link = MagicMock(spec=Link)
-    mock_link.sink_name = "test_input"
-
-    # Mock the database client
-    mock_graph_meta = MagicMock()
-    mock_graph_meta.name = "Original Agent Name"
-    mock_graph_meta.description = "Agent description"
-
-    mock_db_client = AsyncMock()
-    mock_db_client.get_graph_metadata.return_value = mock_graph_meta
-
-    with patch(
-        "backend.blocks.smart_decision_maker.get_database_manager_async_client",
-        return_value=mock_db_client,
-    ):
-        result = await SmartDecisionMakerBlock._create_agent_function_signature(
-            mock_node, [mock_link]
-        )
-
-    # Verify the tool name uses the graph's default name
-    assert result["type"] == "function"
-    assert result["function"]["name"] == "original_agent_name"  # Graph name cleaned
-    assert result["function"]["_sink_node_id"] == "test-agent-node-id"

autogpt_platform/backend/backend/blocks/test/test_smart_decision_maker_dict.py

@@ -15,7 +15,6 @@ async def test_smart_decision_maker_handles_dynamic_dict_fields():
     mock_node.block = CreateDictionaryBlock()
     mock_node.block_id = CreateDictionaryBlock().id
     mock_node.input_default = {}
-    mock_node.metadata = {}
 
     # Create mock links with dynamic dictionary fields
     mock_links = [
@@ -78,7 +77,6 @@ async def test_smart_decision_maker_handles_dynamic_list_fields():
     mock_node.block = AddToListBlock()
     mock_node.block_id = AddToListBlock().id
     mock_node.input_default = {}
-    mock_node.metadata = {}
 
     # Create mock links with dynamic list fields
     mock_links = [

autogpt_platform/backend/backend/blocks/test/test_smart_decision_maker_dynamic_fields.py

@@ -44,7 +44,6 @@ async def test_create_block_function_signature_with_dict_fields():
     mock_node.block = CreateDictionaryBlock()
     mock_node.block_id = CreateDictionaryBlock().id
     mock_node.input_default = {}
-    mock_node.metadata = {}
 
     # Create mock links with dynamic dictionary fields (source sanitized, sink original)
     mock_links = [
@@ -107,7 +106,6 @@ async def test_create_block_function_signature_with_list_fields():
     mock_node.block = AddToListBlock()
     mock_node.block_id = AddToListBlock().id
     mock_node.input_default = {}
-    mock_node.metadata = {}
 
     # Create mock links with dynamic list fields
     mock_links = [
@@ -161,7 +159,6 @@ async def test_create_block_function_signature_with_object_fields():
     mock_node.block = MatchTextPatternBlock()
     mock_node.block_id = MatchTextPatternBlock().id
     mock_node.input_default = {}
-    mock_node.metadata = {}
 
     # Create mock links with dynamic object fields
     mock_links = [
@@ -211,13 +208,11 @@ async def test_create_tool_node_signatures():
         mock_dict_node.block = CreateDictionaryBlock()
         mock_dict_node.block_id = CreateDictionaryBlock().id
         mock_dict_node.input_default = {}
-        mock_dict_node.metadata = {}
 
         mock_list_node = Mock()
         mock_list_node.block = AddToListBlock()
         mock_list_node.block_id = AddToListBlock().id
         mock_list_node.input_default = {}
-        mock_list_node.metadata = {}
 
         # Mock links with dynamic fields
         dict_link1 = Mock(
@@ -428,7 +423,6 @@ async def test_mixed_regular_and_dynamic_fields():
     mock_node.block.name = "TestBlock"
     mock_node.block.description = "A test block"
     mock_node.block.input_schema = Mock()
-    mock_node.metadata = {}
 
     # Mock the get_field_schema to return a proper schema for regular fields
     def get_field_schema(field_name):

autogpt_platform/backend/backend/blocks/wordpress/__init__.py

@@ -1,3 +1,3 @@
-from .blog import WordPressCreatePostBlock, WordPressGetAllPostsBlock
+from .blog import WordPressCreatePostBlock
 
-__all__ = ["WordPressCreatePostBlock", "WordPressGetAllPostsBlock"]
+__all__ = ["WordPressCreatePostBlock"]

autogpt_platform/backend/backend/blocks/wordpress/_api.py

@@ -161,7 +161,7 @@ async def oauth_exchange_code_for_tokens(
         grant_type="authorization_code",
     ).model_dump(exclude_none=True)
 
-    response = await Requests(raise_for_status=False).post(
+    response = await Requests().post(
         f"{WORDPRESS_BASE_URL}oauth2/token",
         headers=headers,
         data=data,
@@ -205,7 +205,7 @@ async def oauth_refresh_tokens(
         grant_type="refresh_token",
     ).model_dump(exclude_none=True)
 
-    response = await Requests(raise_for_status=False).post(
+    response = await Requests().post(
         f"{WORDPRESS_BASE_URL}oauth2/token",
         headers=headers,
         data=data,
@@ -252,7 +252,7 @@ async def validate_token(
         "token": token,
     }
 
-    response = await Requests(raise_for_status=False).get(
+    response = await Requests().get(
         f"{WORDPRESS_BASE_URL}oauth2/token-info",
         params=params,
     )
@@ -296,7 +296,7 @@ async def make_api_request(
 
     url = f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}"
 
-    request_method = getattr(Requests(raise_for_status=False), method.lower())
+    request_method = getattr(Requests(), method.lower())
     response = await request_method(
         url,
         headers=headers,
@@ -476,7 +476,6 @@ async def create_post(
         data["tags"] = ",".join(str(t) for t in data["tags"])
 
     # Make the API request
-    site = normalize_site(site)
     endpoint = f"/rest/v1.1/sites/{site}/posts/new"
 
     headers = {
@@ -484,7 +483,7 @@ async def create_post(
         "Content-Type": "application/x-www-form-urlencoded",
     }
 
-    response = await Requests(raise_for_status=False).post(
+    response = await Requests().post(
         f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}",
         headers=headers,
         data=data,
@@ -500,132 +499,3 @@ async def create_post(
     )
     error_message = error_data.get("message", response.text)
     raise ValueError(f"Failed to create post: {response.status} - {error_message}")
-
-
-class Post(BaseModel):
-    """Response model for individual posts in a posts list response.
-
-    This is a simplified version compared to PostResponse, as the list endpoint
-    returns less detailed information than the create/get single post endpoints.
-    """
-
-    ID: int
-    site_ID: int
-    author: PostAuthor
-    date: datetime
-    modified: datetime
-    title: str
-    URL: str
-    short_URL: str
-    content: str | None = None
-    excerpt: str | None = None
-    slug: str
-    guid: str
-    status: str
-    sticky: bool
-    password: str | None = ""
-    parent: Union[Dict[str, Any], bool, None] = None
-    type: str
-    discussion: Dict[str, Union[str, bool, int]] | None = None
-    likes_enabled: bool | None = None
-    sharing_enabled: bool | None = None
-    like_count: int | None = None
-    i_like: bool | None = None
-    is_reblogged: bool | None = None
-    is_following: bool | None = None
-    global_ID: str | None = None
-    featured_image: str | None = None
-    post_thumbnail: Dict[str, Any] | None = None
-    format: str | None = None
-    geo: Union[Dict[str, Any], bool, None] = None
-    menu_order: int | None = None
-    page_template: str | None = None
-    publicize_URLs: List[str] | None = None
-    terms: Dict[str, Dict[str, Any]] | None = None
-    tags: Dict[str, Dict[str, Any]] | None = None
-    categories: Dict[str, Dict[str, Any]] | None = None
-    attachments: Dict[str, Dict[str, Any]] | None = None
-    attachment_count: int | None = None
-    metadata: List[Dict[str, Any]] | None = None
-    meta: Dict[str, Any] | None = None
-    capabilities: Dict[str, bool] | None = None
-    revisions: List[int] | None = None
-    other_URLs: Dict[str, Any] | None = None
-
-
-class PostsResponse(BaseModel):
-    """Response model for WordPress posts list."""
-
-    found: int
-    posts: List[Post]
-    meta: Dict[str, Any]
-
-
-def normalize_site(site: str) -> str:
-    """
-    Normalize a site identifier by stripping protocol and trailing slashes.
-
-    Args:
-        site: Site URL, domain, or ID (e.g., "https://myblog.wordpress.com/", "myblog.wordpress.com", "123456789")
-
-    Returns:
-        Normalized site identifier (domain or ID only)
-    """
-    site = site.strip()
-    if site.startswith("https://"):
-        site = site[8:]
-    elif site.startswith("http://"):
-        site = site[7:]
-    return site.rstrip("/")
-
-
-async def get_posts(
-    credentials: Credentials,
-    site: str,
-    status: PostStatus | None = None,
-    number: int = 100,
-    offset: int = 0,
-) -> PostsResponse:
-    """
-    Get posts from a WordPress site.
-
-    Args:
-        credentials: OAuth credentials
-        site: Site ID or domain (e.g., "myblog.wordpress.com" or "123456789")
-        status: Filter by post status using PostStatus enum, or None for all
-        number: Number of posts to retrieve (max 100)
-        offset: Number of posts to skip (for pagination)
-
-    Returns:
-        PostsResponse with the list of posts
-    """
-    site = normalize_site(site)
-    endpoint = f"/rest/v1.1/sites/{site}/posts"
-
-    headers = {
-        "Authorization": credentials.auth_header(),
-    }
-
-    params: Dict[str, Any] = {
-        "number": max(1, min(number, 100)),  # 1–100 posts per request
-        "offset": offset,
-    }
-
-    if status:
-        params["status"] = status.value
-    response = await Requests(raise_for_status=False).get(
-        f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}",
-        headers=headers,
-        params=params,
-    )
-
-    if response.ok:
-        return PostsResponse.model_validate(response.json())
-
-    error_data = (
-        response.json()
-        if response.headers.get("content-type", "").startswith("application/json")
-        else {}
-    )
-    error_message = error_data.get("message", response.text)
-    raise ValueError(f"Failed to get posts: {response.status} - {error_message}")

autogpt_platform/backend/backend/blocks/wordpress/blog.py

@@ -9,15 +9,7 @@ from backend.sdk import (
     SchemaField,
 )
 
-from ._api import (
-    CreatePostRequest,
-    Post,
-    PostResponse,
-    PostsResponse,
-    PostStatus,
-    create_post,
-    get_posts,
-)
+from ._api import CreatePostRequest, PostResponse, PostStatus, create_post
 from ._config import wordpress
 
 
@@ -57,15 +49,8 @@ class WordPressCreatePostBlock(Block):
         media_urls: list[str] = SchemaField(
             description="URLs of images to sideload and attach to the post", default=[]
         )
-        publish_as_draft: bool = SchemaField(
-            description="If True, publishes the post as a draft. If False, publishes it publicly.",
-            default=False,
-        )
 
     class Output(BlockSchemaOutput):
-        site: str = SchemaField(
-            description="The site ID or domain (pass-through for chaining with other blocks)"
-        )
         post_id: int = SchemaField(description="The ID of the created post")
         post_url: str = SchemaField(description="The full URL of the created post")
         short_url: str = SchemaField(description="The shortened wp.me URL")
@@ -93,9 +78,7 @@ class WordPressCreatePostBlock(Block):
             tags=input_data.tags,
             featured_image=input_data.featured_image,
             media_urls=input_data.media_urls,
-            status=(
-                PostStatus.DRAFT if input_data.publish_as_draft else PostStatus.PUBLISH
-            ),
+            status=PostStatus.PUBLISH,
         )
 
         post_response: PostResponse = await create_post(
@@ -104,69 +87,7 @@ class WordPressCreatePostBlock(Block):
             post_data=post_request,
         )
 
-        yield "site", input_data.site
         yield "post_id", post_response.ID
         yield "post_url", post_response.URL
         yield "short_url", post_response.short_URL
         yield "post_data", post_response.model_dump()
-
-
-class WordPressGetAllPostsBlock(Block):
-    """
-    Fetches all posts from a WordPress.com site or Jetpack-enabled site.
-    Supports filtering by status and pagination.
-    """
-
-    class Input(BlockSchemaInput):
-        credentials: CredentialsMetaInput = wordpress.credentials_field()
-        site: str = SchemaField(
-            description="Site ID or domain (e.g., 'myblog.wordpress.com' or '123456789')"
-        )
-        status: PostStatus | None = SchemaField(
-            description="Filter by post status, or None for all",
-            default=None,
-        )
-        number: int = SchemaField(
-            description="Number of posts to retrieve (max 100 per request)", default=20
-        )
-        offset: int = SchemaField(
-            description="Number of posts to skip (for pagination)", default=0
-        )
-
-    class Output(BlockSchemaOutput):
-        site: str = SchemaField(
-            description="The site ID or domain (pass-through for chaining with other blocks)"
-        )
-        found: int = SchemaField(description="Total number of posts found")
-        posts: list[Post] = SchemaField(
-            description="List of post objects with their details"
-        )
-        post: Post = SchemaField(
-            description="Individual post object (yielded for each post)"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="97728fa7-7f6f-4789-ba0c-f2c114119536",
-            description="Fetch all posts from WordPress.com or Jetpack sites",
-            categories={BlockCategory.SOCIAL},
-            input_schema=self.Input,
-            output_schema=self.Output,
-        )
-
-    async def run(
-        self, input_data: Input, *, credentials: Credentials, **kwargs
-    ) -> BlockOutput:
-        posts_response: PostsResponse = await get_posts(
-            credentials=credentials,
-            site=input_data.site,
-            status=input_data.status,
-            number=input_data.number,
-            offset=input_data.offset,
-        )
-
-        yield "site", input_data.site
-        yield "found", posts_response.found
-        yield "posts", posts_response.posts
-        for post in posts_response.posts:
-            yield "post", post

autogpt_platform/backend/backend/data/analytics.py

@@ -104,7 +104,7 @@ async def get_accuracy_trends_and_alerts(
             AND e."executionStatus" IN ('COMPLETED', 'FAILED', 'TERMINATED')
             {user_filter}
         GROUP BY DATE(e."createdAt")
-        HAVING COUNT(*) >= 3  -- Need at least 3 executions per day
+        HAVING COUNT(*) >= 1  -- Include all days with at least 1 execution
     ),
     trends AS (
         SELECT 

autogpt_platform/backend/backend/data/block.py

@@ -50,8 +50,6 @@ from .model import (
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
-    from backend.data.execution import ExecutionContext
-
     from .graph import Link
 
 app_config = Config()
@@ -474,7 +472,6 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         self.block_type = block_type
         self.webhook_config = webhook_config
         self.execution_stats: NodeExecutionStats = NodeExecutionStats()
-        self.requires_human_review: bool = False
 
         if self.webhook_config:
             if isinstance(self.webhook_config, BlockWebhookConfig):
@@ -617,77 +614,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
                     block_id=self.id,
                 ) from ex
 
-    async def is_block_exec_need_review(
-        self,
-        input_data: BlockInput,
-        *,
-        user_id: str,
-        node_exec_id: str,
-        graph_exec_id: str,
-        graph_id: str,
-        graph_version: int,
-        execution_context: "ExecutionContext",
-        **kwargs,
-    ) -> tuple[bool, BlockInput]:
-        """
-        Check if this block execution needs human review and handle the review process.
-
-        Returns:
-            Tuple of (should_pause, input_data_to_use)
-            - should_pause: True if execution should be paused for review
-            - input_data_to_use: The input data to use (may be modified by reviewer)
-        """
-        # Skip review if not required or safe mode is disabled
-        if not self.requires_human_review or not execution_context.safe_mode:
-            return False, input_data
-
-        from backend.blocks.helpers.review import HITLReviewHelper
-
-        # Handle the review request and get decision
-        decision = await HITLReviewHelper.handle_review_decision(
-            input_data=input_data,
-            user_id=user_id,
-            node_exec_id=node_exec_id,
-            graph_exec_id=graph_exec_id,
-            graph_id=graph_id,
-            graph_version=graph_version,
-            execution_context=execution_context,
-            block_name=self.name,
-            editable=True,
-        )
-
-        if decision is None:
-            # We're awaiting review - pause execution
-            return True, input_data
-
-        if not decision.should_proceed:
-            # Review was rejected, raise an error to stop execution
-            raise BlockExecutionError(
-                message=f"Block execution rejected by reviewer: {decision.message}",
-                block_name=self.name,
-                block_id=self.id,
-            )
-
-        # Review was approved - use the potentially modified data
-        # ReviewResult.data must be a dict for block inputs
-        reviewed_data = decision.review_result.data
-        if not isinstance(reviewed_data, dict):
-            raise BlockExecutionError(
-                message=f"Review data must be a dict for block input, got {type(reviewed_data).__name__}",
-                block_name=self.name,
-                block_id=self.id,
-            )
-        return False, reviewed_data
-
     async def _execute(self, input_data: BlockInput, **kwargs) -> BlockOutput:
-        # Check for review requirement and get potentially modified input data
-        should_pause, input_data = await self.is_block_exec_need_review(
-            input_data, **kwargs
-        )
-        if should_pause:
-            return
-
-        # Validate the input data (original or reviewer-modified) once
         if error := self.input_schema.validate_data(input_data):
             raise BlockInputError(
                 message=f"Unable to execute block with invalid input data: {error}",
@@ -695,7 +622,6 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
                 block_id=self.id,
             )
 
-        # Use the validated input data
         async for output_name, output_data in self.run(
             self.input_schema(**{k: v for k, v in input_data.items() if v is not None}),
             **kwargs,

autogpt_platform/backend/backend/data/db.py

@@ -108,84 +108,21 @@ def get_database_schema() -> str:
     return query_params.get("schema", "public")
 
 
-async def _raw_with_schema(
-    query_template: str,
-    *args,
-    execute: bool = False,
-    client: Prisma | None = None,
-) -> list[dict] | int:
-    """Internal: Execute raw SQL with proper schema handling.
-
-    Use query_raw_with_schema() or execute_raw_with_schema() instead.
-
-    Args:
-        query_template: SQL query with {schema_prefix} placeholder
-        *args: Query parameters
-        execute: If False, executes SELECT query. If True, executes INSERT/UPDATE/DELETE.
-        client: Optional Prisma client for transactions (only used when execute=True).
-
-    Returns:
-        - list[dict] if execute=False (query results)
-        - int if execute=True (number of affected rows)
-    """
+async def query_raw_with_schema(query_template: str, *args) -> list[dict]:
+    """Execute raw SQL query with proper schema handling."""
     schema = get_database_schema()
     schema_prefix = f'"{schema}".' if schema != "public" else ""
     formatted_query = query_template.format(schema_prefix=schema_prefix)
 
     import prisma as prisma_module
 
-    db_client = client if client else prisma_module.get_client()
-
-    if execute:
-        result = await db_client.execute_raw(formatted_query, *args)  # type: ignore
-    else:
-        result = await db_client.query_raw(formatted_query, *args)  # type: ignore
+    result = await prisma_module.get_client().query_raw(
+        formatted_query, *args  # type: ignore
+    )
 
     return result
 
 
-async def query_raw_with_schema(query_template: str, *args) -> list[dict]:
-    """Execute raw SQL SELECT query with proper schema handling.
-
-    Args:
-        query_template: SQL query with {schema_prefix} placeholder
-        *args: Query parameters
-
-    Returns:
-        List of result rows as dictionaries
-
-    Example:
-        results = await query_raw_with_schema(
-            'SELECT * FROM {schema_prefix}"User" WHERE id = $1',
-            user_id
-        )
-    """
-    return await _raw_with_schema(query_template, *args, execute=False)  # type: ignore
-
-
-async def execute_raw_with_schema(
-    query_template: str, *args, client: Prisma | None = None
-) -> int:
-    """Execute raw SQL command (INSERT/UPDATE/DELETE) with proper schema handling.
-
-    Args:
-        query_template: SQL query with {schema_prefix} placeholder
-        *args: Query parameters
-        client: Optional Prisma client for transactions
-
-    Returns:
-        Number of affected rows
-
-    Example:
-        await execute_raw_with_schema(
-            'INSERT INTO {schema_prefix}"User" (id, name) VALUES ($1, $2)',
-            user_id, name,
-            client=tx  # Optional transaction client
-        )
-    """
-    return await _raw_with_schema(query_template, *args, execute=True, client=client)  # type: ignore
-
-
 class BaseDbModel(BaseModel):
     id: str = Field(default_factory=lambda: str(uuid4()))
 

autogpt_platform/backend/backend/data/execution.py

@@ -153,8 +153,14 @@ class GraphExecutionMeta(BaseDbModel):
     nodes_input_masks: Optional[dict[str, BlockInput]]
     preset_id: Optional[str]
     status: ExecutionStatus
-    started_at: datetime
-    ended_at: datetime
+    started_at: Optional[datetime] = Field(
+        None,
+        description="When execution started running. Null if not yet started (QUEUED).",
+    )
+    ended_at: Optional[datetime] = Field(
+        None,
+        description="When execution finished. Null if not yet completed (QUEUED, RUNNING, INCOMPLETE, REVIEW).",
+    )
     is_shared: bool = False
     share_token: Optional[str] = None
 
@@ -229,10 +235,8 @@ class GraphExecutionMeta(BaseDbModel):
 
     @staticmethod
     def from_db(_graph_exec: AgentGraphExecution):
-        now = datetime.now(timezone.utc)
-        # TODO: make started_at and ended_at optional
-        start_time = _graph_exec.startedAt or _graph_exec.createdAt
-        end_time = _graph_exec.updatedAt or now
+        start_time = _graph_exec.startedAt
+        end_time = _graph_exec.endedAt
 
         try:
             stats = GraphExecutionStats.model_validate(_graph_exec.stats)
@@ -383,7 +387,6 @@ class GraphExecutionWithNodes(GraphExecution):
         self,
         execution_context: ExecutionContext,
         compiled_nodes_input_masks: Optional[NodesInputMasks] = None,
-        nodes_to_skip: Optional[set[str]] = None,
     ):
         return GraphExecutionEntry(
             user_id=self.user_id,
@@ -391,7 +394,6 @@ class GraphExecutionWithNodes(GraphExecution):
             graph_version=self.graph_version or 0,
             graph_exec_id=self.id,
             nodes_input_masks=compiled_nodes_input_masks,
-            nodes_to_skip=nodes_to_skip or set(),
             execution_context=execution_context,
         )
 
@@ -902,6 +904,14 @@ async def update_graph_execution_stats(
 
     if status:
         update_data["executionStatus"] = status
+        # Set endedAt when execution reaches a terminal status
+        terminal_statuses = [
+            ExecutionStatus.COMPLETED,
+            ExecutionStatus.FAILED,
+            ExecutionStatus.TERMINATED,
+        ]
+        if status in terminal_statuses:
+            update_data["endedAt"] = datetime.now(tz=timezone.utc)
 
     where_clause: AgentGraphExecutionWhereInput = {"id": graph_exec_id}
 
@@ -1147,8 +1157,6 @@ class GraphExecutionEntry(BaseModel):
     graph_id: str
     graph_version: int
     nodes_input_masks: Optional[NodesInputMasks] = None
-    nodes_to_skip: set[str] = Field(default_factory=set)
-    """Node IDs that should be skipped due to optional credentials not being configured."""
     execution_context: ExecutionContext = Field(default_factory=ExecutionContext)
 
 

autogpt_platform/backend/backend/data/graph.py

@@ -94,15 +94,6 @@ class Node(BaseDbModel):
     input_links: list[Link] = []
     output_links: list[Link] = []
 
-    @property
-    def credentials_optional(self) -> bool:
-        """
-        Whether credentials are optional for this node.
-        When True and credentials are not configured, the node will be skipped
-        during execution rather than causing a validation error.
-        """
-        return self.metadata.get("credentials_optional", False)
-
     @property
     def block(self) -> AnyBlockSchema | "_UnknownBlockBase":
         """Get the block for this node. Returns UnknownBlock if block is deleted/missing."""
@@ -244,10 +235,7 @@ class BaseGraph(BaseDbModel):
         return any(
             node.block_id
             for node in self.nodes
-            if (
-                node.block.block_type == BlockType.HUMAN_IN_THE_LOOP
-                or node.block.requires_human_review
-            )
+            if node.block.block_type == BlockType.HUMAN_IN_THE_LOOP
         )
 
     @property
@@ -338,35 +326,7 @@ class Graph(BaseGraph):
     @computed_field
     @property
     def credentials_input_schema(self) -> dict[str, Any]:
-        schema = self._credentials_input_schema.jsonschema()
-
-        # Determine which credential fields are required based on credentials_optional metadata
-        graph_credentials_inputs = self.aggregate_credentials_inputs()
-        required_fields = []
-
-        # Build a map of node_id -> node for quick lookup
-        all_nodes = {node.id: node for node in self.nodes}
-        for sub_graph in self.sub_graphs:
-            for node in sub_graph.nodes:
-                all_nodes[node.id] = node
-
-        for field_key, (
-            _field_info,
-            node_field_pairs,
-        ) in graph_credentials_inputs.items():
-            # A field is required if ANY node using it has credentials_optional=False
-            is_required = False
-            for node_id, _field_name in node_field_pairs:
-                node = all_nodes.get(node_id)
-                if node and not node.credentials_optional:
-                    is_required = True
-                    break
-
-            if is_required:
-                required_fields.append(field_key)
-
-        schema["required"] = required_fields
-        return schema
+        return self._credentials_input_schema.jsonschema()
 
     @property
     def _credentials_input_schema(self) -> type[BlockSchema]:

autogpt_platform/backend/backend/data/graph_test.py

@@ -1,6 +1,5 @@
 import json
 from typing import Any
-from unittest.mock import AsyncMock, patch
 from uuid import UUID
 
 import fastapi.exceptions
@@ -19,17 +18,6 @@ from backend.usecases.sample import create_test_user
 from backend.util.test import SpinTestServer
 
 
-@pytest.fixture(scope="session", autouse=True)
-def mock_embedding_functions():
-    """Mock embedding functions for all tests to avoid database/API dependencies."""
-    with patch(
-        "backend.api.features.store.db.ensure_embedding",
-        new_callable=AsyncMock,
-        return_value=True,
-    ):
-        yield
-
-
 @pytest.mark.asyncio(loop_scope="session")
 async def test_graph_creation(server: SpinTestServer, snapshot: Snapshot):
     """
@@ -408,58 +396,3 @@ async def test_access_store_listing_graph(server: SpinTestServer):
         created_graph.id, created_graph.version, "3e53486c-cf57-477e-ba2a-cb02dc828e1b"
     )
     assert got_graph is not None
-
-
-# ============================================================================
-# Tests for Optional Credentials Feature
-# ============================================================================
-
-
-def test_node_credentials_optional_default():
-    """Test that credentials_optional defaults to False when not set in metadata."""
-    node = Node(
-        id="test_node",
-        block_id=StoreValueBlock().id,
-        input_default={},
-        metadata={},
-    )
-    assert node.credentials_optional is False
-
-
-def test_node_credentials_optional_true():
-    """Test that credentials_optional returns True when explicitly set."""
-    node = Node(
-        id="test_node",
-        block_id=StoreValueBlock().id,
-        input_default={},
-        metadata={"credentials_optional": True},
-    )
-    assert node.credentials_optional is True
-
-
-def test_node_credentials_optional_false():
-    """Test that credentials_optional returns False when explicitly set to False."""
-    node = Node(
-        id="test_node",
-        block_id=StoreValueBlock().id,
-        input_default={},
-        metadata={"credentials_optional": False},
-    )
-    assert node.credentials_optional is False
-
-
-def test_node_credentials_optional_with_other_metadata():
-    """Test that credentials_optional works correctly with other metadata present."""
-    node = Node(
-        id="test_node",
-        block_id=StoreValueBlock().id,
-        input_default={},
-        metadata={
-            "position": {"x": 100, "y": 200},
-            "customized_name": "My Custom Node",
-            "credentials_optional": True,
-        },
-    )
-    assert node.credentials_optional is True
-    assert node.metadata["position"] == {"x": 100, "y": 200}
-    assert node.metadata["customized_name"] == "My Custom Node"

autogpt_platform/backend/backend/executor/manager.py

@@ -178,7 +178,6 @@ async def execute_node(
     execution_processor: "ExecutionProcessor",
     execution_stats: NodeExecutionStats | None = None,
     nodes_input_masks: Optional[NodesInputMasks] = None,
-    nodes_to_skip: Optional[set[str]] = None,
 ) -> BlockOutput:
     """
     Execute a node in the graph. This will trigger a block execution on a node,
@@ -246,7 +245,6 @@ async def execute_node(
         "user_id": user_id,
         "execution_context": execution_context,
         "execution_processor": execution_processor,
-        "nodes_to_skip": nodes_to_skip or set(),
     }
 
     # Last-minute fetch credentials + acquire a system-wide read-write lock to prevent
@@ -544,7 +542,6 @@ class ExecutionProcessor:
         node_exec_progress: NodeExecutionProgress,
         nodes_input_masks: Optional[NodesInputMasks],
         graph_stats_pair: tuple[GraphExecutionStats, threading.Lock],
-        nodes_to_skip: Optional[set[str]] = None,
     ) -> NodeExecutionStats:
         log_metadata = LogMetadata(
             logger=_logger,
@@ -567,7 +564,6 @@ class ExecutionProcessor:
             db_client=db_client,
             log_metadata=log_metadata,
             nodes_input_masks=nodes_input_masks,
-            nodes_to_skip=nodes_to_skip,
         )
         if isinstance(status, BaseException):
             raise status
@@ -613,7 +609,6 @@ class ExecutionProcessor:
         db_client: "DatabaseManagerAsyncClient",
         log_metadata: LogMetadata,
         nodes_input_masks: Optional[NodesInputMasks] = None,
-        nodes_to_skip: Optional[set[str]] = None,
     ) -> ExecutionStatus:
         status = ExecutionStatus.RUNNING
 
@@ -650,7 +645,6 @@ class ExecutionProcessor:
                 execution_processor=self,
                 execution_stats=stats,
                 nodes_input_masks=nodes_input_masks,
-                nodes_to_skip=nodes_to_skip,
             ):
                 await persist_output(output_name, output_data)
 
@@ -962,21 +956,6 @@ class ExecutionProcessor:
 
                 queued_node_exec = execution_queue.get()
 
-                # Check if this node should be skipped due to optional credentials
-                if queued_node_exec.node_id in graph_exec.nodes_to_skip:
-                    log_metadata.info(
-                        f"Skipping node execution {queued_node_exec.node_exec_id} "
-                        f"for node {queued_node_exec.node_id} - optional credentials not configured"
-                    )
-                    # Mark the node as completed without executing
-                    # No outputs will be produced, so downstream nodes won't trigger
-                    update_node_execution_status(
-                        db_client=db_client,
-                        exec_id=queued_node_exec.node_exec_id,
-                        status=ExecutionStatus.COMPLETED,
-                    )
-                    continue
-
                 log_metadata.debug(
                     f"Dispatching node execution {queued_node_exec.node_exec_id} "
                     f"for node {queued_node_exec.node_id}",
@@ -1037,7 +1016,6 @@ class ExecutionProcessor:
                             execution_stats,
                             execution_stats_lock,
                         ),
-                        nodes_to_skip=graph_exec.nodes_to_skip,
                     ),
                     self.node_execution_loop,
                 )

autogpt_platform/backend/backend/executor/manager_test.py

@@ -1,5 +1,4 @@
 import logging
-from unittest.mock import AsyncMock, patch
 
 import fastapi.responses
 import pytest
@@ -20,17 +19,6 @@ from backend.util.test import SpinTestServer, wait_execution
 logger = logging.getLogger(__name__)
 
 
-@pytest.fixture(scope="session", autouse=True)
-def mock_embedding_functions():
-    """Mock embedding functions for all tests to avoid database/API dependencies."""
-    with patch(
-        "backend.api.features.store.db.ensure_embedding",
-        new_callable=AsyncMock,
-        return_value=True,
-    ):
-        yield
-
-
 async def create_graph(s: SpinTestServer, g: graph.Graph, u: User) -> graph.Graph:
     logger.info(f"Creating graph for user {u.id}")
     return await s.agent_server.test_create_graph(CreateGraph(graph=g), u.id)

autogpt_platform/backend/backend/executor/scheduler.py

@@ -23,10 +23,6 @@ from dotenv import load_dotenv
 from pydantic import BaseModel, Field, ValidationError
 from sqlalchemy import MetaData, create_engine
 
-from backend.api.features.store.embeddings import (
-    backfill_missing_embeddings,
-    get_embedding_stats,
-)
 from backend.data.auth.oauth import cleanup_expired_oauth_tokens
 from backend.data.block import BlockInput
 from backend.data.execution import GraphExecutionWithNodes
@@ -258,72 +254,6 @@ def execution_accuracy_alerts():
     return report_execution_accuracy_alerts()
 
 
-def ensure_embeddings_coverage():
-    """
-    Ensure approved store agents have embeddings for hybrid search.
-
-    Processes ALL missing embeddings in batches of 10 until 100% coverage.
-    Missing embeddings = agents invisible in hybrid search.
-
-    Schedule: Runs every 6 hours (balanced between coverage and API costs).
-    - Catches agents approved between scheduled runs
-    - Batch size 10: gradual processing to avoid rate limits
-    - Manual trigger available via execute_ensure_embeddings_coverage endpoint
-    """
-
-    async def _ensure():
-        import asyncio
-
-        stats = await get_embedding_stats()
-
-        # Check for error from get_embedding_stats() first
-        if "error" in stats:
-            logger.error(
-                f"Failed to get embedding stats: {stats['error']} - skipping backfill"
-            )
-            return {"processed": 0, "success": 0, "failed": 0, "error": stats["error"]}
-
-        if stats["without_embeddings"] == 0:
-            logger.info("All approved agents have embeddings, skipping backfill")
-            return {"processed": 0, "success": 0, "failed": 0}
-
-        logger.info(
-            f"Found {stats['without_embeddings']} agents without embeddings "
-            f"({stats['coverage_percent']}% coverage) - processing all"
-        )
-
-        total_processed = 0
-        total_success = 0
-        total_failed = 0
-
-        # Process in batches until no more missing embeddings
-        while True:
-            result = await backfill_missing_embeddings(batch_size=10)
-
-            total_processed += result["processed"]
-            total_success += result["success"]
-            total_failed += result["failed"]
-
-            if result["processed"] == 0:
-                # No more missing embeddings
-                break
-
-            # Small delay between batches to avoid rate limits
-            await asyncio.sleep(1)
-
-        logger.info(
-            f"Embedding backfill completed: {total_success}/{total_processed} succeeded, "
-            f"{total_failed} failed"
-        )
-        return {
-            "processed": total_processed,
-            "success": total_success,
-            "failed": total_failed,
-        }
-
-    return run_async(_ensure())
-
-
 # Monitoring functions are now imported from monitoring module
 
 
@@ -545,19 +475,6 @@ class Scheduler(AppService):
                 jobstore=Jobstores.EXECUTION.value,
             )
 
-            # Embedding Coverage - Every 6 hours
-            # Ensures all approved agents have embeddings for hybrid search
-            # Critical: missing embeddings = agents invisible in search
-            self.scheduler.add_job(
-                ensure_embeddings_coverage,
-                id="ensure_embeddings_coverage",
-                trigger="interval",
-                hours=6,
-                replace_existing=True,
-                max_instances=1,  # Prevent overlapping runs
-                jobstore=Jobstores.EXECUTION.value,
-            )
-
         self.scheduler.add_listener(job_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
         self.scheduler.add_listener(job_missed_listener, EVENT_JOB_MISSED)
         self.scheduler.add_listener(job_max_instances_listener, EVENT_JOB_MAX_INSTANCES)
@@ -715,11 +632,6 @@ class Scheduler(AppService):
         """Manually trigger execution accuracy alert checking."""
         return execution_accuracy_alerts()
 
-    @expose
-    def execute_ensure_embeddings_coverage(self):
-        """Manually trigger embedding backfill for approved store agents."""
-        return ensure_embeddings_coverage()
-
 
 class SchedulerClient(AppServiceClient):
     @classmethod

autogpt_platform/backend/backend/executor/utils.py

@@ -239,19 +239,14 @@ async def _validate_node_input_credentials(
     graph: GraphModel,
     user_id: str,
     nodes_input_masks: Optional[NodesInputMasks] = None,
-) -> tuple[dict[str, dict[str, str]], set[str]]:
+) -> dict[str, dict[str, str]]:
     """
-    Checks all credentials for all nodes of the graph and returns structured errors
-    and a set of nodes that should be skipped due to optional missing credentials.
+    Checks all credentials for all nodes of the graph and returns structured errors.
 
     Returns:
-        tuple[
-            dict[node_id, dict[field_name, error_message]]: Credential validation errors per node,
-            set[node_id]: Nodes that should be skipped (optional credentials not configured)
-        ]
+        dict[node_id, dict[field_name, error_message]]: Credential validation errors per node
     """
     credential_errors: dict[str, dict[str, str]] = defaultdict(dict)
-    nodes_to_skip: set[str] = set()
 
     for node in graph.nodes:
         block = node.block
@@ -261,46 +256,27 @@ async def _validate_node_input_credentials(
         if not credentials_fields:
             continue
 
-        # Track if any credential field is missing for this node
-        has_missing_credentials = False
-
         for field_name, credentials_meta_type in credentials_fields.items():
             try:
-                # Check nodes_input_masks first, then input_default
-                field_value = None
                 if (
                     nodes_input_masks
                     and (node_input_mask := nodes_input_masks.get(node.id))
                     and field_name in node_input_mask
                 ):
-                    field_value = node_input_mask[field_name]
+                    credentials_meta = credentials_meta_type.model_validate(
+                        node_input_mask[field_name]
+                    )
                 elif field_name in node.input_default:
-                    # For optional credentials, don't use input_default - treat as missing
-                    # This prevents stale credential IDs from failing validation
-                    if node.credentials_optional:
-                        field_value = None
-                    else:
-                        field_value = node.input_default[field_name]
-
-                # Check if credentials are missing (None, empty, or not present)
-                if field_value is None or (
-                    isinstance(field_value, dict) and not field_value.get("id")
-                ):
-                    has_missing_credentials = True
-                    # If node has credentials_optional flag, mark for skipping instead of error
-                    if node.credentials_optional:
-                        continue  # Don't add error, will be marked for skip after loop
-                    else:
-                        credential_errors[node.id][
-                            field_name
-                        ] = "These credentials are required"
-                        continue
-
-                credentials_meta = credentials_meta_type.model_validate(field_value)
-
+                    credentials_meta = credentials_meta_type.model_validate(
+                        node.input_default[field_name]
+                    )
+                else:
+                    # Missing credentials
+                    credential_errors[node.id][
+                        field_name
+                    ] = "These credentials are required"
+                    continue
             except ValidationError as e:
-                # Validation error means credentials were provided but invalid
-                # This should always be an error, even if optional
                 credential_errors[node.id][field_name] = f"Invalid credentials: {e}"
                 continue
 
@@ -311,7 +287,6 @@ async def _validate_node_input_credentials(
                 )
             except Exception as e:
                 # Handle any errors fetching credentials
-                # If credentials were explicitly configured but unavailable, it's an error
                 credential_errors[node.id][
                     field_name
                 ] = f"Credentials not available: {e}"
@@ -338,19 +313,7 @@ async def _validate_node_input_credentials(
                 ] = "Invalid credentials: type/provider mismatch"
                 continue
 
-        # If node has optional credentials and any are missing, mark for skipping
-        # But only if there are no other errors for this node
-        if (
-            has_missing_credentials
-            and node.credentials_optional
-            and node.id not in credential_errors
-        ):
-            nodes_to_skip.add(node.id)
-            logger.info(
-                f"Node #{node.id} will be skipped: optional credentials not configured"
-            )
-
-    return credential_errors, nodes_to_skip
+    return credential_errors
 
 
 def make_node_credentials_input_map(
@@ -392,25 +355,21 @@ async def validate_graph_with_credentials(
     graph: GraphModel,
     user_id: str,
     nodes_input_masks: Optional[NodesInputMasks] = None,
-) -> tuple[Mapping[str, Mapping[str, str]], set[str]]:
+) -> Mapping[str, Mapping[str, str]]:
     """
-    Validate graph including credentials and return structured errors per node,
-    along with a set of nodes that should be skipped due to optional missing credentials.
+    Validate graph including credentials and return structured errors per node.
 
     Returns:
-        tuple[
-            dict[node_id, dict[field_name, error_message]]: Validation errors per node,
-            set[node_id]: Nodes that should be skipped (optional credentials not configured)
-        ]
+        dict[node_id, dict[field_name, error_message]]: Validation errors per node
     """
     # Get input validation errors
     node_input_errors = GraphModel.validate_graph_get_errors(
         graph, for_run=True, nodes_input_masks=nodes_input_masks
     )
 
-    # Get credential input/availability/validation errors and nodes to skip
-    node_credential_input_errors, nodes_to_skip = (
-        await _validate_node_input_credentials(graph, user_id, nodes_input_masks)
+    # Get credential input/availability/validation errors
+    node_credential_input_errors = await _validate_node_input_credentials(
+        graph, user_id, nodes_input_masks
     )
 
     # Merge credential errors with structural errors
@@ -419,7 +378,7 @@ async def validate_graph_with_credentials(
             node_input_errors[node_id] = {}
         node_input_errors[node_id].update(field_errors)
 
-    return node_input_errors, nodes_to_skip
+    return node_input_errors
 
 
 async def _construct_starting_node_execution_input(
@@ -427,7 +386,7 @@ async def _construct_starting_node_execution_input(
     user_id: str,
     graph_inputs: BlockInput,
     nodes_input_masks: Optional[NodesInputMasks] = None,
-) -> tuple[list[tuple[str, BlockInput]], set[str]]:
+) -> list[tuple[str, BlockInput]]:
     """
     Validates and prepares the input data for executing a graph.
     This function checks the graph for starting nodes, validates the input data
@@ -441,14 +400,11 @@ async def _construct_starting_node_execution_input(
         node_credentials_map: `dict[node_id, dict[input_name, CredentialsMetaInput]]`
 
     Returns:
-        tuple[
-            list[tuple[str, BlockInput]]: A list of tuples, each containing the node ID
-                and the corresponding input data for that node.
-            set[str]: Node IDs that should be skipped (optional credentials not configured)
-        ]
+        list[tuple[str, BlockInput]]: A list of tuples, each containing the node ID and
+            the corresponding input data for that node.
     """
     # Use new validation function that includes credentials
-    validation_errors, nodes_to_skip = await validate_graph_with_credentials(
+    validation_errors = await validate_graph_with_credentials(
         graph, user_id, nodes_input_masks
     )
     n_error_nodes = len(validation_errors)
@@ -489,7 +445,7 @@ async def _construct_starting_node_execution_input(
             "No starting nodes found for the graph, make sure an AgentInput or blocks with no inbound links are present as starting nodes."
         )
 
-    return nodes_input, nodes_to_skip
+    return nodes_input
 
 
 async def validate_and_construct_node_execution_input(
@@ -500,7 +456,7 @@ async def validate_and_construct_node_execution_input(
     graph_credentials_inputs: Optional[Mapping[str, CredentialsMetaInput]] = None,
     nodes_input_masks: Optional[NodesInputMasks] = None,
     is_sub_graph: bool = False,
-) -> tuple[GraphModel, list[tuple[str, BlockInput]], NodesInputMasks, set[str]]:
+) -> tuple[GraphModel, list[tuple[str, BlockInput]], NodesInputMasks]:
     """
     Public wrapper that handles graph fetching, credential mapping, and validation+construction.
     This centralizes the logic used by both scheduler validation and actual execution.
@@ -517,7 +473,6 @@ async def validate_and_construct_node_execution_input(
         GraphModel: Full graph object for the given `graph_id`.
         list[tuple[node_id, BlockInput]]: Starting node IDs with corresponding inputs.
         dict[str, BlockInput]: Node input masks including all passed-in credentials.
-        set[str]: Node IDs that should be skipped (optional credentials not configured).
 
     Raises:
         NotFoundError: If the graph is not found.
@@ -559,16 +514,14 @@ async def validate_and_construct_node_execution_input(
         nodes_input_masks or {},
     )
 
-    starting_nodes_input, nodes_to_skip = (
-        await _construct_starting_node_execution_input(
-            graph=graph,
-            user_id=user_id,
-            graph_inputs=graph_inputs,
-            nodes_input_masks=nodes_input_masks,
-        )
+    starting_nodes_input = await _construct_starting_node_execution_input(
+        graph=graph,
+        user_id=user_id,
+        graph_inputs=graph_inputs,
+        nodes_input_masks=nodes_input_masks,
     )
 
-    return graph, starting_nodes_input, nodes_input_masks, nodes_to_skip
+    return graph, starting_nodes_input, nodes_input_masks
 
 
 def _merge_nodes_input_masks(
@@ -826,9 +779,6 @@ async def add_graph_execution(
 
         # Use existing execution's compiled input masks
         compiled_nodes_input_masks = graph_exec.nodes_input_masks or {}
-        # For resumed executions, nodes_to_skip was already determined at creation time
-        # TODO: Consider storing nodes_to_skip in DB if we need to preserve it across resumes
-        nodes_to_skip: set[str] = set()
 
         logger.info(f"Resuming graph execution #{graph_exec.id} for graph #{graph_id}")
     else:
@@ -837,7 +787,7 @@ async def add_graph_execution(
         )
 
         # Create new execution
-        graph, starting_nodes_input, compiled_nodes_input_masks, nodes_to_skip = (
+        graph, starting_nodes_input, compiled_nodes_input_masks = (
             await validate_and_construct_node_execution_input(
                 graph_id=graph_id,
                 user_id=user_id,
@@ -886,7 +836,6 @@ async def add_graph_execution(
     try:
         graph_exec_entry = graph_exec.to_graph_execution_entry(
             compiled_nodes_input_masks=compiled_nodes_input_masks,
-            nodes_to_skip=nodes_to_skip,
             execution_context=execution_context,
         )
         logger.info(f"Publishing execution {graph_exec.id} to execution queue")

autogpt_platform/backend/backend/executor/utils_test.py

@@ -367,13 +367,10 @@ async def test_add_graph_execution_is_repeatable(mocker: MockerFixture):
     )
 
     # Setup mock returns
-    # The function returns (graph, starting_nodes_input, compiled_nodes_input_masks, nodes_to_skip)
-    nodes_to_skip: set[str] = set()
     mock_validate.return_value = (
         mock_graph,
         starting_nodes_input,
         compiled_nodes_input_masks,
-        nodes_to_skip,
     )
     mock_prisma.is_connected.return_value = True
     mock_edb.create_graph_execution = mocker.AsyncMock(return_value=mock_graph_exec)
@@ -459,212 +456,3 @@ async def test_add_graph_execution_is_repeatable(mocker: MockerFixture):
     # Both executions should succeed (though they create different objects)
     assert result1 == mock_graph_exec
     assert result2 == mock_graph_exec_2
-
-
-# ============================================================================
-# Tests for Optional Credentials Feature
-# ============================================================================
-
-
-@pytest.mark.asyncio
-async def test_validate_node_input_credentials_returns_nodes_to_skip(
-    mocker: MockerFixture,
-):
-    """
-    Test that _validate_node_input_credentials returns nodes_to_skip set
-    for nodes with credentials_optional=True and missing credentials.
-    """
-    from backend.executor.utils import _validate_node_input_credentials
-
-    # Create a mock node with credentials_optional=True
-    mock_node = mocker.MagicMock()
-    mock_node.id = "node-with-optional-creds"
-    mock_node.credentials_optional = True
-    mock_node.input_default = {}  # No credentials configured
-
-    # Create a mock block with credentials field
-    mock_block = mocker.MagicMock()
-    mock_credentials_field_type = mocker.MagicMock()
-    mock_block.input_schema.get_credentials_fields.return_value = {
-        "credentials": mock_credentials_field_type
-    }
-    mock_node.block = mock_block
-
-    # Create mock graph
-    mock_graph = mocker.MagicMock()
-    mock_graph.nodes = [mock_node]
-
-    # Call the function
-    errors, nodes_to_skip = await _validate_node_input_credentials(
-        graph=mock_graph,
-        user_id="test-user-id",
-        nodes_input_masks=None,
-    )
-
-    # Node should be in nodes_to_skip, not in errors
-    assert mock_node.id in nodes_to_skip
-    assert mock_node.id not in errors
-
-
-@pytest.mark.asyncio
-async def test_validate_node_input_credentials_required_missing_creds_error(
-    mocker: MockerFixture,
-):
-    """
-    Test that _validate_node_input_credentials returns errors
-    for nodes with credentials_optional=False and missing credentials.
-    """
-    from backend.executor.utils import _validate_node_input_credentials
-
-    # Create a mock node with credentials_optional=False (required)
-    mock_node = mocker.MagicMock()
-    mock_node.id = "node-with-required-creds"
-    mock_node.credentials_optional = False
-    mock_node.input_default = {}  # No credentials configured
-
-    # Create a mock block with credentials field
-    mock_block = mocker.MagicMock()
-    mock_credentials_field_type = mocker.MagicMock()
-    mock_block.input_schema.get_credentials_fields.return_value = {
-        "credentials": mock_credentials_field_type
-    }
-    mock_node.block = mock_block
-
-    # Create mock graph
-    mock_graph = mocker.MagicMock()
-    mock_graph.nodes = [mock_node]
-
-    # Call the function
-    errors, nodes_to_skip = await _validate_node_input_credentials(
-        graph=mock_graph,
-        user_id="test-user-id",
-        nodes_input_masks=None,
-    )
-
-    # Node should be in errors, not in nodes_to_skip
-    assert mock_node.id in errors
-    assert "credentials" in errors[mock_node.id]
-    assert "required" in errors[mock_node.id]["credentials"].lower()
-    assert mock_node.id not in nodes_to_skip
-
-
-@pytest.mark.asyncio
-async def test_validate_graph_with_credentials_returns_nodes_to_skip(
-    mocker: MockerFixture,
-):
-    """
-    Test that validate_graph_with_credentials returns nodes_to_skip set
-    from _validate_node_input_credentials.
-    """
-    from backend.executor.utils import validate_graph_with_credentials
-
-    # Mock _validate_node_input_credentials to return specific values
-    mock_validate = mocker.patch(
-        "backend.executor.utils._validate_node_input_credentials"
-    )
-    expected_errors = {"node1": {"field": "error"}}
-    expected_nodes_to_skip = {"node2", "node3"}
-    mock_validate.return_value = (expected_errors, expected_nodes_to_skip)
-
-    # Mock GraphModel with validate_graph_get_errors method
-    mock_graph = mocker.MagicMock()
-    mock_graph.validate_graph_get_errors.return_value = {}
-
-    # Call the function
-    errors, nodes_to_skip = await validate_graph_with_credentials(
-        graph=mock_graph,
-        user_id="test-user-id",
-        nodes_input_masks=None,
-    )
-
-    # Verify nodes_to_skip is passed through
-    assert nodes_to_skip == expected_nodes_to_skip
-    assert "node1" in errors
-
-
-@pytest.mark.asyncio
-async def test_add_graph_execution_with_nodes_to_skip(mocker: MockerFixture):
-    """
-    Test that add_graph_execution properly passes nodes_to_skip
-    to the graph execution entry.
-    """
-    from backend.data.execution import GraphExecutionWithNodes
-    from backend.executor.utils import add_graph_execution
-
-    # Mock data
-    graph_id = "test-graph-id"
-    user_id = "test-user-id"
-    inputs = {"test_input": "test_value"}
-    graph_version = 1
-
-    # Mock the graph object
-    mock_graph = mocker.MagicMock()
-    mock_graph.version = graph_version
-
-    # Starting nodes and masks
-    starting_nodes_input = [("node1", {"input1": "value1"})]
-    compiled_nodes_input_masks = {}
-    nodes_to_skip = {"skipped-node-1", "skipped-node-2"}
-
-    # Mock the graph execution object
-    mock_graph_exec = mocker.MagicMock(spec=GraphExecutionWithNodes)
-    mock_graph_exec.id = "execution-id-123"
-    mock_graph_exec.node_executions = []
-
-    # Track what's passed to to_graph_execution_entry
-    captured_kwargs = {}
-
-    def capture_to_entry(**kwargs):
-        captured_kwargs.update(kwargs)
-        return mocker.MagicMock()
-
-    mock_graph_exec.to_graph_execution_entry.side_effect = capture_to_entry
-
-    # Setup mocks
-    mock_validate = mocker.patch(
-        "backend.executor.utils.validate_and_construct_node_execution_input"
-    )
-    mock_edb = mocker.patch("backend.executor.utils.execution_db")
-    mock_prisma = mocker.patch("backend.executor.utils.prisma")
-    mock_udb = mocker.patch("backend.executor.utils.user_db")
-    mock_gdb = mocker.patch("backend.executor.utils.graph_db")
-    mock_get_queue = mocker.patch("backend.executor.utils.get_async_execution_queue")
-    mock_get_event_bus = mocker.patch(
-        "backend.executor.utils.get_async_execution_event_bus"
-    )
-
-    # Setup returns - include nodes_to_skip in the tuple
-    mock_validate.return_value = (
-        mock_graph,
-        starting_nodes_input,
-        compiled_nodes_input_masks,
-        nodes_to_skip,  # This should be passed through
-    )
-    mock_prisma.is_connected.return_value = True
-    mock_edb.create_graph_execution = mocker.AsyncMock(return_value=mock_graph_exec)
-    mock_edb.update_graph_execution_stats = mocker.AsyncMock(
-        return_value=mock_graph_exec
-    )
-    mock_edb.update_node_execution_status_batch = mocker.AsyncMock()
-
-    mock_user = mocker.MagicMock()
-    mock_user.timezone = "UTC"
-    mock_settings = mocker.MagicMock()
-    mock_settings.human_in_the_loop_safe_mode = True
-
-    mock_udb.get_user_by_id = mocker.AsyncMock(return_value=mock_user)
-    mock_gdb.get_graph_settings = mocker.AsyncMock(return_value=mock_settings)
-    mock_get_queue.return_value = mocker.AsyncMock()
-    mock_get_event_bus.return_value = mocker.MagicMock(publish=mocker.AsyncMock())
-
-    # Call the function
-    await add_graph_execution(
-        graph_id=graph_id,
-        user_id=user_id,
-        inputs=inputs,
-        graph_version=graph_version,
-    )
-
-    # Verify nodes_to_skip was passed to to_graph_execution_entry
-    assert "nodes_to_skip" in captured_kwargs
-    assert captured_kwargs["nodes_to_skip"] == nodes_to_skip

autogpt_platform/backend/backend/integrations/oauth/__init__.py

@@ -8,7 +8,6 @@ from .discord import DiscordOAuthHandler
 from .github import GitHubOAuthHandler
 from .google import GoogleOAuthHandler
 from .notion import NotionOAuthHandler
-from .reddit import RedditOAuthHandler
 from .twitter import TwitterOAuthHandler
 
 if TYPE_CHECKING:
@@ -21,7 +20,6 @@ _ORIGINAL_HANDLERS = [
     GitHubOAuthHandler,
     GoogleOAuthHandler,
     NotionOAuthHandler,
-    RedditOAuthHandler,
     TwitterOAuthHandler,
     TodoistOAuthHandler,
 ]

autogpt_platform/backend/backend/integrations/oauth/reddit.py

@@ -1,208 +0,0 @@
-import time
-import urllib.parse
-from typing import ClassVar, Optional
-
-from pydantic import SecretStr
-
-from backend.data.model import OAuth2Credentials
-from backend.integrations.oauth.base import BaseOAuthHandler
-from backend.integrations.providers import ProviderName
-from backend.util.request import Requests
-from backend.util.settings import Settings
-
-settings = Settings()
-
-
-class RedditOAuthHandler(BaseOAuthHandler):
-    """
-    Reddit OAuth 2.0 handler.
-
-    Based on the documentation at:
-    - https://github.com/reddit-archive/reddit/wiki/OAuth2
-
-    Notes:
-    - Reddit requires `duration=permanent` to get refresh tokens
-    - Access tokens expire after 1 hour (3600 seconds)
-    - Reddit requires HTTP Basic Auth for token requests
-    - Reddit requires a unique User-Agent header
-    """
-
-    PROVIDER_NAME = ProviderName.REDDIT
-    DEFAULT_SCOPES: ClassVar[list[str]] = [
-        "identity",  # Get username, verify auth
-        "read",  # Access posts and comments
-        "submit",  # Submit new posts and comments
-        "edit",  # Edit own posts and comments
-        "history",  # Access user's post history
-        "privatemessages",  # Access inbox and send private messages
-        "flair",  # Access and set flair on posts/subreddits
-    ]
-
-    AUTHORIZE_URL = "https://www.reddit.com/api/v1/authorize"
-    TOKEN_URL = "https://www.reddit.com/api/v1/access_token"
-    USERNAME_URL = "https://oauth.reddit.com/api/v1/me"
-    REVOKE_URL = "https://www.reddit.com/api/v1/revoke_token"
-
-    def __init__(self, client_id: str, client_secret: str, redirect_uri: str):
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.redirect_uri = redirect_uri
-
-    def get_login_url(
-        self, scopes: list[str], state: str, code_challenge: Optional[str]
-    ) -> str:
-        """Generate Reddit OAuth 2.0 authorization URL"""
-        scopes = self.handle_default_scopes(scopes)
-
-        params = {
-            "response_type": "code",
-            "client_id": self.client_id,
-            "redirect_uri": self.redirect_uri,
-            "scope": " ".join(scopes),
-            "state": state,
-            "duration": "permanent",  # Required for refresh tokens
-        }
-
-        return f"{self.AUTHORIZE_URL}?{urllib.parse.urlencode(params)}"
-
-    async def exchange_code_for_tokens(
-        self, code: str, scopes: list[str], code_verifier: Optional[str]
-    ) -> OAuth2Credentials:
-        """Exchange authorization code for access tokens"""
-        scopes = self.handle_default_scopes(scopes)
-
-        headers = {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "User-Agent": settings.config.reddit_user_agent,
-        }
-
-        data = {
-            "grant_type": "authorization_code",
-            "code": code,
-            "redirect_uri": self.redirect_uri,
-        }
-
-        # Reddit requires HTTP Basic Auth for token requests
-        auth = (self.client_id, self.client_secret)
-
-        response = await Requests().post(
-            self.TOKEN_URL, headers=headers, data=data, auth=auth
-        )
-
-        if not response.ok:
-            error_text = response.text()
-            raise ValueError(
-                f"Reddit token exchange failed: {response.status} - {error_text}"
-            )
-
-        tokens = response.json()
-
-        if "error" in tokens:
-            raise ValueError(f"Reddit OAuth error: {tokens.get('error')}")
-
-        username = await self._get_username(tokens["access_token"])
-
-        return OAuth2Credentials(
-            provider=self.PROVIDER_NAME,
-            title=None,
-            username=username,
-            access_token=tokens["access_token"],
-            refresh_token=tokens.get("refresh_token"),
-            access_token_expires_at=int(time.time()) + tokens.get("expires_in", 3600),
-            refresh_token_expires_at=None,  # Reddit refresh tokens don't expire
-            scopes=scopes,
-        )
-
-    async def _get_username(self, access_token: str) -> str:
-        """Get the username from the access token"""
-        headers = {
-            "Authorization": f"Bearer {access_token}",
-            "User-Agent": settings.config.reddit_user_agent,
-        }
-
-        response = await Requests().get(self.USERNAME_URL, headers=headers)
-
-        if not response.ok:
-            raise ValueError(f"Failed to get Reddit username: {response.status}")
-
-        data = response.json()
-        return data.get("name", "unknown")
-
-    async def _refresh_tokens(
-        self, credentials: OAuth2Credentials
-    ) -> OAuth2Credentials:
-        """Refresh access tokens using refresh token"""
-        if not credentials.refresh_token:
-            raise ValueError("No refresh token available")
-
-        headers = {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "User-Agent": settings.config.reddit_user_agent,
-        }
-
-        data = {
-            "grant_type": "refresh_token",
-            "refresh_token": credentials.refresh_token.get_secret_value(),
-        }
-
-        auth = (self.client_id, self.client_secret)
-
-        response = await Requests().post(
-            self.TOKEN_URL, headers=headers, data=data, auth=auth
-        )
-
-        if not response.ok:
-            error_text = response.text()
-            raise ValueError(
-                f"Reddit token refresh failed: {response.status} - {error_text}"
-            )
-
-        tokens = response.json()
-
-        if "error" in tokens:
-            raise ValueError(f"Reddit OAuth error: {tokens.get('error')}")
-
-        username = await self._get_username(tokens["access_token"])
-
-        # Reddit may or may not return a new refresh token
-        new_refresh_token = tokens.get("refresh_token")
-        if new_refresh_token:
-            refresh_token: SecretStr | None = SecretStr(new_refresh_token)
-        elif credentials.refresh_token:
-            # Keep the existing refresh token
-            refresh_token = credentials.refresh_token
-        else:
-            refresh_token = None
-
-        return OAuth2Credentials(
-            id=credentials.id,
-            provider=self.PROVIDER_NAME,
-            title=credentials.title,
-            username=username,
-            access_token=tokens["access_token"],
-            refresh_token=refresh_token,
-            access_token_expires_at=int(time.time()) + tokens.get("expires_in", 3600),
-            refresh_token_expires_at=None,
-            scopes=credentials.scopes,
-        )
-
-    async def revoke_tokens(self, credentials: OAuth2Credentials) -> bool:
-        """Revoke the access token"""
-        headers = {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "User-Agent": settings.config.reddit_user_agent,
-        }
-
-        data = {
-            "token": credentials.access_token.get_secret_value(),
-            "token_type_hint": "access_token",
-        }
-
-        auth = (self.client_id, self.client_secret)
-
-        response = await Requests().post(
-            self.REVOKE_URL, headers=headers, data=data, auth=auth
-        )
-
-        # Reddit returns 204 No Content on successful revocation
-        return response.ok

autogpt_platform/backend/backend/monitoring/late_execution_monitor.py

@@ -60,8 +60,10 @@ class LateExecutionMonitor:
         if not all_late_executions:
             return "No late executions detected."
 
-        # Sort by created time (oldest first)
-        all_late_executions.sort(key=lambda x: x.started_at)
+        # Sort by started time (oldest first), with None values (unstarted) first
+        all_late_executions.sort(
+            key=lambda x: x.started_at or datetime.min.replace(tzinfo=timezone.utc)
+        )
 
         num_total_late = len(all_late_executions)
         num_queued = len(queued_late_executions)
@@ -74,7 +76,7 @@ class LateExecutionMonitor:
         was_truncated = num_total_late > tuncate_size
 
         late_execution_details = [
-            f"* `Execution ID: {exec.id}, Graph ID: {exec.graph_id}v{exec.graph_version}, User ID: {exec.user_id}, Status: {exec.status}, Created At: {exec.started_at.isoformat()}`"
+            f"* `Execution ID: {exec.id}, Graph ID: {exec.graph_id}v{exec.graph_version}, User ID: {exec.user_id}, Status: {exec.status}, Started At: {exec.started_at.isoformat() if exec.started_at else 'Not started'}`"
             for exec in truncated_executions
         ]
 

autogpt_platform/backend/backend/util/clients.py

@@ -10,7 +10,6 @@ from backend.util.settings import Settings
 settings = Settings()
 
 if TYPE_CHECKING:
-    from openai import AsyncOpenAI
     from supabase import AClient, Client
 
     from backend.data.execution import (
@@ -140,24 +139,6 @@ async def get_async_supabase() -> "AClient":
     )
 
 
-# ============ OpenAI Client ============ #
-
-
-@cached(ttl_seconds=3600)
-def get_openai_client() -> "AsyncOpenAI | None":
-    """
-    Get a process-cached async OpenAI client for embeddings.
-
-    Returns None if API key is not configured.
-    """
-    from openai import AsyncOpenAI
-
-    api_key = settings.secrets.openai_internal_api_key
-    if not api_key:
-        return None
-    return AsyncOpenAI(api_key=api_key)
-
-
 # ============ Notification Queue Helpers ============ #
 
 

autogpt_platform/backend/backend/util/settings.py

@@ -264,7 +264,7 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
     )
 
     reddit_user_agent: str = Field(
-        default="web:AutoGPT:v0.6.0 (by /u/autogpt)",
+        default="AutoGPT:1.0 (by /u/autogpt)",
         description="The user agent for the Reddit API",
     )
 

autogpt_platform/backend/gen_prisma_types_stub.py

@@ -1,227 +0,0 @@
-#!/usr/bin/env python3
-"""
-Generate a lightweight stub for prisma/types.py that collapses all exported
-symbols to Any. This prevents Pyright from spending time/budget on Prisma's
-query DSL types while keeping runtime behavior unchanged.
-
-Usage:
-    poetry run gen-prisma-stub
-
-This script automatically finds the prisma package location and generates
-the types.pyi stub file in the same directory as types.py.
-"""
-
-from __future__ import annotations
-
-import ast
-import importlib.util
-import sys
-from pathlib import Path
-from typing import Iterable, Set
-
-
-def _iter_assigned_names(target: ast.expr) -> Iterable[str]:
-    """Extract names from assignment targets (handles tuple unpacking)."""
-    if isinstance(target, ast.Name):
-        yield target.id
-    elif isinstance(target, (ast.Tuple, ast.List)):
-        for elt in target.elts:
-            yield from _iter_assigned_names(elt)
-
-
-def _is_private(name: str) -> bool:
-    """Check if a name is private (starts with _ but not __)."""
-    return name.startswith("_") and not name.startswith("__")
-
-
-def _is_safe_type_alias(node: ast.Assign) -> bool:
-    """Check if an assignment is a safe type alias that shouldn't be stubbed.
-
-    Safe types are:
-    - Literal types (don't cause type budget issues)
-    - Simple type references (SortMode, SortOrder, etc.)
-    - TypeVar definitions
-    """
-    if not node.value:
-        return False
-
-    # Check if it's a Subscript (like Literal[...], Union[...], TypeVar[...])
-    if isinstance(node.value, ast.Subscript):
-        # Get the base type name
-        if isinstance(node.value.value, ast.Name):
-            base_name = node.value.value.id
-            # Literal types are safe
-            if base_name == "Literal":
-                return True
-            # TypeVar is safe
-            if base_name == "TypeVar":
-                return True
-        elif isinstance(node.value.value, ast.Attribute):
-            # Handle typing_extensions.Literal etc.
-            if node.value.value.attr == "Literal":
-                return True
-
-    # Check if it's a simple Name reference (like SortMode = _types.SortMode)
-    if isinstance(node.value, ast.Attribute):
-        return True
-
-    # Check if it's a Call (like TypeVar(...))
-    if isinstance(node.value, ast.Call):
-        if isinstance(node.value.func, ast.Name):
-            if node.value.func.id == "TypeVar":
-                return True
-
-    return False
-
-
-def collect_top_level_symbols(
-    tree: ast.Module, source_lines: list[str]
-) -> tuple[Set[str], Set[str], list[str], Set[str]]:
-    """Collect all top-level symbols from an AST module.
-
-    Returns:
-        Tuple of (class_names, function_names, safe_variable_sources, unsafe_variable_names)
-        safe_variable_sources contains the actual source code lines for safe variables
-    """
-    classes: Set[str] = set()
-    functions: Set[str] = set()
-    safe_variable_sources: list[str] = []
-    unsafe_variables: Set[str] = set()
-
-    for node in tree.body:
-        if isinstance(node, ast.ClassDef):
-            if not _is_private(node.name):
-                classes.add(node.name)
-        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            if not _is_private(node.name):
-                functions.add(node.name)
-        elif isinstance(node, ast.Assign):
-            is_safe = _is_safe_type_alias(node)
-            names = []
-            for t in node.targets:
-                for n in _iter_assigned_names(t):
-                    if not _is_private(n):
-                        names.append(n)
-            if names:
-                if is_safe:
-                    # Extract the source code for this assignment
-                    start_line = node.lineno - 1  # 0-indexed
-                    end_line = node.end_lineno if node.end_lineno else node.lineno
-                    source = "\n".join(source_lines[start_line:end_line])
-                    safe_variable_sources.append(source)
-                else:
-                    unsafe_variables.update(names)
-        elif isinstance(node, ast.AnnAssign) and node.target:
-            # Annotated assignments are always stubbed
-            for n in _iter_assigned_names(node.target):
-                if not _is_private(n):
-                    unsafe_variables.add(n)
-
-    return classes, functions, safe_variable_sources, unsafe_variables
-
-
-def find_prisma_types_path() -> Path:
-    """Find the prisma types.py file in the installed package."""
-    spec = importlib.util.find_spec("prisma")
-    if spec is None or spec.origin is None:
-        raise RuntimeError("Could not find prisma package. Is it installed?")
-
-    prisma_dir = Path(spec.origin).parent
-    types_path = prisma_dir / "types.py"
-
-    if not types_path.exists():
-        raise RuntimeError(f"prisma/types.py not found at {types_path}")
-
-    return types_path
-
-
-def generate_stub(src_path: Path, stub_path: Path) -> int:
-    """Generate the .pyi stub file from the source types.py."""
-    code = src_path.read_text(encoding="utf-8", errors="ignore")
-    source_lines = code.splitlines()
-    tree = ast.parse(code, filename=str(src_path))
-    classes, functions, safe_variable_sources, unsafe_variables = (
-        collect_top_level_symbols(tree, source_lines)
-    )
-
-    header = """\
-# -*- coding: utf-8 -*-
-# Auto-generated stub file - DO NOT EDIT
-# Generated by gen_prisma_types_stub.py
-#
-# This stub intentionally collapses complex Prisma query DSL types to Any.
-# Prisma's generated types can explode Pyright's type inference budgets
-# on large schemas. We collapse them to Any so the rest of the codebase
-# can remain strongly typed while keeping runtime behavior unchanged.
-#
-# Safe types (Literal, TypeVar, simple references) are preserved from the
-# original types.py to maintain proper type checking where possible.
-
-from __future__ import annotations
-from typing import Any
-from typing_extensions import Literal
-
-# Re-export commonly used typing constructs that may be imported from this module
-from typing import TYPE_CHECKING, TypeVar, Generic, Union, Optional, List, Dict
-
-# Base type alias for stubbed Prisma types - allows any dict structure
-_PrismaDict = dict[str, Any]
-
-"""
-
-    lines = [header]
-
-    # Include safe variable definitions (Literal types, TypeVars, etc.)
-    lines.append("# Safe type definitions preserved from original types.py")
-    for source in safe_variable_sources:
-        lines.append(source)
-    lines.append("")
-
-    # Stub all classes and unsafe variables uniformly as dict[str, Any] aliases
-    # This allows:
-    # 1. Use in type annotations: x: SomeType
-    # 2. Constructor calls: SomeType(...)
-    # 3. Dict literal assignments: x: SomeType = {...}
-    lines.append(
-        "# Stubbed types (collapsed to dict[str, Any] to prevent type budget exhaustion)"
-    )
-    all_stubbed = sorted(classes | unsafe_variables)
-    for name in all_stubbed:
-        lines.append(f"{name} = _PrismaDict")
-
-    lines.append("")
-
-    # Stub functions
-    for name in sorted(functions):
-        lines.append(f"def {name}(*args: Any, **kwargs: Any) -> Any: ...")
-
-    lines.append("")
-
-    stub_path.write_text("\n".join(lines), encoding="utf-8")
-    return (
-        len(classes)
-        + len(functions)
-        + len(safe_variable_sources)
-        + len(unsafe_variables)
-    )
-
-
-def main() -> None:
-    """Main entry point."""
-    try:
-        types_path = find_prisma_types_path()
-        stub_path = types_path.with_suffix(".pyi")
-
-        print(f"Found prisma types.py at: {types_path}")
-        print(f"Generating stub at: {stub_path}")
-
-        num_symbols = generate_stub(types_path, stub_path)
-        print(f"Generated {stub_path.name} with {num_symbols} Any-typed symbols")
-
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

autogpt_platform/backend/linter.py

@@ -25,9 +25,6 @@ def run(*command: str) -> None:
 
 
 def lint():
-    # Generate Prisma types stub before running pyright to prevent type budget exhaustion
-    run("gen-prisma-stub")
-
     lint_step_args: list[list[str]] = [
         ["ruff", "check", *TARGET_DIRS, "--exit-zero"],
         ["ruff", "format", "--diff", "--check", LIBS_DIR],
@@ -52,6 +49,4 @@ def format():
     run("ruff", "format", LIBS_DIR)
     run("isort", "--profile", "black", BACKEND_DIR)
     run("black", BACKEND_DIR)
-    # Generate Prisma types stub before running pyright to prevent type budget exhaustion
-    run("gen-prisma-stub")
     run("pyright", *TARGET_DIRS)

autogpt_platform/backend/migrations/20260109181714_add_docs_embedding/migration.sql

@@ -1,42 +0,0 @@
--- CreateExtension
--- Supabase: pgvector must be enabled via Dashboard → Database → Extensions first
--- This migration only verifies the extension exists and is accessible
--- The vector type is available across all schemas once enabled
-CREATE EXTENSION IF NOT EXISTS vector;
-
--- CreateEnum
-CREATE TYPE "ContentType" AS ENUM ('STORE_AGENT', 'BLOCK', 'INTEGRATION', 'DOCUMENTATION', 'LIBRARY_AGENT');
-
--- CreateTable
-CREATE TABLE "UnifiedContentEmbedding" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "contentType" "ContentType" NOT NULL,
-    "contentId" TEXT NOT NULL,
-    "userId" TEXT,
-    "embedding" vector(1536) NOT NULL,
-    "searchableText" TEXT NOT NULL,
-    "metadata" JSONB NOT NULL DEFAULT '{}',
-
-    CONSTRAINT "UnifiedContentEmbedding_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE INDEX "UnifiedContentEmbedding_contentType_idx" ON "UnifiedContentEmbedding"("contentType");
-
--- CreateIndex
-CREATE INDEX "UnifiedContentEmbedding_userId_idx" ON "UnifiedContentEmbedding"("userId");
-
--- CreateIndex
-CREATE INDEX "UnifiedContentEmbedding_contentType_userId_idx" ON "UnifiedContentEmbedding"("contentType", "userId");
-
--- CreateIndex
--- NULLS NOT DISTINCT ensures only one public (NULL userId) embedding per contentType+contentId
--- Requires PostgreSQL 15+. Supabase uses PostgreSQL 15+.
-CREATE UNIQUE INDEX "UnifiedContentEmbedding_contentType_contentId_userId_key" ON "UnifiedContentEmbedding"("contentType", "contentId", "userId") NULLS NOT DISTINCT;
-
--- CreateIndex
--- HNSW index for fast vector similarity search on embeddings
--- Uses cosine distance operator (<=>), which matches the query in hybrid_search.py
-CREATE INDEX "UnifiedContentEmbedding_embedding_idx" ON "UnifiedContentEmbedding" USING hnsw ("embedding" vector_cosine_ops);

autogpt_platform/backend/migrations/20260112173500_add_supabase_extensions_to_platform_schema/migration.sql

@@ -1,71 +0,0 @@
--- Acknowledge Supabase-managed extensions to prevent drift warnings
--- These extensions are pre-installed by Supabase in specific schemas
--- This migration ensures they exist where available (Supabase) or skips gracefully (CI)
-
--- Create schemas (safe in both CI and Supabase)
-CREATE SCHEMA IF NOT EXISTS "extensions";
-
--- Extensions that exist in both CI and Supabase
-DO $$
-BEGIN
-    CREATE EXTENSION IF NOT EXISTS "pgcrypto" WITH SCHEMA "extensions";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'pgcrypto extension not available, skipping';
-END $$;
-
-DO $$
-BEGIN
-    CREATE EXTENSION IF NOT EXISTS "uuid-ossp" WITH SCHEMA "extensions";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'uuid-ossp extension not available, skipping';
-END $$;
-
--- Supabase-specific extensions (skip gracefully in CI)
-DO $$
-BEGIN
-    CREATE EXTENSION IF NOT EXISTS "pg_stat_statements" WITH SCHEMA "extensions";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'pg_stat_statements extension not available, skipping';
-END $$;
-
-DO $$
-BEGIN
-    CREATE EXTENSION IF NOT EXISTS "pg_net" WITH SCHEMA "extensions";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'pg_net extension not available, skipping';
-END $$;
-
-DO $$
-BEGIN
-    CREATE EXTENSION IF NOT EXISTS "pgjwt" WITH SCHEMA "extensions";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'pgjwt extension not available, skipping';
-END $$;
-
-DO $$
-BEGIN
-    CREATE SCHEMA IF NOT EXISTS "graphql";
-    CREATE EXTENSION IF NOT EXISTS "pg_graphql" WITH SCHEMA "graphql";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'pg_graphql extension not available, skipping';
-END $$;
-
-DO $$
-BEGIN
-    CREATE SCHEMA IF NOT EXISTS "pgsodium";
-    CREATE EXTENSION IF NOT EXISTS "pgsodium" WITH SCHEMA "pgsodium";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'pgsodium extension not available, skipping';
-END $$;
-
-DO $$
-BEGIN
-    CREATE SCHEMA IF NOT EXISTS "vault";
-    CREATE EXTENSION IF NOT EXISTS "supabase_vault" WITH SCHEMA "vault";
-EXCEPTION WHEN OTHERS THEN
-    RAISE NOTICE 'supabase_vault extension not available, skipping';
-END $$;
-
-
--- Return to platform
-CREATE SCHEMA IF NOT EXISTS "platform";

autogpt_platform/backend/migrations/20260113170839_add_ended_at_to_agent_graph_execution/migration.sql

@@ -0,0 +1,8 @@
+-- AlterTable
+ALTER TABLE "AgentGraphExecution" ADD COLUMN "endedAt" TIMESTAMP(3);
+
+-- Set endedAt to updatedAt for existing records with terminal status only
+UPDATE "AgentGraphExecution"
+SET "endedAt" = "updatedAt"
+WHERE "endedAt" IS NULL
+  AND "executionStatus" IN ('COMPLETED', 'FAILED', 'TERMINATED');

autogpt_platform/backend/pyproject.toml

@@ -117,7 +117,6 @@ lint = "linter:lint"
 test = "run_tests:test"
 load-store-agents = "test.load_store_agents:run"
 export-api-schema = "backend.cli.generate_openapi_json:main"
-gen-prisma-stub = "gen_prisma_types_stub:main"
 oauth-tool = "backend.cli.oauth_tool:cli"
 
 [tool.isort]
@@ -135,9 +134,6 @@ ignore_patterns = []
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "session"
-# Disable syrupy plugin to avoid conflict with pytest-snapshot
-# Both provide --snapshot-update argument causing ArgumentError
-addopts = "-p no:syrupy"
 filterwarnings = [
     "ignore:'audioop' is deprecated:DeprecationWarning:discord.player",
     "ignore:invalid escape sequence:DeprecationWarning:tweepy.api",

autogpt_platform/backend/schema.prisma

@@ -1,15 +1,14 @@
 datasource db {
-  provider   = "postgresql"
-  url        = env("DATABASE_URL")
-  directUrl  = env("DIRECT_URL")
-  extensions = [pgvector(map: "vector")]
+  provider  = "postgresql"
+  url       = env("DATABASE_URL")
+  directUrl = env("DIRECT_URL")
 }
 
 generator client {
   provider               = "prisma-client-py"
   recursive_type_depth   = -1
   interface              = "asyncio"
-  previewFeatures        = ["views", "fullTextSearch", "postgresqlExtensions"]
+  previewFeatures        = ["views", "fullTextSearch"]
   partial_type_generator = "backend/data/partial_types.py"
 }
 
@@ -128,8 +127,8 @@ model BuilderSearchHistory {
   updatedAt DateTime @default(now()) @updatedAt
 
   searchQuery String
-  filter      String[] @default([])
-  byCreator   String[] @default([])
+  filter      String[]  @default([])
+  byCreator   String[]  @default([])
 
   userId String
   User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
@@ -384,6 +383,7 @@ model AgentGraphExecution {
   createdAt DateTime  @default(now())
   updatedAt DateTime? @updatedAt
   startedAt DateTime?
+  endedAt   DateTime?
 
   isDeleted Boolean @default(false)
 
@@ -722,25 +722,26 @@ view StoreAgent {
   storeListingVersionId String
   updated_at            DateTime
 
-  slug              String
-  agent_name        String
-  agent_video       String?
-  agent_output_demo String?
-  agent_image       String[]
+  slug                String
+  agent_name          String
+  agent_video         String?
+  agent_output_demo   String?
+  agent_image         String[]
 
-  featured           Boolean  @default(false)
-  creator_username   String?
-  creator_avatar     String?
-  sub_heading        String
-  description        String
-  categories         String[]
-  runs               Int
-  rating             Float
-  versions           String[]
-  agentGraphVersions String[]
-  agentGraphId       String
-  is_available       Boolean  @default(true)
-  useForOnboarding   Boolean  @default(false)
+  featured         Boolean                  @default(false)
+  creator_username String?
+  creator_avatar   String?
+  sub_heading      String
+  description      String
+  categories       String[]
+  search           Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
+  runs                Int
+  rating              Float
+  versions            String[]
+  agentGraphVersions  String[]
+  agentGraphId        String
+  is_available        Boolean                  @default(true)
+  useForOnboarding    Boolean                  @default(false)
 
   // Materialized views used (refreshed every 15 minutes via pg_cron):
   // - mv_agent_run_counts - Pre-aggregated agent execution counts by agentGraphId
@@ -856,14 +857,14 @@ model StoreListingVersion {
   AgentGraph        AgentGraph @relation(fields: [agentGraphId, agentGraphVersion], references: [id, version])
 
   // Content fields
-  name               String
-  subHeading         String
-  videoUrl           String?
-  agentOutputDemoUrl String?
-  imageUrls          String[]
-  description        String
-  instructions       String?
-  categories         String[]
+  name                String
+  subHeading          String
+  videoUrl            String?
+  agentOutputDemoUrl  String?
+  imageUrls           String[]
+  description         String
+  instructions        String?
+  categories          String[]
 
   isFeatured Boolean @default(false)
 
@@ -899,9 +900,6 @@ model StoreListingVersion {
   // Reviews for this specific version
   Reviews StoreListingReview[]
 
-  // Note: Embeddings now stored in UnifiedContentEmbedding table
-  // Use contentType=STORE_AGENT and contentId=storeListingVersionId
-
   @@unique([storeListingId, version])
   @@index([storeListingId, submissionStatus, isAvailable])
   @@index([submissionStatus])
@@ -909,42 +907,6 @@ model StoreListingVersion {
   @@index([agentGraphId, agentGraphVersion]) // Non-unique index for efficient lookups
 }
 
-// Content type enum for unified search across store agents, blocks, docs
-// Note: BLOCK/INTEGRATION are file-based (Python classes), not DB records
-// DOCUMENTATION are file-based (.md files), not DB records  
-// Only STORE_AGENT and LIBRARY_AGENT are stored in database
-enum ContentType {
-  STORE_AGENT // Database: StoreListingVersion
-  BLOCK // File-based: Python classes in /backend/blocks/
-  INTEGRATION // File-based: Python classes (blocks with credentials)
-  DOCUMENTATION // File-based: .md/.mdx files
-  LIBRARY_AGENT // Database: User's personal agents
-}
-
-// Unified embeddings table for all searchable content types
-// Supports both public content (userId=null) and user-specific content (userId=userID)
-model UnifiedContentEmbedding {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  // Content identification
-  contentType ContentType
-  contentId   String // DB ID (storeListingVersionId) or file identifier (block.id, file_path)
-  userId      String? // NULL for public content (store, blocks, docs), userId for private content (library agents)
-
-  // Search data
-  embedding      Unsupported("vector(1536)") // pgvector embedding (extension in platform schema)
-  searchableText String // Combined text for search and fallback
-  metadata       Json                        @default("{}") // Content-specific metadata
-
-  @@unique([contentType, contentId, userId], map: "UnifiedContentEmbedding_contentType_contentId_userId_key")
-  @@index([contentType])
-  @@index([userId])
-  @@index([contentType, userId])
-  @@index([embedding], map: "UnifiedContentEmbedding_embedding_idx")
-}
-
 model StoreListingReview {
   id        String   @id @default(uuid())
   createdAt DateTime @default(now())
@@ -1037,16 +999,16 @@ model OAuthApplication {
   updatedAt DateTime @updatedAt
 
   // Application metadata
-  name             String
-  description      String?
-  logoUrl          String? // URL to app logo stored in GCS
-  clientId         String  @unique
-  clientSecret     String // Hashed with Scrypt (same as API keys)
-  clientSecretSalt String // Salt for Scrypt hashing
+  name               String
+  description        String?
+  logoUrl            String? // URL to app logo stored in GCS
+  clientId           String @unique
+  clientSecret       String // Hashed with Scrypt (same as API keys)
+  clientSecretSalt   String // Salt for Scrypt hashing
 
   // OAuth configuration
   redirectUris String[] // Allowed callback URLs
-  grantTypes   String[]           @default(["authorization_code", "refresh_token"])
+  grantTypes   String[] @default(["authorization_code", "refresh_token"])
   scopes       APIKeyPermission[] // Which permissions the app can request
 
   // Application management

autogpt_platform/backend/snapshots/grph_single

@@ -2,7 +2,6 @@
   "created_at": "2025-09-04T13:37:00",
   "credentials_input_schema": {
     "properties": {},
-    "required": [],
     "title": "TestGraphCredentialsInputSchema",
     "type": "object"
   },

autogpt_platform/backend/snapshots/grphs_all

@@ -2,7 +2,6 @@
   {
     "credentials_input_schema": {
       "properties": {},
-      "required": [],
       "title": "TestGraphCredentialsInputSchema",
       "type": "object"
     },

autogpt_platform/backend/snapshots/lib_agts_search

@@ -4,7 +4,6 @@
       "id": "test-agent-1",
       "graph_id": "test-agent-1",
       "graph_version": 1,
-      "owner_user_id": "3e53486c-cf57-477e-ba2a-cb02dc828e1a",
       "image_url": null,
       "creator_name": "Test Creator",
       "creator_image_url": "",
@@ -42,7 +41,6 @@
       "id": "test-agent-2",
       "graph_id": "test-agent-2",
       "graph_version": 1,
-      "owner_user_id": "3e53486c-cf57-477e-ba2a-cb02dc828e1a",
       "image_url": null,
       "creator_name": "Test Creator",
       "creator_image_url": "",

autogpt_platform/backend/snapshots/sub_success

@@ -1,7 +1,6 @@
 {
   "submissions": [
     {
-      "listing_id": "test-listing-id",
       "agent_id": "test-agent-id",
       "agent_version": 1,
       "name": "Test Agent",

autogpt_platform/docker-compose.platform.yml

@@ -37,7 +37,7 @@ services:
       context: ../
       dockerfile: autogpt_platform/backend/Dockerfile
       target: migrate
-    command: ["sh", "-c", "poetry run prisma generate && poetry run gen-prisma-stub && poetry run prisma migrate deploy"]
+    command: ["sh", "-c", "poetry run prisma generate && poetry run prisma migrate deploy"]
     develop:
       watch:
         - path: ./

autogpt_platform/frontend/package.json

@@ -92,6 +92,7 @@
     "react-currency-input-field": "4.0.3",
     "react-day-picker": "9.11.1",
     "react-dom": "18.3.1",
+    "react-drag-drop-files": "2.4.0",
     "react-hook-form": "7.66.0",
     "react-icons": "5.5.0",
     "react-markdown": "9.0.3",

autogpt_platform/frontend/pnpm-lock.yaml

@@ -200,6 +200,9 @@ importers:
       react-dom:
         specifier: 18.3.1
         version: 18.3.1(react@18.3.1)
+      react-drag-drop-files:
+        specifier: 2.4.0
+        version: 2.4.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       react-hook-form:
         specifier: 7.66.0
         version: 7.66.0(react@18.3.1)
@@ -1001,6 +1004,9 @@ packages:
   '@emotion/memoize@0.8.1':
     resolution: {integrity: sha512-W2P2c/VRW1/1tLox0mVUalvnWXxavmv/Oum2aPsRcoDJuob75FC3Y8FbpfLwUegRcxINtGUMPq0tFCvYNTBXNA==}
 
+  '@emotion/unitless@0.8.1':
+    resolution: {integrity: sha512-KOEGMu6dmJZtpadb476IsZBclKvILjopjUii3V+7MnXIQCYh8W3NgNcgwo21n9LXZX6EDIKvqfjYxXebDwxKmQ==}
+
   '@epic-web/invariant@1.0.0':
     resolution: {integrity: sha512-lrTPqgvfFQtR/eY/qkIzp98OGdNJu0m5ji3q/nJI8v3SXkRKEnWiOxMmbvcSoAIzv/cGiuvRy57k4suKQSAdwA==}
 
@@ -3116,6 +3122,9 @@ packages:
   '@types/statuses@2.0.6':
     resolution: {integrity: sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==}
 
+  '@types/stylis@4.2.7':
+    resolution: {integrity: sha512-VgDNokpBoKF+wrdvhAAfS55OMQpL6QRglwTwNC3kIgBrzZxA4WsFj+2eLfEA/uMUDzBcEhYmjSbwQakn/i3ajA==}
+
   '@types/tedious@4.0.14':
     resolution: {integrity: sha512-KHPsfX/FoVbUGbyYvk1q9MMQHLPeRZhRJZdO45Q4YjvFkv4hMNghCWTvy7rdKessBsmtz4euWCWAB6/tVpI1Iw==}
 
@@ -3772,6 +3781,9 @@ packages:
     resolution: {integrity: sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==}
     engines: {node: '>= 6'}
 
+  camelize@1.0.1:
+    resolution: {integrity: sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ==}
+
   caniuse-lite@1.0.30001762:
     resolution: {integrity: sha512-PxZwGNvH7Ak8WX5iXzoK1KPZttBXNPuaOvI2ZYU7NrlM+d9Ov+TUvlLOBNGzVXAntMSMMlJPd+jY6ovrVjSmUw==}
 
@@ -3985,6 +3997,10 @@ packages:
     resolution: {integrity: sha512-r4ESw/IlusD17lgQi1O20Fa3qNnsckR126TdUuBgAu7GBYSIPvdNyONd3Zrxh0xCwA4+6w/TDArBPsMvhur+KQ==}
     engines: {node: '>= 0.10'}
 
+  css-color-keywords@1.0.0:
+    resolution: {integrity: sha512-FyyrDHZKEjXDpNJYvVsV960FiqQyXc/LlYmsxl2BcdMb2WPx0OGRVgTg55rPSyLSNMqP52R9r8geSp7apN3Ofg==}
+    engines: {node: '>=4'}
+
   css-loader@6.11.0:
     resolution: {integrity: sha512-CTJ+AEQJjq5NzLga5pE39qdiSV56F8ywCIsqNIRF0r7BDgWsN25aazToqAFg7ZrtA/U016xudB3ffgweORxX7g==}
     engines: {node: '>= 12.13.0'}
@@ -4000,6 +4016,9 @@ packages:
   css-select@4.3.0:
     resolution: {integrity: sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==}
 
+  css-to-react-native@3.2.0:
+    resolution: {integrity: sha512-e8RKaLXMOFii+02mOlqwjbD00KSEKqblnpO9e++1aXS1fPQOpS1YoqdVHBqPjHNoxeF2mimzVqawm2KCbEdtHQ==}
+
   css-what@6.2.2:
     resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==}
     engines: {node: '>= 6'}
@@ -6112,6 +6131,10 @@ packages:
     resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==}
     engines: {node: ^10 || ^12 || >=14}
 
+  postcss@8.4.49:
+    resolution: {integrity: sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==}
+    engines: {node: ^10 || ^12 || >=14}
+
   postcss@8.5.6:
     resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
     engines: {node: ^10 || ^12 || >=14}
@@ -6283,6 +6306,12 @@ packages:
     peerDependencies:
       react: ^18.3.1
 
+  react-drag-drop-files@2.4.0:
+    resolution: {integrity: sha512-MGPV3HVVnwXEXq3gQfLtSU3jz5j5jrabvGedokpiSEMoONrDHgYl/NpIOlfsqGQ4zBv1bzzv7qbKURZNOX32PA==}
+    peerDependencies:
+      react: ^18.0.0
+      react-dom: ^18.0.0
+
   react-hook-form@7.66.0:
     resolution: {integrity: sha512-xXBqsWGKrY46ZqaHDo+ZUYiMUgi8suYu5kdrS20EG8KiL7VRQitEbNjm+UcrDYrNi1YLyfpmAeGjCZYXLT9YBw==}
     engines: {node: '>=18.0.0'}
@@ -6649,6 +6678,9 @@ packages:
     engines: {node: '>= 0.10'}
     hasBin: true
 
+  shallowequal@1.1.0:
+    resolution: {integrity: sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==}
+
   sharp@0.34.5:
     resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -6862,6 +6894,13 @@ packages:
   style-to-object@1.0.14:
     resolution: {integrity: sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==}
 
+  styled-components@6.2.0:
+    resolution: {integrity: sha512-ryFCkETE++8jlrBmC+BoGPUN96ld1/Yp0s7t5bcXDobrs4XoXroY1tN+JbFi09hV6a5h3MzbcVi8/BGDP0eCgQ==}
+    engines: {node: '>= 16'}
+    peerDependencies:
+      react: '>= 16.8.0'
+      react-dom: '>= 16.8.0'
+
   styled-jsx@5.1.6:
     resolution: {integrity: sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA==}
     engines: {node: '>= 12.0.0'}
@@ -6888,6 +6927,9 @@ packages:
       babel-plugin-macros:
         optional: true
 
+  stylis@4.3.6:
+    resolution: {integrity: sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==}
+
   sucrase@3.35.1:
     resolution: {integrity: sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==}
     engines: {node: '>=16 || 14 >=14.17'}
@@ -7054,6 +7096,9 @@ packages:
   tslib@1.14.1:
     resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
 
+  tslib@2.6.2:
+    resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==}
+
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
@@ -8290,10 +8335,10 @@ snapshots:
   '@emotion/is-prop-valid@1.2.2':
     dependencies:
       '@emotion/memoize': 0.8.1
-    optional: true
 
-  '@emotion/memoize@0.8.1':
-    optional: true
+  '@emotion/memoize@0.8.1': {}
+
+  '@emotion/unitless@0.8.1': {}
 
   '@epic-web/invariant@1.0.0': {}
 
@@ -10689,6 +10734,8 @@ snapshots:
 
   '@types/statuses@2.0.6': {}
 
+  '@types/stylis@4.2.7': {}
+
   '@types/tedious@4.0.14':
     dependencies:
       '@types/node': 24.10.0
@@ -11385,6 +11432,8 @@ snapshots:
 
   camelcase-css@2.0.1: {}
 
+  camelize@1.0.1: {}
+
   caniuse-lite@1.0.30001762: {}
 
   case-sensitive-paths-webpack-plugin@2.4.0: {}
@@ -11596,6 +11645,8 @@ snapshots:
       randombytes: 2.1.0
       randomfill: 1.0.4
 
+  css-color-keywords@1.0.0: {}
+
   css-loader@6.11.0(webpack@5.104.1(esbuild@0.25.12)):
     dependencies:
       icss-utils: 5.1.0(postcss@8.5.6)
@@ -11617,6 +11668,12 @@ snapshots:
       domutils: 2.8.0
       nth-check: 2.1.1
 
+  css-to-react-native@3.2.0:
+    dependencies:
+      camelize: 1.0.1
+      css-color-keywords: 1.0.0
+      postcss-value-parser: 4.2.0
+
   css-what@6.2.2: {}
 
   css.escape@1.5.1: {}
@@ -12070,8 +12127,8 @@ snapshots:
       '@typescript-eslint/parser': 8.52.0(eslint@8.57.1)(typescript@5.9.3)
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@8.57.1)
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
       eslint-plugin-jsx-a11y: 6.10.2(eslint@8.57.1)
       eslint-plugin-react: 7.37.5(eslint@8.57.1)
       eslint-plugin-react-hooks: 5.2.0(eslint@8.57.1)
@@ -12090,7 +12147,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0)(eslint@8.57.1):
+  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       '@nolyfill/is-core-module': 1.0.39
       debug: 4.4.3
@@ -12101,22 +12158,22 @@ snapshots:
       tinyglobby: 0.2.15
       unrs-resolver: 1.11.1
     optionalDependencies:
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
       '@typescript-eslint/parser': 8.52.0(eslint@8.57.1)(typescript@5.9.3)
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@8.57.1)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9
@@ -12127,7 +12184,7 @@ snapshots:
       doctrine: 2.1.0
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.52.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
       hasown: 2.0.2
       is-core-module: 2.16.1
       is-glob: 4.0.3
@@ -14202,6 +14259,12 @@ snapshots:
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
+  postcss@8.4.49:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
   postcss@8.5.6:
     dependencies:
       nanoid: 3.3.11
@@ -14323,6 +14386,13 @@ snapshots:
       react: 18.3.1
       scheduler: 0.23.2
 
+  react-drag-drop-files@2.4.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      prop-types: 15.8.1
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+      styled-components: 6.2.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+
   react-hook-form@7.66.0(react@18.3.1):
     dependencies:
       react: 18.3.1
@@ -14816,6 +14886,8 @@ snapshots:
       safe-buffer: 5.2.1
       to-buffer: 1.2.2
 
+  shallowequal@1.1.0: {}
+
   sharp@0.34.5:
     dependencies:
       '@img/colour': 1.0.0
@@ -15106,6 +15178,20 @@ snapshots:
     dependencies:
       inline-style-parser: 0.2.7
 
+  styled-components@6.2.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      '@emotion/is-prop-valid': 1.2.2
+      '@emotion/unitless': 0.8.1
+      '@types/stylis': 4.2.7
+      css-to-react-native: 3.2.0
+      csstype: 3.2.3
+      postcss: 8.4.49
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+      shallowequal: 1.1.0
+      stylis: 4.3.6
+      tslib: 2.6.2
+
   styled-jsx@5.1.6(@babel/core@7.28.5)(react@18.3.1):
     dependencies:
       client-only: 0.0.1
@@ -15120,6 +15206,8 @@ snapshots:
     optionalDependencies:
       '@babel/core': 7.28.5
 
+  stylis@4.3.6: {}
+
   sucrase@3.35.1:
     dependencies:
       '@jridgewell/gen-mapping': 0.3.13
@@ -15302,6 +15390,8 @@ snapshots:
 
   tslib@1.14.1: {}
 
+  tslib@2.6.2: {}
+
   tslib@2.8.1: {}
 
   tty-browserify@0.0.1: {}

autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/AnalyticsResultsTable.tsx

@@ -51,6 +51,8 @@ export function AnalyticsResultsTable({ results }: Props) {
       "Execution ID",
       "Status",
       "Score",
+      "Started At",
+      "Ended At",
       "Summary Text",
       "Error Message",
     ];
@@ -62,6 +64,8 @@ export function AnalyticsResultsTable({ results }: Props) {
       result.exec_id,
       result.status,
       result.score?.toString() || "",
+      result.started_at ? new Date(result.started_at).toLocaleString() : "",
+      result.ended_at ? new Date(result.ended_at).toLocaleString() : "",
       `"${(result.summary_text || "").replace(/"/g, '""')}"`, // Escape quotes in summary
       `"${(result.error_message || "").replace(/"/g, '""')}"`, // Escape quotes in error
     ]);
@@ -248,15 +252,13 @@ export function AnalyticsResultsTable({ results }: Props) {
                         )}
                       </td>
                       <td className="px-4 py-3">
-                        {(result.summary_text || result.error_message) && (
-                          <Button
-                            variant="ghost"
-                            size="small"
-                            onClick={() => toggleRowExpansion(result.exec_id)}
-                          >
-                            <EyeIcon size={16} />
-                          </Button>
-                        )}
+                        <Button
+                          variant="ghost"
+                          size="small"
+                          onClick={() => toggleRowExpansion(result.exec_id)}
+                        >
+                          <EyeIcon size={16} />
+                        </Button>
                       </td>
                     </tr>
 
@@ -264,6 +266,44 @@ export function AnalyticsResultsTable({ results }: Props) {
                       <tr>
                         <td colSpan={7} className="bg-gray-50 px-4 py-3">
                           <div className="space-y-3">
+                            {/* Timestamps section */}
+                            <div className="grid grid-cols-2 gap-4 border-b border-gray-200 pb-3">
+                              <div>
+                                <Text
+                                  variant="body"
+                                  className="text-xs font-medium text-gray-600"
+                                >
+                                  Started At:
+                                </Text>
+                                <Text
+                                  variant="body"
+                                  className="text-sm text-gray-700"
+                                >
+                                  {result.started_at
+                                    ? new Date(
+                                        result.started_at,
+                                      ).toLocaleString()
+                                    : "—"}
+                                </Text>
+                              </div>
+                              <div>
+                                <Text
+                                  variant="body"
+                                  className="text-xs font-medium text-gray-600"
+                                >
+                                  Ended At:
+                                </Text>
+                                <Text
+                                  variant="body"
+                                  className="text-sm text-gray-700"
+                                >
+                                  {result.ended_at
+                                    ? new Date(result.ended_at).toLocaleString()
+                                    : "—"}
+                                </Text>
+                              </div>
+                            </div>
+
                             {result.summary_text && (
                               <div>
                                 <Text

autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx

@@ -541,7 +541,19 @@ export function ExecutionAnalyticsForm() {
       {/* Accuracy Trends Display */}
       {trendsData && (
         <div className="space-y-4">
-          <h3 className="text-lg font-semibold">Execution Accuracy Trends</h3>
+          <div className="flex items-start justify-between">
+            <h3 className="text-lg font-semibold">Execution Accuracy Trends</h3>
+            <div className="rounded-md bg-blue-50 px-3 py-2 text-xs text-blue-700">
+              <p className="font-medium">
+                Chart Filters (matches monitoring system):
+              </p>
+              <ul className="mt-1 list-inside list-disc space-y-1">
+                <li>Only days with ≥1 execution with correctness score</li>
+                <li>Last 30 days</li>
+                <li>Averages calculated from scored executions only</li>
+              </ul>
+            </div>
+          </div>
 
           {/* Alert Section */}
           {trendsData.alert && (

autogpt_platform/frontend/src/app/(platform)/build/components/BuilderActions/components/RunInputDialog/RunInputDialog.tsx

@@ -66,7 +66,6 @@ export const RunInputDialog = ({
                     formContext={{
                       showHandles: false,
                       size: "large",
-                      showOptionalToggle: false,
                     }}
                   />
                 </div>

autogpt_platform/frontend/src/app/(platform)/build/components/BuilderActions/components/RunInputDialog/useRunInputDialog.ts

@@ -66,7 +66,7 @@ export const useRunInputDialog = ({
         if (isCredentialFieldSchema(fieldSchema)) {
           dynamicUiSchema[fieldName] = {
             ...dynamicUiSchema[fieldName],
-            "ui:field": "custom/credential_field",
+            "ui:field": "credentials",
           };
         }
       });
@@ -76,18 +76,12 @@ export const useRunInputDialog = ({
   }, [credentialsSchema]);
 
   const handleManualRun = async () => {
-    // Filter out incomplete credentials (those without a valid id)
-    // RJSF auto-populates const values (provider, type) but not id field
-    const validCredentials = Object.fromEntries(
-      Object.entries(credentialValues).filter(([_, cred]) => cred && cred.id),
-    );
-
     await executeGraph({
       graphId: flowID ?? "",
       graphVersion: flowVersion || null,
       data: {
         inputs: inputValues,
-        credentials_inputs: validCredentials,
+        credentials_inputs: credentialValues,
         source: "builder",
       },
     });

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/Flow/Flow.tsx

@@ -97,9 +97,6 @@ export const Flow = () => {
           onConnect={onConnect}
           onEdgesChange={onEdgesChange}
           onNodeDragStop={onNodeDragStop}
-          onNodeContextMenu={(event) => {
-            event.preventDefault();
-          }}
           maxZoom={2}
           minZoom={0.1}
           onDragOver={onDragOver}

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/CustomNode/CustomNode.tsx

@@ -1,25 +1,24 @@
-import { AgentExecutionStatus } from "@/app/api/__generated__/models/agentExecutionStatus";
-import { BlockCost } from "@/app/api/__generated__/models/blockCost";
-import { BlockInfoCategoriesItem } from "@/app/api/__generated__/models/blockInfoCategoriesItem";
-import { NodeExecutionResult } from "@/app/api/__generated__/models/nodeExecutionResult";
-import { NodeModelMetadata } from "@/app/api/__generated__/models/nodeModelMetadata";
-import { preprocessInputSchema } from "@/components/renderers/InputRenderer/utils/input-schema-pre-processor";
-import { cn } from "@/lib/utils";
-import { RJSFSchema } from "@rjsf/utils";
-import { NodeProps, Node as XYNode } from "@xyflow/react";
 import React from "react";
+import { Node as XYNode, NodeProps } from "@xyflow/react";
+import { RJSFSchema } from "@rjsf/utils";
 import { BlockUIType } from "../../../types";
-import { FormCreator } from "../FormCreator";
-import { OutputHandler } from "../OutputHandler";
-import { AyrshareConnectButton } from "./components/AyrshareConnectButton";
-import { NodeAdvancedToggle } from "./components/NodeAdvancedToggle";
-import { NodeContainer } from "./components/NodeContainer";
-import { NodeExecutionBadge } from "./components/NodeExecutionBadge";
-import { NodeHeader } from "./components/NodeHeader";
-import { NodeDataRenderer } from "./components/NodeOutput/NodeOutput";
-import { NodeRightClickMenu } from "./components/NodeRightClickMenu";
 import { StickyNoteBlock } from "./components/StickyNoteBlock";
+import { BlockInfoCategoriesItem } from "@/app/api/__generated__/models/blockInfoCategoriesItem";
+import { BlockCost } from "@/app/api/__generated__/models/blockCost";
+import { AgentExecutionStatus } from "@/app/api/__generated__/models/agentExecutionStatus";
+import { NodeExecutionResult } from "@/app/api/__generated__/models/nodeExecutionResult";
+import { NodeContainer } from "./components/NodeContainer";
+import { NodeHeader } from "./components/NodeHeader";
+import { FormCreator } from "../FormCreator";
+import { preprocessInputSchema } from "@/components/renderers/InputRenderer/utils/input-schema-pre-processor";
+import { OutputHandler } from "../OutputHandler";
+import { NodeAdvancedToggle } from "./components/NodeAdvancedToggle";
+import { NodeDataRenderer } from "./components/NodeOutput/NodeOutput";
+import { NodeExecutionBadge } from "./components/NodeExecutionBadge";
+import { cn } from "@/lib/utils";
 import { WebhookDisclaimer } from "./components/WebhookDisclaimer";
+import { AyrshareConnectButton } from "./components/AyrshareConnectButton";
+import { NodeModelMetadata } from "@/app/api/__generated__/models/nodeModelMetadata";
 
 export type CustomNodeData = {
   hardcodedValues: {
@@ -89,7 +88,7 @@ export const CustomNode: React.FC<NodeProps<CustomNode>> = React.memo(
 
     // Currently all blockTypes design are similar - that's why i am using the same component for all of them
     // If in future - if we need some drastic change in some blockTypes design - we can create separate components for them
-    const node = (
+    return (
       <NodeContainer selected={selected} nodeId={nodeId} hasErrors={hasErrors}>
         <div className="rounded-xlarge bg-white">
           <NodeHeader data={data} nodeId={nodeId} />
@@ -118,15 +117,6 @@ export const CustomNode: React.FC<NodeProps<CustomNode>> = React.memo(
         <NodeExecutionBadge nodeId={nodeId} />
       </NodeContainer>
     );
-
-    return (
-      <NodeRightClickMenu
-        nodeId={nodeId}
-        subGraphID={data.hardcodedValues?.graph_id}
-      >
-        {node}
-      </NodeRightClickMenu>
-    );
   },
 );
 

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/CustomNode/components/NodeContextMenu.tsx

@@ -1,31 +1,26 @@
-import { useCopyPasteStore } from "@/app/(platform)/build/stores/copyPasteStore";
-import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
+import { Separator } from "@/components/__legacy__/ui/separator";
 import {
   DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
   DropdownMenuTrigger,
 } from "@/components/molecules/DropdownMenu/DropdownMenu";
-import {
-  SecondaryDropdownMenuContent,
-  SecondaryDropdownMenuItem,
-  SecondaryDropdownMenuSeparator,
-} from "@/components/molecules/SecondaryMenu/SecondaryMenu";
-import {
-  ArrowSquareOutIcon,
-  CopyIcon,
-  DotsThreeOutlineVerticalIcon,
-  TrashIcon,
-} from "@phosphor-icons/react";
+import { DotsThreeOutlineVerticalIcon } from "@phosphor-icons/react";
+import { Copy, Trash2, ExternalLink } from "lucide-react";
+import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
+import { useCopyPasteStore } from "@/app/(platform)/build/stores/copyPasteStore";
 import { useReactFlow } from "@xyflow/react";
 
-type Props = {
+export const NodeContextMenu = ({
+  nodeId,
+  subGraphID,
+}: {
   nodeId: string;
   subGraphID?: string;
-};
-
-export const NodeContextMenu = ({ nodeId, subGraphID }: Props) => {
+}) => {
   const { deleteElements } = useReactFlow();
 
-  function handleCopy() {
+  const handleCopy = () => {
     useNodeStore.setState((state) => ({
       nodes: state.nodes.map((node) => ({
         ...node,
@@ -35,47 +30,47 @@ export const NodeContextMenu = ({ nodeId, subGraphID }: Props) => {
 
     useCopyPasteStore.getState().copySelectedNodes();
     useCopyPasteStore.getState().pasteNodes();
-  }
+  };
 
-  function handleDelete() {
+  const handleDelete = () => {
     deleteElements({ nodes: [{ id: nodeId }] });
-  }
+  };
 
   return (
     <DropdownMenu>
       <DropdownMenuTrigger className="py-2">
         <DotsThreeOutlineVerticalIcon size={16} weight="fill" />
       </DropdownMenuTrigger>
-      <SecondaryDropdownMenuContent side="right" align="start">
-        <SecondaryDropdownMenuItem onClick={handleCopy}>
-          <CopyIcon size={20} className="mr-2 dark:text-gray-100" />
-          <span className="dark:text-gray-100">Copy</span>
-        </SecondaryDropdownMenuItem>
-        <SecondaryDropdownMenuSeparator />
+      <DropdownMenuContent
+        side="right"
+        align="start"
+        className="rounded-xlarge"
+      >
+        <DropdownMenuItem onClick={handleCopy} className="hover:rounded-xlarge">
+          <Copy className="mr-2 h-4 w-4" />
+          Copy Node
+        </DropdownMenuItem>
 
         {subGraphID && (
-          <>
-            <SecondaryDropdownMenuItem
-              onClick={() => window.open(`/build?flowID=${subGraphID}`)}
-            >
-              <ArrowSquareOutIcon
-                size={20}
-                className="mr-2 dark:text-gray-100"
-              />
-              <span className="dark:text-gray-100">Open agent</span>
-            </SecondaryDropdownMenuItem>
-            <SecondaryDropdownMenuSeparator />
-          </>
+          <DropdownMenuItem
+            onClick={() => window.open(`/build?flowID=${subGraphID}`)}
+            className="hover:rounded-xlarge"
+          >
+            <ExternalLink className="mr-2 h-4 w-4" />
+            Open Agent
+          </DropdownMenuItem>
         )}
 
-        <SecondaryDropdownMenuItem variant="destructive" onClick={handleDelete}>
-          <TrashIcon
-            size={20}
-            className="mr-2 text-red-500 dark:text-red-400"
-          />
-          <span className="dark:text-red-400">Delete</span>
-        </SecondaryDropdownMenuItem>
-      </SecondaryDropdownMenuContent>
+        <Separator className="my-2" />
+
+        <DropdownMenuItem
+          onClick={handleDelete}
+          className="text-red-600 hover:rounded-xlarge"
+        >
+          <Trash2 className="mr-2 h-4 w-4" />
+          Delete
+        </DropdownMenuItem>
+      </DropdownMenuContent>
     </DropdownMenu>
   );
 };

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/CustomNode/components/NodeHeader.tsx

@@ -1,24 +1,25 @@
-import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
 import { Text } from "@/components/atoms/Text/Text";
+import { beautifyString, cn } from "@/lib/utils";
+import { NodeCost } from "./NodeCost";
+import { NodeBadges } from "./NodeBadges";
+import { NodeContextMenu } from "./NodeContextMenu";
+import { CustomNodeData } from "../CustomNode";
+import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
+import { useState } from "react";
 import {
   Tooltip,
   TooltipContent,
   TooltipProvider,
   TooltipTrigger,
 } from "@/components/atoms/Tooltip/BaseTooltip";
-import { beautifyString, cn } from "@/lib/utils";
-import { useState } from "react";
-import { CustomNodeData } from "../CustomNode";
-import { NodeBadges } from "./NodeBadges";
-import { NodeContextMenu } from "./NodeContextMenu";
-import { NodeCost } from "./NodeCost";
 
-type Props = {
+export const NodeHeader = ({
+  data,
+  nodeId,
+}: {
   data: CustomNodeData;
   nodeId: string;
-};
-
-export const NodeHeader = ({ data, nodeId }: Props) => {
+}) => {
   const updateNodeData = useNodeStore((state) => state.updateNodeData);
   const title = (data.metadata?.customized_name as string) || data.title;
   const [isEditingTitle, setIsEditingTitle] = useState(false);
@@ -68,10 +69,7 @@ export const NodeHeader = ({ data, nodeId }: Props) => {
                 <Tooltip>
                   <TooltipTrigger asChild>
                     <div>
-                      <Text
-                        variant="large-semibold"
-                        className="line-clamp-1 hover:cursor-text"
-                      >
+                      <Text variant="large-semibold" className="line-clamp-1">
                         {beautifyString(title).replace("Block", "").trim()}
                       </Text>
                     </div>

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/CustomNode/components/NodeOutput/components/NodeDataViewer/NodeDataViewer.tsx

@@ -151,7 +151,7 @@ export const NodeDataViewer: FC<NodeDataViewerProps> = ({
         </div>
 
         <div className="flex justify-end pt-4">
-          {outputItems.length > 1 && (
+          {outputItems.length > 0 && (
             <OutputActions
               items={outputItems.map((item) => ({
                 value: item.value,

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/CustomNode/components/NodeRightClickMenu.tsx

@@ -1,104 +0,0 @@
-import { useCopyPasteStore } from "@/app/(platform)/build/stores/copyPasteStore";
-import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
-import {
-  SecondaryMenuContent,
-  SecondaryMenuItem,
-  SecondaryMenuSeparator,
-} from "@/components/molecules/SecondaryMenu/SecondaryMenu";
-import { ArrowSquareOutIcon, CopyIcon, TrashIcon } from "@phosphor-icons/react";
-import * as ContextMenu from "@radix-ui/react-context-menu";
-import { useReactFlow } from "@xyflow/react";
-import { useEffect, useRef } from "react";
-import { CustomNode } from "../CustomNode";
-
-type Props = {
-  nodeId: string;
-  subGraphID?: string;
-  children: React.ReactNode;
-};
-
-const DOUBLE_CLICK_TIMEOUT = 300;
-
-export function NodeRightClickMenu({ nodeId, subGraphID, children }: Props) {
-  const { deleteElements } = useReactFlow<CustomNode>();
-  const lastRightClickTime = useRef<number>(0);
-  const containerRef = useRef<HTMLDivElement>(null);
-
-  function copyNode() {
-    useNodeStore.setState((state) => ({
-      nodes: state.nodes.map((node) => ({
-        ...node,
-        selected: node.id === nodeId,
-      })),
-    }));
-
-    useCopyPasteStore.getState().copySelectedNodes();
-    useCopyPasteStore.getState().pasteNodes();
-  }
-
-  function deleteNode() {
-    deleteElements({ nodes: [{ id: nodeId }] });
-  }
-
-  useEffect(() => {
-    const container = containerRef.current;
-    if (!container) return;
-
-    function handleContextMenu(e: MouseEvent) {
-      const now = Date.now();
-      const timeSinceLastClick = now - lastRightClickTime.current;
-
-      if (timeSinceLastClick < DOUBLE_CLICK_TIMEOUT) {
-        e.stopImmediatePropagation();
-        lastRightClickTime.current = 0;
-        return;
-      }
-
-      lastRightClickTime.current = now;
-    }
-
-    container.addEventListener("contextmenu", handleContextMenu, true);
-
-    return () => {
-      container.removeEventListener("contextmenu", handleContextMenu, true);
-    };
-  }, []);
-
-  return (
-    <ContextMenu.Root>
-      <ContextMenu.Trigger asChild>
-        <div ref={containerRef}>{children}</div>
-      </ContextMenu.Trigger>
-      <SecondaryMenuContent>
-        <SecondaryMenuItem onSelect={copyNode}>
-          <CopyIcon size={20} className="mr-2 dark:text-gray-100" />
-          <span className="dark:text-gray-100">Copy</span>
-        </SecondaryMenuItem>
-        <SecondaryMenuSeparator />
-
-        {subGraphID && (
-          <>
-            <SecondaryMenuItem
-              onClick={() => window.open(`/build?flowID=${subGraphID}`)}
-            >
-              <ArrowSquareOutIcon
-                size={20}
-                className="mr-2 dark:text-gray-100"
-              />
-              <span className="dark:text-gray-100">Open agent</span>
-            </SecondaryMenuItem>
-            <SecondaryMenuSeparator />
-          </>
-        )}
-
-        <SecondaryMenuItem variant="destructive" onSelect={deleteNode}>
-          <TrashIcon
-            size={20}
-            className="mr-2 text-red-500 dark:text-red-400"
-          />
-          <span className="dark:text-red-400">Delete</span>
-        </SecondaryMenuItem>
-      </SecondaryMenuContent>
-    </ContextMenu.Root>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/helpers.ts

@@ -89,18 +89,6 @@ export function extractOptions(
 
 // get display type and color for schema types [need for type display next to field name]
 export const getTypeDisplayInfo = (schema: any) => {
-  if (
-    schema?.type === "array" &&
-    "format" in schema &&
-    schema.format === "table"
-  ) {
-    return {
-      displayType: "table",
-      colorClass: "!text-indigo-500",
-      hexColor: "#6366f1",
-    };
-  }
-
   if (schema?.type === "string" && schema?.format) {
     const formatMap: Record<
       string,

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/uiSchema.ts

@@ -1,6 +1,6 @@
 export const uiSchema = {
   credentials: {
-    "ui:field": "custom/credential_field",
+    "ui:field": "credentials",
     provider: { "ui:widget": "hidden" },
     type: { "ui:widget": "hidden" },
     id: { "ui:autofocus": true },

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/BlockMenuFilters/BlockMenuFilters.tsx

@@ -1,57 +0,0 @@
-import { useBlockMenuStore } from "@/app/(platform)/build/stores/blockMenuStore";
-import { FilterChip } from "../FilterChip";
-import { categories } from "./constants";
-import { FilterSheet } from "../FilterSheet/FilterSheet";
-import { GetV2BuilderSearchFilterAnyOfItem } from "@/app/api/__generated__/models/getV2BuilderSearchFilterAnyOfItem";
-
-export const BlockMenuFilters = () => {
-  const {
-    filters,
-    addFilter,
-    removeFilter,
-    categoryCounts,
-    creators,
-    addCreator,
-    removeCreator,
-  } = useBlockMenuStore();
-
-  const handleFilterClick = (filter: GetV2BuilderSearchFilterAnyOfItem) => {
-    if (filters.includes(filter)) {
-      removeFilter(filter);
-    } else {
-      addFilter(filter);
-    }
-  };
-
-  const handleCreatorClick = (creator: string) => {
-    if (creators.includes(creator)) {
-      removeCreator(creator);
-    } else {
-      addCreator(creator);
-    }
-  };
-
-  return (
-    <div className="flex flex-wrap gap-2">
-      <FilterSheet categories={categories} />
-      {creators.length > 0 &&
-        creators.map((creator) => (
-          <FilterChip
-            key={creator}
-            name={"Created by " + creator.slice(0, 10) + "..."}
-            selected={creators.includes(creator)}
-            onClick={() => handleCreatorClick(creator)}
-          />
-        ))}
-      {categories.map((category) => (
-        <FilterChip
-          key={category.key}
-          name={category.name}
-          selected={filters.includes(category.key)}
-          onClick={() => handleFilterClick(category.key)}
-          number={categoryCounts[category.key] ?? 0}
-        />
-      ))}
-    </div>
-  );
-};

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/BlockMenuFilters/constants.ts

@@ -1,15 +0,0 @@
-import { GetV2BuilderSearchFilterAnyOfItem } from "@/app/api/__generated__/models/getV2BuilderSearchFilterAnyOfItem";
-import { CategoryKey } from "./types";
-
-export const categories: Array<{ key: CategoryKey; name: string }> = [
-  { key: GetV2BuilderSearchFilterAnyOfItem.blocks, name: "Blocks" },
-  {
-    key: GetV2BuilderSearchFilterAnyOfItem.integrations,
-    name: "Integrations",
-  },
-  {
-    key: GetV2BuilderSearchFilterAnyOfItem.marketplace_agents,
-    name: "Marketplace agents",
-  },
-  { key: GetV2BuilderSearchFilterAnyOfItem.my_agents, name: "My agents" },
-];

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/BlockMenuFilters/types.ts

@@ -1,26 +0,0 @@
-import { GetV2BuilderSearchFilterAnyOfItem } from "@/app/api/__generated__/models/getV2BuilderSearchFilterAnyOfItem";
-
-export type DefaultStateType =
-  | "suggestion"
-  | "all_blocks"
-  | "input_blocks"
-  | "action_blocks"
-  | "output_blocks"
-  | "integrations"
-  | "marketplace_agents"
-  | "my_agents";
-
-export type CategoryKey = GetV2BuilderSearchFilterAnyOfItem;
-
-export interface Filters {
-  categories: {
-    blocks: boolean;
-    integrations: boolean;
-    marketplace_agents: boolean;
-    my_agents: boolean;
-    providers: boolean;
-  };
-  createdBy: string[];
-}
-
-export type CategoryCounts = Record<CategoryKey, number>;

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/BlockMenuSearch/BlockMenuSearch.tsx

@@ -1,14 +1,111 @@
 import { Text } from "@/components/atoms/Text/Text";
+import { useBlockMenuSearch } from "./useBlockMenuSearch";
+import { InfiniteScroll } from "@/components/contextual/InfiniteScroll/InfiniteScroll";
+import { LoadingSpinner } from "@/components/__legacy__/ui/loading";
+import { SearchResponseItemsItem } from "@/app/api/__generated__/models/searchResponseItemsItem";
+import { MarketplaceAgentBlock } from "../MarketplaceAgentBlock";
+import { Block } from "../Block";
+import { UGCAgentBlock } from "../UGCAgentBlock";
+import { getSearchItemType } from "./helper";
+import { useBlockMenuStore } from "../../../../stores/blockMenuStore";
 import { blockMenuContainerStyle } from "../style";
-import { BlockMenuFilters } from "../BlockMenuFilters/BlockMenuFilters";
-import { BlockMenuSearchContent } from "../BlockMenuSearchContent/BlockMenuSearchContent";
+import { cn } from "@/lib/utils";
+import { NoSearchResult } from "../NoSearchResult";
 
 export const BlockMenuSearch = () => {
+  const {
+    searchResults,
+    isFetchingNextPage,
+    fetchNextPage,
+    hasNextPage,
+    searchLoading,
+    handleAddLibraryAgent,
+    handleAddMarketplaceAgent,
+    addingLibraryAgentId,
+    addingMarketplaceAgentSlug,
+  } = useBlockMenuSearch();
+  const { searchQuery } = useBlockMenuStore();
+
+  if (searchLoading) {
+    return (
+      <div
+        className={cn(
+          blockMenuContainerStyle,
+          "flex items-center justify-center",
+        )}
+      >
+        <LoadingSpinner className="size-13" />
+      </div>
+    );
+  }
+
+  if (searchResults.length === 0) {
+    return <NoSearchResult />;
+  }
+
   return (
     <div className={blockMenuContainerStyle}>
-      <BlockMenuFilters />
       <Text variant="body-medium">Search results</Text>
-      <BlockMenuSearchContent />
+      <InfiniteScroll
+        isFetchingNextPage={isFetchingNextPage}
+        fetchNextPage={fetchNextPage}
+        hasNextPage={hasNextPage}
+        loader={<LoadingSpinner className="size-13" />}
+        className="space-y-2.5"
+      >
+        {searchResults.map((item: SearchResponseItemsItem, index: number) => {
+          const { type, data } = getSearchItemType(item);
+          // backend give support to these 3 types only [right now] - we need to give support to integration and ai agent types in follow up PRs
+          switch (type) {
+            case "store_agent":
+              return (
+                <MarketplaceAgentBlock
+                  key={index}
+                  slug={data.slug}
+                  highlightedText={searchQuery}
+                  title={data.agent_name}
+                  image_url={data.agent_image}
+                  creator_name={data.creator}
+                  number_of_runs={data.runs}
+                  loading={addingMarketplaceAgentSlug === data.slug}
+                  onClick={() =>
+                    handleAddMarketplaceAgent({
+                      creator_name: data.creator,
+                      slug: data.slug,
+                    })
+                  }
+                />
+              );
+            case "block":
+              return (
+                <Block
+                  key={index}
+                  title={data.name}
+                  highlightedText={searchQuery}
+                  description={data.description}
+                  blockData={data}
+                />
+              );
+
+            case "library_agent":
+              return (
+                <UGCAgentBlock
+                  key={index}
+                  title={data.name}
+                  highlightedText={searchQuery}
+                  image_url={data.image_url}
+                  version={data.graph_version}
+                  edited_time={data.updated_at}
+                  isLoading={addingLibraryAgentId === data.id}
+                  onClick={() => handleAddLibraryAgent(data)}
+                />
+              );
+
+            default:
+              return null;
+          }
+        })}
+      </InfiniteScroll>
     </div>
   );
 };

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/BlockMenuSearch/useBlockMenuSearch.ts

@@ -23,19 +23,9 @@ import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { getQueryClient } from "@/lib/react-query/queryClient";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import * as Sentry from "@sentry/nextjs";
-import { GetV2BuilderSearchFilterAnyOfItem } from "@/app/api/__generated__/models/getV2BuilderSearchFilterAnyOfItem";
-
-export const useBlockMenuSearchContent = () => {
-  const {
-    searchQuery,
-    searchId,
-    setSearchId,
-    filters,
-    setCreatorsList,
-    creators,
-    setCategoryCounts,
-  } = useBlockMenuStore();
 
+export const useBlockMenuSearch = () => {
+  const { searchQuery, searchId, setSearchId } = useBlockMenuStore();
   const { toast } = useToast();
   const { addAgentToBuilder, addLibraryAgentToBuilder } =
     useAddAgentToBuilder();
@@ -67,8 +57,6 @@ export const useBlockMenuSearchContent = () => {
       page_size: 8,
       search_query: searchQuery,
       search_id: searchId,
-      filter: filters.length > 0 ? filters : undefined,
-      by_creator: creators.length > 0 ? creators : undefined,
     },
     {
       query: { getNextPageParam: getPaginationNextPageNumber },
@@ -110,26 +98,6 @@ export const useBlockMenuSearchContent = () => {
     }
   }, [searchQueryData, searchId, setSearchId]);
 
-  // from all the results, we need to get all the unique creators
-  useEffect(() => {
-    if (!searchQueryData?.pages?.length) {
-      return;
-    }
-    const latestData = okData(searchQueryData.pages.at(-1));
-    setCategoryCounts(
-      (latestData?.total_items as Record<
-        GetV2BuilderSearchFilterAnyOfItem,
-        number
-      >) || {
-        blocks: 0,
-        integrations: 0,
-        marketplace_agents: 0,
-        my_agents: 0,
-      },
-    );
-    setCreatorsList(latestData?.items || []);
-  }, [searchQueryData]);
-
   useEffect(() => {
     if (searchId && !searchQuery) {
       resetSearchSession();

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/BlockMenuSearchContent/BlockMenuSearchContent.tsx

@@ -1,108 +0,0 @@
-import { SearchResponseItemsItem } from "@/app/api/__generated__/models/searchResponseItemsItem";
-import { LoadingSpinner } from "@/components/atoms/LoadingSpinner/LoadingSpinner";
-import { InfiniteScroll } from "@/components/contextual/InfiniteScroll/InfiniteScroll";
-import { getSearchItemType } from "./helper";
-import { MarketplaceAgentBlock } from "../MarketplaceAgentBlock";
-import { Block } from "../Block";
-import { UGCAgentBlock } from "../UGCAgentBlock";
-import { useBlockMenuSearchContent } from "./useBlockMenuSearchContent";
-import { useBlockMenuStore } from "@/app/(platform)/build/stores/blockMenuStore";
-import { cn } from "@/lib/utils";
-import { blockMenuContainerStyle } from "../style";
-import { NoSearchResult } from "../NoSearchResult";
-
-export const BlockMenuSearchContent = () => {
-  const {
-    searchResults,
-    isFetchingNextPage,
-    fetchNextPage,
-    hasNextPage,
-    searchLoading,
-    handleAddLibraryAgent,
-    handleAddMarketplaceAgent,
-    addingLibraryAgentId,
-    addingMarketplaceAgentSlug,
-  } = useBlockMenuSearchContent();
-
-  const { searchQuery } = useBlockMenuStore();
-
-  if (searchLoading) {
-    return (
-      <div
-        className={cn(
-          blockMenuContainerStyle,
-          "flex items-center justify-center",
-        )}
-      >
-        <LoadingSpinner className="size-13" />
-      </div>
-    );
-  }
-
-  if (searchResults.length === 0) {
-    return <NoSearchResult />;
-  }
-
-  return (
-    <InfiniteScroll
-      isFetchingNextPage={isFetchingNextPage}
-      fetchNextPage={fetchNextPage}
-      hasNextPage={hasNextPage}
-      loader={<LoadingSpinner className="size-13" />}
-      className="space-y-2.5"
-    >
-      {searchResults.map((item: SearchResponseItemsItem, index: number) => {
-        const { type, data } = getSearchItemType(item);
-        // backend give support to these 3 types only [right now] - we need to give support to integration and ai agent types in follow up PRs
-        switch (type) {
-          case "store_agent":
-            return (
-              <MarketplaceAgentBlock
-                key={index}
-                slug={data.slug}
-                highlightedText={searchQuery}
-                title={data.agent_name}
-                image_url={data.agent_image}
-                creator_name={data.creator}
-                number_of_runs={data.runs}
-                loading={addingMarketplaceAgentSlug === data.slug}
-                onClick={() =>
-                  handleAddMarketplaceAgent({
-                    creator_name: data.creator,
-                    slug: data.slug,
-                  })
-                }
-              />
-            );
-          case "block":
-            return (
-              <Block
-                key={index}
-                title={data.name}
-                highlightedText={searchQuery}
-                description={data.description}
-                blockData={data}
-              />
-            );
-
-          case "library_agent":
-            return (
-              <UGCAgentBlock
-                key={index}
-                title={data.name}
-                highlightedText={searchQuery}
-                image_url={data.image_url}
-                version={data.graph_version}
-                edited_time={data.updated_at}
-                isLoading={addingLibraryAgentId === data.id}
-                onClick={() => handleAddLibraryAgent(data)}
-              />
-            );
-
-          default:
-            return null;
-        }
-      })}
-    </InfiniteScroll>
-  );
-};

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/FilterChip.tsx

@@ -1,9 +1,7 @@
 import { Button } from "@/components/__legacy__/ui/button";
 import { cn } from "@/lib/utils";
-import { XIcon } from "@phosphor-icons/react";
-import { AnimatePresence, motion } from "framer-motion";
-
-import React, { ButtonHTMLAttributes, useState } from "react";
+import { X } from "lucide-react";
+import React, { ButtonHTMLAttributes } from "react";
 
 interface Props extends ButtonHTMLAttributes<HTMLButtonElement> {
   selected?: boolean;
@@ -18,51 +16,39 @@ export const FilterChip: React.FC<Props> = ({
   className,
   ...rest
 }) => {
-  const [isHovered, setIsHovered] = useState(false);
   return (
-    <AnimatePresence mode="wait">
-      <Button
-        onMouseEnter={() => setIsHovered(true)}
-        onMouseLeave={() => setIsHovered(false)}
+    <Button
+      className={cn(
+        "group w-fit space-x-1 rounded-[1.5rem] border border-zinc-300 bg-transparent px-[0.625rem] py-[0.375rem] shadow-none transition-transform duration-300 ease-in-out",
+        "hover:border-violet-500 hover:bg-transparent focus:ring-0 disabled:cursor-not-allowed",
+        selected && "border-0 bg-violet-700 hover:border",
+        className,
+      )}
+      {...rest}
+    >
+      <span
         className={cn(
-          "group w-fit space-x-1 rounded-[1.5rem] border border-zinc-300 bg-transparent px-[0.625rem] py-[0.375rem] shadow-none",
-          "hover:border-violet-500 hover:bg-transparent focus:ring-0 disabled:cursor-not-allowed",
-          selected && "border-0 bg-violet-700 hover:border",
-          className,
+          "font-sans text-sm font-medium leading-[1.375rem] text-zinc-600 group-hover:text-zinc-600 group-disabled:text-zinc-400",
+          selected && "text-zinc-50",
         )}
-        {...rest}
       >
-        <span
-          className={cn(
-            "font-sans text-sm font-medium leading-[1.375rem] text-zinc-600 group-hover:text-zinc-600 group-disabled:text-zinc-400",
-            selected && "text-zinc-50",
+        {name}
+      </span>
+      {selected && (
+        <>
+          <span className="flex h-4 w-4 items-center justify-center rounded-full bg-zinc-50 transition-all duration-300 ease-in-out group-hover:hidden">
+            <X
+              className="h-3 w-3 rounded-full text-violet-700"
+              strokeWidth={2}
+            />
+          </span>
+          {number !== undefined && (
+            <span className="hidden h-[1.375rem] items-center rounded-[1.25rem] bg-violet-700 p-[0.375rem] text-zinc-50 transition-all duration-300 ease-in-out animate-in fade-in zoom-in group-hover:flex">
+              {number > 100 ? "100+" : number}
+            </span>
           )}
-        >
-          {name}
-        </span>
-        {selected && !isHovered && (
-          <motion.span
-            initial={{ opacity: 0.5, scale: 0.5, filter: "blur(20px)" }}
-            animate={{ opacity: 1, scale: 1, filter: "blur(0px)" }}
-            exit={{ opacity: 0.5, scale: 0.5, filter: "blur(20px)" }}
-            transition={{ duration: 0.3, type: "spring", bounce: 0.2 }}
-            className="flex h-4 w-4 items-center justify-center rounded-full bg-zinc-50"
-          >
-            <XIcon size={12} weight="bold" className="text-violet-700" />
-          </motion.span>
-        )}
-        {number !== undefined && isHovered && (
-          <motion.span
-            initial={{ opacity: 0.5, scale: 0.5, filter: "blur(10px)" }}
-            animate={{ opacity: 1, scale: 1, filter: "blur(0px)" }}
-            exit={{ opacity: 0.5, scale: 0.5, filter: "blur(10px)" }}
-            transition={{ duration: 0.3, type: "spring", bounce: 0.2 }}
-            className="flex h-[1.375rem] items-center rounded-[1.25rem] bg-violet-700 p-[0.375rem] text-zinc-50"
-          >
-            {number > 100 ? "100+" : number}
-          </motion.span>
-        )}
-      </Button>
-    </AnimatePresence>
+        </>
+      )}
+    </Button>
   );
 };

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/FilterSheet/FilterSheet.tsx

@@ -1,156 +0,0 @@
-import { FilterChip } from "../FilterChip";
-import { cn } from "@/lib/utils";
-import { CategoryKey } from "../BlockMenuFilters/types";
-import { AnimatePresence, motion } from "framer-motion";
-import { XIcon } from "@phosphor-icons/react";
-import { Button } from "@/components/atoms/Button/Button";
-import { Text } from "@/components/atoms/Text/Text";
-import { Separator } from "@/components/__legacy__/ui/separator";
-import { Checkbox } from "@/components/__legacy__/ui/checkbox";
-import { useFilterSheet } from "./useFilterSheet";
-import { INITIAL_CREATORS_TO_SHOW } from "./constant";
-
-export function FilterSheet({
-  categories,
-}: {
-  categories: Array<{ key: CategoryKey; name: string }>;
-}) {
-  const {
-    isOpen,
-    localCategories,
-    localCreators,
-    displayedCreatorsCount,
-    handleLocalCategoryChange,
-    handleToggleShowMoreCreators,
-    handleLocalCreatorChange,
-    handleClearFilters,
-    handleCloseButton,
-    handleApplyFilters,
-    hasLocalActiveFilters,
-    visibleCreators,
-    creators,
-    handleOpenFilters,
-    hasActiveFilters,
-  } = useFilterSheet();
-
-  return (
-    <div className="m-0 inline w-fit p-0">
-      <FilterChip
-        name={hasActiveFilters() ? "Edit filters" : "All filters"}
-        onClick={handleOpenFilters}
-      />
-
-      <AnimatePresence>
-        {isOpen && (
-          <motion.div
-            className={cn(
-              "absolute bottom-2 left-2 top-2 z-20 w-3/4 max-w-[22.5rem] space-y-4 overflow-hidden rounded-[0.75rem] bg-white pb-4 shadow-[0_4px_12px_2px_rgba(0,0,0,0.1)]",
-            )}
-            initial={{ x: "-100%", filter: "blur(10px)" }}
-            animate={{ x: 0, filter: "blur(0px)" }}
-            exit={{ x: "-110%", filter: "blur(10px)" }}
-            transition={{ duration: 0.4, type: "spring", bounce: 0.2 }}
-          >
-            {/* Top section */}
-            <div className="flex items-center justify-between px-5 pt-4">
-              <Text variant="body">Filters</Text>
-              <Button
-                className="p-0"
-                variant="ghost"
-                size="icon"
-                onClick={handleCloseButton}
-              >
-                <XIcon size={20} />
-              </Button>
-            </div>
-
-            <Separator className="h-[1px] w-full text-zinc-300" />
-
-            {/* Category section */}
-            <div className="space-y-4 px-5">
-              <Text variant="large">Categories</Text>
-              <div className="space-y-2">
-                {categories.map((category) => (
-                  <div
-                    key={category.key}
-                    className="flex items-center space-x-2"
-                  >
-                    <Checkbox
-                      id={category.key}
-                      checked={localCategories.includes(category.key)}
-                      onCheckedChange={() =>
-                        handleLocalCategoryChange(category.key)
-                      }
-                      className="border border-[#D4D4D4] shadow-none data-[state=checked]:border-none data-[state=checked]:bg-violet-700 data-[state=checked]:text-white"
-                    />
-                    <label
-                      htmlFor={category.key}
-                      className="font-sans text-sm leading-[1.375rem] text-zinc-600"
-                    >
-                      {category.name}
-                    </label>
-                  </div>
-                ))}
-              </div>
-            </div>
-
-            {/* Created by section */}
-            <div className="space-y-4 px-5">
-              <p className="font-sans text-base font-medium text-zinc-800">
-                Created by
-              </p>
-              <div className="space-y-2">
-                {visibleCreators.map((creator, i) => (
-                  <div key={i} className="flex items-center space-x-2">
-                    <Checkbox
-                      id={`creator-${creator}`}
-                      checked={localCreators.includes(creator)}
-                      onCheckedChange={() => handleLocalCreatorChange(creator)}
-                      className="border border-[#D4D4D4] shadow-none data-[state=checked]:border-none data-[state=checked]:bg-violet-700 data-[state=checked]:text-white"
-                    />
-                    <label
-                      htmlFor={`creator-${creator}`}
-                      className="font-sans text-sm leading-[1.375rem] text-zinc-600"
-                    >
-                      {creator}
-                    </label>
-                  </div>
-                ))}
-              </div>
-              {creators.length > INITIAL_CREATORS_TO_SHOW && (
-                <Button
-                  variant={"link"}
-                  className="m-0 p-0 font-sans text-sm font-medium leading-[1.375rem] text-zinc-800 underline hover:text-zinc-600"
-                  onClick={handleToggleShowMoreCreators}
-                >
-                  {displayedCreatorsCount < creators.length ? "More" : "Less"}
-                </Button>
-              )}
-            </div>
-
-            {/* Footer section */}
-            <div className="fixed bottom-0 flex w-full justify-between gap-3 border-t border-zinc-200 bg-white px-5 py-3">
-              <Button
-                size="small"
-                variant={"outline"}
-                onClick={handleClearFilters}
-                className="rounded-[8px] px-2 py-1.5"
-              >
-                Clear
-              </Button>
-
-              <Button
-                size="small"
-                onClick={handleApplyFilters}
-                disabled={!hasLocalActiveFilters()}
-                className="rounded-[8px] px-2 py-1.5"
-              >
-                Apply filters
-              </Button>
-            </div>
-          </motion.div>
-        )}
-      </AnimatePresence>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/FilterSheet/constant.ts

@@ -1 +0,0 @@
-export const INITIAL_CREATORS_TO_SHOW = 5;

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/FilterSheet/useFilterSheet.ts

@@ -1,100 +0,0 @@
-import { useBlockMenuStore } from "@/app/(platform)/build/stores/blockMenuStore";
-import { useState } from "react";
-import { INITIAL_CREATORS_TO_SHOW } from "./constant";
-import { GetV2BuilderSearchFilterAnyOfItem } from "@/app/api/__generated__/models/getV2BuilderSearchFilterAnyOfItem";
-
-export const useFilterSheet = () => {
-  const { filters, creators_list, creators, setFilters, setCreators } =
-    useBlockMenuStore();
-
-  const [isOpen, setIsOpen] = useState(false);
-  const [localCategories, setLocalCategories] =
-    useState<GetV2BuilderSearchFilterAnyOfItem[]>(filters);
-  const [localCreators, setLocalCreators] = useState<string[]>(creators);
-  const [displayedCreatorsCount, setDisplayedCreatorsCount] = useState(
-    INITIAL_CREATORS_TO_SHOW,
-  );
-
-  const handleLocalCategoryChange = (
-    category: GetV2BuilderSearchFilterAnyOfItem,
-  ) => {
-    setLocalCategories((prev) => {
-      if (prev.includes(category)) {
-        return prev.filter((c) => c !== category);
-      }
-      return [...prev, category];
-    });
-  };
-
-  const hasActiveFilters = () => {
-    return filters.length > 0 || creators.length > 0;
-  };
-
-  const handleToggleShowMoreCreators = () => {
-    if (displayedCreatorsCount < creators.length) {
-      setDisplayedCreatorsCount(creators.length);
-    } else {
-      setDisplayedCreatorsCount(INITIAL_CREATORS_TO_SHOW);
-    }
-  };
-
-  const handleLocalCreatorChange = (creator: string) => {
-    setLocalCreators((prev) => {
-      if (prev.includes(creator)) {
-        return prev.filter((c) => c !== creator);
-      }
-      return [...prev, creator];
-    });
-  };
-
-  const handleClearFilters = () => {
-    setLocalCategories([]);
-    setLocalCreators([]);
-    setDisplayedCreatorsCount(INITIAL_CREATORS_TO_SHOW);
-  };
-
-  const handleCloseButton = () => {
-    setIsOpen(false);
-    setLocalCategories(filters);
-    setLocalCreators(creators);
-    setDisplayedCreatorsCount(INITIAL_CREATORS_TO_SHOW);
-  };
-
-  const handleApplyFilters = () => {
-    setFilters(localCategories);
-    setCreators(localCreators);
-    setIsOpen(false);
-  };
-
-  const handleOpenFilters = () => {
-    setIsOpen(true);
-    setLocalCategories(filters);
-    setLocalCreators(creators);
-  };
-
-  const hasLocalActiveFilters = () => {
-    return localCategories.length > 0 || localCreators.length > 0;
-  };
-
-  const visibleCreators = creators_list.slice(0, displayedCreatorsCount);
-
-  return {
-    creators,
-    isOpen,
-    setIsOpen,
-    localCategories,
-    localCreators,
-    displayedCreatorsCount,
-    setDisplayedCreatorsCount,
-    handleLocalCategoryChange,
-    handleToggleShowMoreCreators,
-    handleLocalCreatorChange,
-    handleClearFilters,
-    handleCloseButton,
-    handleOpenFilters,
-    handleApplyFilters,
-    hasLocalActiveFilters,
-    visibleCreators,
-    hasActiveFilters,
-  };
-};

autogpt_platform/frontend/src/app/(platform)/build/stores/blockMenuStore.ts

@@ -1,30 +1,12 @@
 import { create } from "zustand";
 import { DefaultStateType } from "../components/NewControlPanel/NewBlockMenu/types";
-import { SearchResponseItemsItem } from "@/app/api/__generated__/models/searchResponseItemsItem";
-import { getSearchItemType } from "../components/NewControlPanel/NewBlockMenu/BlockMenuSearchContent/helper";
-import { StoreAgent } from "@/app/api/__generated__/models/storeAgent";
-import { GetV2BuilderSearchFilterAnyOfItem } from "@/app/api/__generated__/models/getV2BuilderSearchFilterAnyOfItem";
 
 type BlockMenuStore = {
   searchQuery: string;
   searchId: string | undefined;
   defaultState: DefaultStateType;
   integration: string | undefined;
-  filters: GetV2BuilderSearchFilterAnyOfItem[];
-  creators: string[];
-  creators_list: string[];
-  categoryCounts: Record<GetV2BuilderSearchFilterAnyOfItem, number>;
 
-  setCategoryCounts: (
-    counts: Record<GetV2BuilderSearchFilterAnyOfItem, number>,
-  ) => void;
-  setCreatorsList: (searchData: SearchResponseItemsItem[]) => void;
-  addCreator: (creator: string) => void;
-  setCreators: (creators: string[]) => void;
-  removeCreator: (creator: string) => void;
-  addFilter: (filter: GetV2BuilderSearchFilterAnyOfItem) => void;
-  setFilters: (filters: GetV2BuilderSearchFilterAnyOfItem[]) => void;
-  removeFilter: (filter: GetV2BuilderSearchFilterAnyOfItem) => void;
   setSearchQuery: (query: string) => void;
   setSearchId: (id: string | undefined) => void;
   setDefaultState: (state: DefaultStateType) => void;
@@ -37,44 +19,11 @@ export const useBlockMenuStore = create<BlockMenuStore>((set) => ({
   searchId: undefined,
   defaultState: DefaultStateType.SUGGESTION,
   integration: undefined,
-  filters: [],
-  creators: [], // creator filters that are applied to the search results
-  creators_list: [], // all creators that are available to filter by
-  categoryCounts: {
-    blocks: 0,
-    integrations: 0,
-    marketplace_agents: 0,
-    my_agents: 0,
-  },
 
-  setCategoryCounts: (counts) => set({ categoryCounts: counts }),
-  setCreatorsList: (searchData) => {
-    const marketplaceAgents = searchData.filter((item) => {
-      return getSearchItemType(item).type === "store_agent";
-    }) as StoreAgent[];
-
-    const newCreators = marketplaceAgents.map((agent) => agent.creator);
-
-    set((state) => ({
-      creators_list: Array.from(
-        new Set([...state.creators_list, ...newCreators]),
-      ),
-    }));
-  },
-  setCreators: (creators) => set({ creators }),
-  setFilters: (filters) => set({ filters }),
   setSearchQuery: (query) => set({ searchQuery: query }),
   setSearchId: (id) => set({ searchId: id }),
   setDefaultState: (state) => set({ defaultState: state }),
   setIntegration: (integration) => set({ integration }),
-  addFilter: (filter) =>
-    set((state) => ({ filters: [...state.filters, filter] })),
-  removeFilter: (filter) =>
-    set((state) => ({ filters: state.filters.filter((f) => f !== filter) })),
-  addCreator: (creator) =>
-    set((state) => ({ creators: [...state.creators, creator] })),
-  removeCreator: (creator) =>
-    set((state) => ({ creators: state.creators.filter((c) => c !== creator) })),
   reset: () =>
     set({
       searchQuery: "",

autogpt_platform/frontend/src/app/(platform)/build/stores/nodeStore.ts

@@ -68,9 +68,6 @@ type NodeStore = {
   clearAllNodeErrors: () => void; // Add this
 
   syncHardcodedValuesWithHandleIds: (nodeId: string) => void;
-
-  // Credentials optional helpers
-  setCredentialsOptional: (nodeId: string, optional: boolean) => void;
 };
 
 export const useNodeStore = create<NodeStore>((set, get) => ({
@@ -229,9 +226,6 @@ export const useNodeStore = create<NodeStore>((set, get) => ({
         ...(node.data.metadata?.customized_name !== undefined && {
           customized_name: node.data.metadata.customized_name,
         }),
-        ...(node.data.metadata?.credentials_optional !== undefined && {
-          credentials_optional: node.data.metadata.credentials_optional,
-        }),
       },
     };
   },
@@ -348,30 +342,4 @@ export const useNodeStore = create<NodeStore>((set, get) => ({
       }));
     }
   },
-
-  setCredentialsOptional: (nodeId: string, optional: boolean) => {
-    set((state) => ({
-      nodes: state.nodes.map((n) =>
-        n.id === nodeId
-          ? {
-              ...n,
-              data: {
-                ...n.data,
-                metadata: {
-                  ...n.data.metadata,
-                  credentials_optional: optional,
-                },
-              },
-            }
-          : n,
-      ),
-    }));
-
-    const newState = {
-      nodes: get().nodes,
-      edges: useEdgeStore.getState().edges,
-    };
-
-    useHistoryStore.getState().pushState(newState);
-  },
 }));

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs.tsx

@@ -34,9 +34,7 @@ type Props = {
   onSelectCredentials: (newValue?: CredentialsMetaInput) => void;
   onLoaded?: (loaded: boolean) => void;
   readOnly?: boolean;
-  isOptional?: boolean;
   showTitle?: boolean;
-  variant?: "default" | "node";
 };
 
 export function CredentialsInput({
@@ -47,9 +45,7 @@ export function CredentialsInput({
   siblingInputs,
   onLoaded,
   readOnly = false,
-  isOptional = false,
   showTitle = true,
-  variant = "default",
 }: Props) {
   const hookData = useCredentialsInput({
     schema,
@@ -58,7 +54,6 @@ export function CredentialsInput({
     siblingInputs,
     onLoaded,
     readOnly,
-    isOptional,
   });
 
   if (!isLoaded(hookData)) {
@@ -99,14 +94,7 @@ export function CredentialsInput({
     <div className={cn("mb-6", className)}>
       {showTitle && (
         <div className="mb-2 flex items-center gap-2">
-          <Text variant="large-medium">
-            {displayName} credentials
-            {isOptional && (
-              <span className="ml-1 text-sm font-normal text-gray-500">
-                (optional)
-              </span>
-            )}
-          </Text>
+          <Text variant="large-medium">{displayName} credentials</Text>
           {schema.description && (
             <InformationTooltip description={schema.description} />
           )}
@@ -115,17 +103,14 @@ export function CredentialsInput({
 
       {hasCredentialsToShow ? (
         <>
-          {(credentialsToShow.length > 1 || isOptional) && !readOnly ? (
+          {credentialsToShow.length > 1 && !readOnly ? (
             <CredentialsSelect
               credentials={credentialsToShow}
               provider={provider}
               displayName={displayName}
               selectedCredentials={selectedCredential}
               onSelectCredential={handleCredentialSelect}
-              onClearCredential={() => onSelectCredential(undefined)}
               readOnly={readOnly}
-              allowNone={isOptional}
-              variant={variant}
             />
           ) : (
             <div className="mb-4 space-y-2">

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/components/CredentialRow/CredentialRow.tsx

@@ -30,8 +30,6 @@ type CredentialRowProps = {
   readOnly?: boolean;
   showCaret?: boolean;
   asSelectTrigger?: boolean;
-  /** When "node", applies compact styling for node context */
-  variant?: "default" | "node";
 };
 
 export function CredentialRow({
@@ -43,22 +41,14 @@ export function CredentialRow({
   readOnly = false,
   showCaret = false,
   asSelectTrigger = false,
-  variant = "default",
 }: CredentialRowProps) {
   const ProviderIcon = providerIcons[provider] || fallbackIcon;
-  const isNodeVariant = variant === "node";
 
   return (
     <div
       className={cn(
         "flex items-center gap-3 rounded-medium border border-zinc-200 bg-white p-3 transition-colors",
-        asSelectTrigger && isNodeVariant
-          ? "min-w-0 flex-1 overflow-hidden border-0 bg-transparent"
-          : asSelectTrigger
-            ? "border-0 bg-transparent"
-            : readOnly
-              ? "w-fit"
-              : "",
+        asSelectTrigger ? "border-0 bg-transparent" : readOnly ? "w-fit" : "",
       )}
       onClick={readOnly || showCaret || asSelectTrigger ? undefined : onSelect}
       style={
@@ -71,31 +61,19 @@ export function CredentialRow({
         <ProviderIcon className="h-3 w-3 text-white" />
       </div>
       <IconKey className="h-5 w-5 shrink-0 text-zinc-800" />
-      <div
-        className={cn(
-          "flex min-w-0 flex-1 flex-nowrap items-center gap-4",
-          isNodeVariant && "overflow-hidden",
-        )}
-      >
+      <div className="flex min-w-0 flex-1 flex-nowrap items-center gap-4">
         <Text
           variant="body"
-          className={cn(
-            "tracking-tight",
-            isNodeVariant
-              ? "truncate"
-              : "line-clamp-1 flex-[0_0_50%] text-ellipsis",
-          )}
+          className="line-clamp-1 flex-[0_0_50%] text-ellipsis tracking-tight"
         >
           {getCredentialDisplayName(credential, displayName)}
         </Text>
-        {!(asSelectTrigger && isNodeVariant) && (
-          <Text
-            variant="large"
-            className="relative top-1 hidden overflow-hidden whitespace-nowrap font-mono tracking-tight md:block"
-          >
-            {"*".repeat(MASKED_KEY_LENGTH)}
-          </Text>
-        )}
+        <Text
+          variant="large"
+          className="lex-[0_0_40%] relative top-1 hidden overflow-hidden whitespace-nowrap font-mono tracking-tight md:block"
+        >
+          {"*".repeat(MASKED_KEY_LENGTH)}
+        </Text>
       </div>
       {showCaret && !asSelectTrigger && (
         <CaretDown className="h-4 w-4 shrink-0 text-gray-400" />

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/components/CredentialsSelect/CredentialsSelect.tsx

@@ -7,7 +7,6 @@ import {
 } from "@/components/__legacy__/ui/select";
 import { Text } from "@/components/atoms/Text/Text";
 import { CredentialsMetaInput } from "@/lib/autogpt-server-api/types";
-import { cn } from "@/lib/utils";
 import { useEffect } from "react";
 import { getCredentialDisplayName } from "../../helpers";
 import { CredentialRow } from "../CredentialRow/CredentialRow";
@@ -24,11 +23,7 @@ interface Props {
   displayName: string;
   selectedCredentials?: CredentialsMetaInput;
   onSelectCredential: (credentialId: string) => void;
-  onClearCredential?: () => void;
   readOnly?: boolean;
-  allowNone?: boolean;
-  /** When "node", applies compact styling for node context */
-  variant?: "default" | "node";
 }
 
 export function CredentialsSelect({
@@ -37,38 +32,22 @@ export function CredentialsSelect({
   displayName,
   selectedCredentials,
   onSelectCredential,
-  onClearCredential,
   readOnly = false,
-  allowNone = true,
-  variant = "default",
 }: Props) {
-  // Auto-select first credential if none is selected (only if allowNone is false)
+  // Auto-select first credential if none is selected
   useEffect(() => {
-    if (!allowNone && !selectedCredentials && credentials.length > 0) {
+    if (!selectedCredentials && credentials.length > 0) {
       onSelectCredential(credentials[0].id);
     }
-  }, [allowNone, selectedCredentials, credentials, onSelectCredential]);
-
-  const handleValueChange = (value: string) => {
-    if (value === "__none__") {
-      onClearCredential?.();
-    } else {
-      onSelectCredential(value);
-    }
-  };
+  }, [selectedCredentials, credentials, onSelectCredential]);
 
   return (
     <div className="mb-4 w-full">
       <Select
-        value={selectedCredentials?.id || (allowNone ? "__none__" : "")}
-        onValueChange={handleValueChange}
+        value={selectedCredentials?.id || ""}
+        onValueChange={(value) => onSelectCredential(value)}
       >
-        <SelectTrigger
-          className={cn(
-            "h-auto min-h-12 w-full rounded-medium border-zinc-200 p-0 pr-4 shadow-none",
-            variant === "node" && "overflow-hidden",
-          )}
-        >
+        <SelectTrigger className="h-auto min-h-12 w-full rounded-medium border-zinc-200 p-0 pr-4 shadow-none">
           {selectedCredentials ? (
             <SelectValue key={selectedCredentials.id} asChild>
               <CredentialRow
@@ -84,7 +63,6 @@ export function CredentialsSelect({
                 onDelete={() => {}}
                 readOnly={readOnly}
                 asSelectTrigger={true}
-                variant={variant}
               />
             </SelectValue>
           ) : (
@@ -92,15 +70,6 @@ export function CredentialsSelect({
           )}
         </SelectTrigger>
         <SelectContent>
-          {allowNone && (
-            <SelectItem key="__none__" value="__none__">
-              <div className="flex items-center gap-2">
-                <Text variant="body" className="tracking-tight text-gray-500">
-                  None (skip this credential)
-                </Text>
-              </div>
-            </SelectItem>
-          )}
           {credentials.map((credential) => (
             <SelectItem key={credential.id} value={credential.id}>
               <div className="flex items-center gap-2">

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/useCredentialsInput.ts

@@ -22,7 +22,6 @@ type Params = {
   siblingInputs?: Record<string, any>;
   onLoaded?: (loaded: boolean) => void;
   readOnly?: boolean;
-  isOptional?: boolean;
 };
 
 export function useCredentialsInput({
@@ -32,7 +31,6 @@ export function useCredentialsInput({
   siblingInputs,
   onLoaded,
   readOnly = false,
-  isOptional = false,
 }: Params) {
   const [isAPICredentialsModalOpen, setAPICredentialsModalOpen] =
     useState(false);
@@ -101,20 +99,13 @@ export function useCredentialsInput({
       : null;
   }, [credentials]);
 
-  // Auto-select the one available credential (only if not optional)
+  // Auto-select the one available credential
   useEffect(() => {
     if (readOnly) return;
-    if (isOptional) return; // Don't auto-select when credential is optional
     if (singleCredential && !selectedCredential) {
       onSelectCredential(singleCredential);
     }
-  }, [
-    singleCredential,
-    selectedCredential,
-    onSelectCredential,
-    readOnly,
-    isOptional,
-  ]);
+  }, [singleCredential, selectedCredential, onSelectCredential, readOnly]);
 
   if (
     !credentials ||

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/components/ModalRunSection/ModalRunSection.tsx

@@ -8,7 +8,6 @@ import { WebhookTriggerBanner } from "../WebhookTriggerBanner/WebhookTriggerBann
 
 export function ModalRunSection() {
   const {
-    agent,
     defaultRunType,
     presetName,
     setPresetName,
@@ -25,11 +24,6 @@ export function ModalRunSection() {
   const inputFields = Object.entries(agentInputFields || {});
   const credentialFields = Object.entries(agentCredentialsInputFields || {});
 
-  // Get the list of required credentials from the schema
-  const requiredCredentials = new Set(
-    (agent.credentials_input_schema?.required as string[]) || [],
-  );
-
   return (
     <div className="flex flex-col gap-4">
       {defaultRunType === "automatic-trigger" ||
@@ -105,12 +99,14 @@ export function ModalRunSection() {
                   schema={
                     { ...inputSubSchema, discriminator: undefined } as any
                   }
-                  selectedCredentials={inputCredentials?.[key]}
+                  selectedCredentials={
+                    (inputCredentials && inputCredentials[key]) ??
+                    inputSubSchema.default
+                  }
                   onSelectCredentials={(value) =>
                     setInputCredentialsValue(key, value)
                   }
                   siblingInputs={inputValues}
-                  isOptional={!requiredCredentials.has(key)}
                 />
               ),
             )}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/useAgentRunModal.tsx

@@ -163,21 +163,15 @@ export function useAgentRunModal(
   }, [agentInputSchema.required, inputValues]);
 
   const [allCredentialsAreSet, missingCredentials] = useMemo(() => {
-    // Only check required credentials from schema, not all properties
-    // Credentials marked as optional in node metadata won't be in the required array
-    const requiredCredentials = new Set(
-      (agent.credentials_input_schema?.required as string[]) || [],
+    const availableCredentials = new Set(Object.keys(inputCredentials));
+    const allCredentials = new Set(
+      Object.keys(agentCredentialsInputFields || {}) ?? [],
+    );
+    const missing = [...allCredentials].filter(
+      (key) => !availableCredentials.has(key),
     );
-
-    // Check if required credentials have valid id (not just key existence)
-    // A credential is valid only if it has an id field set
-    const missing = [...requiredCredentials].filter((key) => {
-      const cred = inputCredentials[key];
-      return !cred || !cred.id;
-    });
-
     return [missing.length === 0, missing];
-  }, [agent.credentials_input_schema, inputCredentials]);
+  }, [agentCredentialsInputFields, inputCredentials]);
 
   const credentialsRequired = useMemo(
     () => Object.keys(agentCredentialsInputFields || {}).length > 0,
@@ -245,18 +239,12 @@ export function useAgentRunModal(
       });
     } else {
       // Manual execution
-      // Filter out incomplete credentials (optional ones not selected)
-      // Only send credentials that have a valid id field
-      const validCredentials = Object.fromEntries(
-        Object.entries(inputCredentials).filter(([_, cred]) => cred && cred.id),
-      );
-
       executeGraphMutation.mutate({
         graphId: agent.graph_id,
         graphVersion: agent.graph_version,
         data: {
           inputs: inputValues,
-          credentials_inputs: validCredentials,
+          credentials_inputs: inputCredentials,
           source: "library",
         },
       });

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/other/EmptyTasks.tsx

@@ -1,25 +1,17 @@
 "use client";
 
 import { getV1GetGraphVersion } from "@/app/api/__generated__/endpoints/graphs/graphs";
-import {
-  getGetV2ListLibraryAgentsQueryKey,
-  useDeleteV2DeleteLibraryAgent,
-} from "@/app/api/__generated__/endpoints/library/library";
 import { GraphExecutionJobInfo } from "@/app/api/__generated__/models/graphExecutionJobInfo";
 import { GraphExecutionMeta } from "@/app/api/__generated__/models/graphExecutionMeta";
 import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { LibraryAgentPreset } from "@/app/api/__generated__/models/libraryAgentPreset";
 import { Button } from "@/components/atoms/Button/Button";
 import { Text } from "@/components/atoms/Text/Text";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { ShowMoreText } from "@/components/molecules/ShowMoreText/ShowMoreText";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { exportAsJSONFile } from "@/lib/utils";
 import { formatDate } from "@/lib/utils/time";
-import { useQueryClient } from "@tanstack/react-query";
 import Link from "next/link";
-import { useRouter } from "next/navigation";
-import { useState } from "react";
 import { RunAgentModal } from "../modals/RunAgentModal/RunAgentModal";
 import { RunDetailCard } from "../selected-views/RunDetailCard/RunDetailCard";
 import { EmptyTasksIllustration } from "./EmptyTasksIllustration";
@@ -38,41 +30,6 @@ export function EmptyTasks({
   onScheduleCreated,
 }: Props) {
   const { toast } = useToast();
-  const queryClient = useQueryClient();
-  const router = useRouter();
-  const [showDeleteDialog, setShowDeleteDialog] = useState(false);
-  const [isDeletingAgent, setIsDeletingAgent] = useState(false);
-
-  const { mutateAsync: deleteAgent } = useDeleteV2DeleteLibraryAgent();
-
-  async function handleDeleteAgent() {
-    if (!agent.id) return;
-
-    setIsDeletingAgent(true);
-
-    try {
-      await deleteAgent({ libraryAgentId: agent.id });
-
-      await queryClient.refetchQueries({
-        queryKey: getGetV2ListLibraryAgentsQueryKey(),
-      });
-
-      toast({ title: "Agent deleted" });
-      setShowDeleteDialog(false);
-      router.push("/library");
-    } catch (error: unknown) {
-      toast({
-        title: "Failed to delete agent",
-        description:
-          error instanceof Error
-            ? error.message
-            : "An unexpected error occurred.",
-        variant: "destructive",
-      });
-    } finally {
-      setIsDeletingAgent(false);
-    }
-  }
 
   async function handleExport() {
     try {
@@ -190,50 +147,9 @@ export function EmptyTasks({
             <Button variant="secondary" size="small" onClick={handleExport}>
               Export agent to file
             </Button>
-            <Button
-              variant="secondary"
-              size="small"
-              onClick={() => setShowDeleteDialog(true)}
-            >
-              Delete agent
-            </Button>
           </div>
         </div>
       </div>
-
-      <Dialog
-        controlled={{
-          isOpen: showDeleteDialog,
-          set: setShowDeleteDialog,
-        }}
-        styling={{ maxWidth: "32rem" }}
-        title="Delete agent"
-      >
-        <Dialog.Content>
-          <div>
-            <Text variant="large">
-              Are you sure you want to delete this agent? This action cannot be
-              undone.
-            </Text>
-            <Dialog.Footer>
-              <Button
-                variant="secondary"
-                disabled={isDeletingAgent}
-                onClick={() => setShowDeleteDialog(false)}
-              >
-                Cancel
-              </Button>
-              <Button
-                variant="destructive"
-                onClick={handleDeleteAgent}
-                loading={isDeletingAgent}
-              >
-                Delete Agent
-              </Button>
-            </Dialog.Footer>
-          </div>
-        </Dialog.Content>
-      </Dialog>
     </div>
   );
 }

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers/renderers/CodeRenderer.tsx

@@ -83,9 +83,7 @@ function renderCode(
         </div>
       )}
       <pre className="overflow-x-auto rounded-md bg-muted p-3">
-        <code className="whitespace-pre-wrap break-words font-mono text-sm">
-          {codeValue}
-        </code>
+        <code className="font-mono text-sm">{codeValue}</code>
       </pre>
     </div>
   );