port backend changes ontop of a fresh dev branch

.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

@@ -1,9 +1,6 @@
 # Ignore everything by default, selectively add things to context
 *
 
-# Documentation (for embeddings/search)
-!docs/
-
 # Platform - Libs
 !autogpt_platform/autogpt_libs/autogpt_libs/
 !autogpt_platform/autogpt_libs/pyproject.toml
@@ -19,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 }}

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

@@ -11,7 +11,6 @@ on:
       - ".github/workflows/platform-frontend-ci.yml"
       - "autogpt_platform/frontend/**"
   merge_group:
-  workflow_dispatch:
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event_name == 'merge_group' && format('merge-queue-{0}', github.ref) || format('{0}-{1}', github.ref, github.event.pull_request.number || github.sha) }}
@@ -152,14 +151,6 @@ jobs:
         run: |
           cp ../.env.default ../.env
 
-      - name: Copy backend .env and set OpenAI API key
-        run: |
-          cp ../backend/.env.default ../backend/.env
-          echo "OPENAI_INTERNAL_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> ../backend/.env
-        env:
-          # Used by E2E test data script to generate embeddings for approved store agents
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 
@@ -235,25 +226,13 @@ jobs:
 
       - name: Run Playwright tests
         run: pnpm test:no-build
-        continue-on-error: false
 
-      - name: Upload Playwright report
-        if: always()
+      - name: Upload Playwright artifacts
+        if: failure()
         uses: actions/upload-artifact@v4
         with:
           name: playwright-report
           path: playwright-report
-          if-no-files-found: ignore
-          retention-days: 3
-
-      - name: Upload Playwright test results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: playwright-test-results
-          path: test-results
-          if-no-files-found: ignore
-          retention-days: 3
 
       - name: Print Final Docker Compose logs
         if: always()

autogpt_platform/Makefile

@@ -11,9 +11,6 @@ stop-core:
 reset-db:
 	docker compose stop 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:
@@ -35,7 +32,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/.env.default

@@ -58,13 +58,6 @@ V0_API_KEY=
 OPEN_ROUTER_API_KEY=
 NVIDIA_API_KEY=
 
-# Langfuse Prompt Management
-# Used for managing the CoPilot system prompt externally
-# Get credentials from https://cloud.langfuse.com or your self-hosted instance
-LANGFUSE_PUBLIC_KEY=
-LANGFUSE_SECRET_KEY=
-LANGFUSE_HOST=https://cloud.langfuse.com
-
 # OAuth Credentials
 # For the OAuth callback URL, use <your_frontend_url>/auth/integrations/oauth_callback,
 # e.g. http://localhost:3000/auth/integrations/oauth_callback

autogpt_platform/backend/.gitignore

@@ -18,4 +18,3 @@ load-tests/results/
 load-tests/*.json
 load-tests/*.log
 load-tests/node_modules/*
-migrations/*/rollback*.sql

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
 
@@ -100,7 +99,6 @@ COPY autogpt_platform/backend/migrations /app/autogpt_platform/backend/migration
 FROM server_dependencies AS server
 
 COPY autogpt_platform/backend /app/autogpt_platform/backend
-COPY docs /app/docs
 RUN poetry install --no-ansi --only-root
 
 ENV PORT=8000

autogpt_platform/backend/backend/api/external/fastapi_app.py

@@ -1,57 +1,21 @@
-"""
-External API Application
-
-This module defines the main FastAPI application for the external API,
-which mounts the v1 and v2 sub-applications.
-"""
-
 from fastapi import FastAPI
-from fastapi.responses import RedirectResponse
 
+from backend.api.middleware.security import SecurityHeadersMiddleware
 from backend.monitoring.instrumentation import instrument_fastapi
 
-from .v1.app import v1_app
-from .v2.app import v2_app
-
-DESCRIPTION = """
-The external API provides programmatic access to the AutoGPT Platform for building
-integrations, automations, and custom applications.
-
-### API Versions
-
-| Version             | End of Life | Path                   | Documentation |
-|---------------------|-------------|------------------------|---------------|
-| **v2**              |             | `/external-api/v2/...` | [v2 docs](v2/docs) |
-| **v1** (deprecated) | 2025-05-01  | `/external-api/v1/...` | [v1 docs](v1/docs) |
-
-**Recommendation**: New integrations should use v2.
-
-For authentication details and usage examples, see the
-[API Integration Guide](https://docs.agpt.co/platform/integrating/api-guide/).
-"""
+from .v1.routes import v1_router
 
 external_api = FastAPI(
-    title="AutoGPT Platform API",
-    summary="External API for AutoGPT Platform integrations",
-    description=DESCRIPTION,
-    version="2.0.0",
+    title="AutoGPT External API",
+    description="External API for AutoGPT integrations",
     docs_url="/docs",
-    redoc_url="/redoc",
+    version="1.0",
 )
 
+external_api.add_middleware(SecurityHeadersMiddleware)
+external_api.include_router(v1_router, prefix="/v1")
 
-@external_api.get("/", include_in_schema=False)
-async def root_redirect() -> RedirectResponse:
-    """Redirect root to API documentation."""
-    return RedirectResponse(url="/docs")
-
-
-# Mount versioned sub-applications
-# Each sub-app has its own /docs page at /v1/docs and /v2/docs
-external_api.mount("/v1", v1_app)
-external_api.mount("/v2", v2_app)
-
-# Add Prometheus instrumentation to the main app
+# Add Prometheus instrumentation
 instrument_fastapi(
     external_api,
     service_name="external-api",

autogpt_platform/backend/backend/api/external/v1/app.py

@@ -1,39 +0,0 @@
-"""
-V1 External API Application
-
-This module defines the FastAPI application for the v1 external API.
-"""
-
-from fastapi import FastAPI
-
-from backend.api.middleware.security import SecurityHeadersMiddleware
-
-from .routes import v1_router
-
-DESCRIPTION = """
-The v1 API provides access to core AutoGPT functionality for external integrations.
-
-For authentication details and usage examples, see the
-[API Integration Guide](https://docs.agpt.co/platform/integrating/api-guide/).
-"""
-
-v1_app = FastAPI(
-    title="AutoGPT Platform API",
-    summary="External API for AutoGPT Platform integrations (v1)",
-    description=DESCRIPTION,
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    openapi_url="/openapi.json",
-    openapi_tags=[
-        {"name": "user", "description": "User information"},
-        {"name": "blocks", "description": "Block operations"},
-        {"name": "graphs", "description": "Graph execution"},
-        {"name": "store", "description": "Marketplace agents and creators"},
-        {"name": "integrations", "description": "OAuth credential management"},
-        {"name": "tools", "description": "AI assistant tools"},
-    ],
-)
-
-v1_app.add_middleware(SecurityHeadersMiddleware)
-v1_app.include_router(v1_router)

autogpt_platform/backend/backend/api/external/v1/tools.py

@@ -70,7 +70,7 @@ class RunAgentRequest(BaseModel):
     )
 
 
-def _create_ephemeral_session(user_id: str) -> ChatSession:
+def _create_ephemeral_session(user_id: str | None) -> ChatSession:
     """Create an ephemeral session for stateless API requests."""
     return ChatSession.new(user_id)
 

autogpt_platform/backend/backend/api/external/v2/__init__.py

@@ -1,9 +0,0 @@
-"""
-V2 External API
-
-This module provides the v2 external API for programmatic access to the AutoGPT Platform.
-"""
-
-from .routes import v2_router
-
-__all__ = ["v2_router"]

autogpt_platform/backend/backend/api/external/v2/app.py

@@ -1,82 +0,0 @@
-"""
-V2 External API Application
-
-This module defines the FastAPI application for the v2 external API.
-"""
-
-from fastapi import FastAPI
-
-from backend.api.middleware.security import SecurityHeadersMiddleware
-
-from .routes import v2_router
-
-DESCRIPTION = """
-The v2 API provides comprehensive access to the AutoGPT Platform for building
-integrations, automations, and custom applications.
-
-### Key Improvements over v1
-
-- **Consistent naming**: Uses `graph_id`/`graph_version` consistently
-- **Better pagination**: All list endpoints support pagination
-- **Comprehensive coverage**: Access to library, runs, schedules, credits, and more
-- **Human-in-the-loop**: Review and approve agent decisions via the API
-
-For authentication details and usage examples, see the
-[API Integration Guide](https://docs.agpt.co/platform/integrating/api-guide/).
-
-### Pagination
-
-List endpoints return paginated responses. Use `page` and `page_size` query
-parameters to navigate results. Maximum page size is 100 items.
-"""
-
-v2_app = FastAPI(
-    title="AutoGPT Platform External API",
-    summary="External API for AutoGPT Platform integrations (v2)",
-    description=DESCRIPTION,
-    version="2.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    openapi_url="/openapi.json",
-    openapi_tags=[
-        {
-            "name": "graphs",
-            "description": "Create, update, and manage agent graphs",
-        },
-        {
-            "name": "schedules",
-            "description": "Manage scheduled graph executions",
-        },
-        {
-            "name": "blocks",
-            "description": "Discover available building blocks",
-        },
-        {
-            "name": "marketplace",
-            "description": "Browse agents and creators, manage submissions",
-        },
-        {
-            "name": "library",
-            "description": "Access your agent library and execute agents",
-        },
-        {
-            "name": "runs",
-            "description": "Monitor execution runs and human-in-the-loop reviews",
-        },
-        {
-            "name": "credits",
-            "description": "Check balance and view transaction history",
-        },
-        {
-            "name": "integrations",
-            "description": "Manage OAuth credentials for external services",
-        },
-        {
-            "name": "files",
-            "description": "Upload files for agent input",
-        },
-    ],
-)
-
-v2_app.add_middleware(SecurityHeadersMiddleware)
-v2_app.include_router(v2_router)

autogpt_platform/backend/backend/api/external/v2/blocks.py

@@ -1,140 +0,0 @@
-"""
-V2 External API - Blocks Endpoints
-
-Provides read-only access to available building blocks.
-"""
-
-import logging
-from typing import Any
-
-from fastapi import APIRouter, Response, Security
-from fastapi.concurrency import run_in_threadpool
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.block import get_blocks
-from backend.util.cache import cached
-from backend.util.json import dumps
-
-logger = logging.getLogger(__name__)
-
-blocks_router = APIRouter()
-
-
-# ============================================================================
-# Models
-# ============================================================================
-
-
-class BlockCost(BaseModel):
-    """Cost information for a block."""
-
-    cost_type: str = Field(description="Type of cost (e.g., 'per_call', 'per_token')")
-    cost_filter: dict[str, Any] = Field(
-        default_factory=dict, description="Conditions for this cost"
-    )
-    cost_amount: int = Field(description="Cost amount in credits")
-
-
-class Block(BaseModel):
-    """A building block that can be used in graphs."""
-
-    id: str
-    name: str
-    description: str
-    categories: list[str] = Field(default_factory=list)
-    input_schema: dict[str, Any]
-    output_schema: dict[str, Any]
-    costs: list[BlockCost] = Field(default_factory=list)
-    disabled: bool = Field(default=False)
-
-
-class BlocksListResponse(BaseModel):
-    """Response for listing blocks."""
-
-    blocks: list[Block]
-    total_count: int
-
-
-# ============================================================================
-# Internal Functions
-# ============================================================================
-
-
-def _compute_blocks_sync() -> str:
-    """
-    Synchronous function to compute blocks data.
-    This does the heavy lifting: instantiate 226+ blocks, compute costs, serialize.
-    """
-    from backend.data.credit import get_block_cost
-
-    block_classes = get_blocks()
-    result = []
-
-    for block_class in block_classes.values():
-        block_instance = block_class()
-        if not block_instance.disabled:
-            costs = get_block_cost(block_instance)
-            # Convert BlockCost BaseModel objects to dictionaries
-            costs_dict = [
-                cost.model_dump() if isinstance(cost, BaseModel) else cost
-                for cost in costs
-            ]
-            result.append({**block_instance.to_dict(), "costs": costs_dict})
-
-    return dumps(result)
-
-
-@cached(ttl_seconds=3600)
-async def _get_cached_blocks() -> str:
-    """
-    Async cached function with thundering herd protection.
-    On cache miss: runs heavy work in thread pool
-    On cache hit: returns cached string immediately
-    """
-    return await run_in_threadpool(_compute_blocks_sync)
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@blocks_router.get(
-    path="",
-    summary="List available blocks",
-    responses={
-        200: {
-            "description": "List of available building blocks",
-            "content": {
-                "application/json": {
-                    "schema": {
-                        "items": {"additionalProperties": True, "type": "object"},
-                        "type": "array",
-                    }
-                }
-            },
-        }
-    },
-)
-async def list_blocks(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_BLOCK)
-    ),
-) -> Response:
-    """
-    List all available building blocks that can be used in graphs.
-
-    Each block represents a specific capability (e.g., HTTP request, text processing,
-    AI completion, etc.) that can be connected in a graph to create an agent.
-
-    The response includes input/output schemas for each block, as well as
-    cost information for blocks that consume credits.
-    """
-    content = await _get_cached_blocks()
-    return Response(
-        content=content,
-        media_type="application/json",
-    )

autogpt_platform/backend/backend/api/external/v2/common.py

@@ -1,36 +0,0 @@
-"""
-Common utilities for V2 External API
-"""
-
-from typing import TypeVar
-
-from pydantic import BaseModel, Field
-
-# Constants for pagination
-MAX_PAGE_SIZE = 100
-DEFAULT_PAGE_SIZE = 20
-
-
-class PaginationParams(BaseModel):
-    """Common pagination parameters."""
-
-    page: int = Field(default=1, ge=1, description="Page number (1-indexed)")
-    page_size: int = Field(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Number of items per page (max {MAX_PAGE_SIZE})",
-    )
-
-
-T = TypeVar("T")
-
-
-class PaginatedResponse(BaseModel):
-    """Generic paginated response wrapper."""
-
-    items: list
-    total_count: int = Field(description="Total number of items across all pages")
-    page: int = Field(description="Current page number (1-indexed)")
-    page_size: int = Field(description="Number of items per page")
-    total_pages: int = Field(description="Total number of pages")

autogpt_platform/backend/backend/api/external/v2/credits.py

@@ -1,141 +0,0 @@
-"""
-V2 External API - Credits Endpoints
-
-Provides access to credit balance and transaction history.
-"""
-
-import logging
-from datetime import datetime
-from typing import Optional
-
-from fastapi import APIRouter, Query, Security
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.credit import get_user_credit_model
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-
-logger = logging.getLogger(__name__)
-
-credits_router = APIRouter()
-
-
-# ============================================================================
-# Models
-# ============================================================================
-
-
-class CreditBalance(BaseModel):
-    """User's credit balance."""
-
-    balance: int = Field(description="Current credit balance")
-
-
-class CreditTransaction(BaseModel):
-    """A credit transaction."""
-
-    transaction_key: str
-    amount: int = Field(description="Transaction amount (positive or negative)")
-    type: str = Field(description="One of: TOP_UP, USAGE, GRANT, REFUND")
-    transaction_time: datetime
-    running_balance: Optional[int] = Field(
-        default=None, description="Balance after this transaction"
-    )
-    description: Optional[str] = None
-
-
-class CreditTransactionsResponse(BaseModel):
-    """Response for listing credit transactions."""
-
-    transactions: list[CreditTransaction]
-    total_count: int
-    page: int
-    page_size: int
-    total_pages: int
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@credits_router.get(
-    path="",
-    summary="Get credit balance",
-    response_model=CreditBalance,
-)
-async def get_balance(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_CREDITS)
-    ),
-) -> CreditBalance:
-    """
-    Get the current credit balance for the authenticated user.
-    """
-    user_credit_model = await get_user_credit_model(auth.user_id)
-    balance = await user_credit_model.get_credits(auth.user_id)
-
-    return CreditBalance(balance=balance)
-
-
-@credits_router.get(
-    path="/transactions",
-    summary="Get transaction history",
-    response_model=CreditTransactionsResponse,
-)
-async def get_transactions(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_CREDITS)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    transaction_type: Optional[str] = Query(
-        default=None,
-        description="Filter by transaction type (TOP_UP, USAGE, GRANT, REFUND)",
-    ),
-) -> CreditTransactionsResponse:
-    """
-    Get credit transaction history for the authenticated user.
-
-    Returns transactions sorted by most recent first.
-    """
-    user_credit_model = await get_user_credit_model(auth.user_id)
-
-    history = await user_credit_model.get_transaction_history(
-        user_id=auth.user_id,
-        transaction_count_limit=page_size,
-        transaction_type=transaction_type,
-    )
-
-    transactions = [
-        CreditTransaction(
-            transaction_key=t.transaction_key,
-            amount=t.amount,
-            type=t.transaction_type.value,
-            transaction_time=t.transaction_time,
-            running_balance=t.running_balance,
-            description=t.description,
-        )
-        for t in history.transactions
-    ]
-
-    # Note: The current credit module doesn't support true pagination,
-    # so we're returning what we have
-    total_count = len(transactions)
-    total_pages = 1  # Without true pagination support
-
-    return CreditTransactionsResponse(
-        transactions=transactions,
-        total_count=total_count,
-        page=page,
-        page_size=page_size,
-        total_pages=total_pages,
-    )

autogpt_platform/backend/backend/api/external/v2/files.py

@@ -1,132 +0,0 @@
-"""
-V2 External API - Files Endpoints
-
-Provides file upload functionality for agent inputs.
-"""
-
-import base64
-import logging
-
-from fastapi import APIRouter, File, HTTPException, Query, Security, UploadFile
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.util.cloud_storage import get_cloud_storage_handler
-from backend.util.settings import Settings
-from backend.util.virus_scanner import scan_content_safe
-
-logger = logging.getLogger(__name__)
-settings = Settings()
-
-files_router = APIRouter()
-
-
-# ============================================================================
-# Models
-# ============================================================================
-
-
-class UploadFileResponse(BaseModel):
-    """Response after uploading a file."""
-
-    file_uri: str = Field(description="URI to reference the uploaded file in agents")
-    file_name: str
-    size: int = Field(description="File size in bytes")
-    content_type: str
-    expires_in_hours: int
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-def _create_file_size_error(size_bytes: int, max_size_mb: int) -> HTTPException:
-    """Create standardized file size error response."""
-    return HTTPException(
-        status_code=400,
-        detail=f"File size ({size_bytes} bytes) exceeds the maximum allowed size of {max_size_mb}MB",
-    )
-
-
-@files_router.post(
-    path="/upload",
-    summary="Upload a file",
-    response_model=UploadFileResponse,
-)
-async def upload_file(
-    file: UploadFile = File(...),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.UPLOAD_FILES)
-    ),
-    provider: str = Query(
-        default="gcs", description="Storage provider (gcs, s3, azure)"
-    ),
-    expiration_hours: int = Query(
-        default=24, ge=1, le=48, description="Hours until file expires (1-48)"
-    ),
-) -> UploadFileResponse:
-    """
-    Upload a file to cloud storage for use with agents.
-
-    The returned `file_uri` can be used as input to agents that accept file inputs
-    (e.g., FileStoreBlock, AgentFileInputBlock).
-
-    Files are automatically scanned for viruses before storage.
-    """
-    # Check file size limit
-    max_size_mb = settings.config.upload_file_size_limit_mb
-    max_size_bytes = max_size_mb * 1024 * 1024
-
-    # Try to get file size from headers first
-    if hasattr(file, "size") and file.size is not None and file.size > max_size_bytes:
-        raise _create_file_size_error(file.size, max_size_mb)
-
-    # Read file content
-    content = await file.read()
-    content_size = len(content)
-
-    # Double-check file size after reading
-    if content_size > max_size_bytes:
-        raise _create_file_size_error(content_size, max_size_mb)
-
-    # Extract file info
-    file_name = file.filename or "uploaded_file"
-    content_type = file.content_type or "application/octet-stream"
-
-    # Virus scan the content
-    await scan_content_safe(content, filename=file_name)
-
-    # Check if cloud storage is configured
-    cloud_storage = await get_cloud_storage_handler()
-    if not cloud_storage.config.gcs_bucket_name:
-        # Fallback to base64 data URI when GCS is not configured
-        base64_content = base64.b64encode(content).decode("utf-8")
-        data_uri = f"data:{content_type};base64,{base64_content}"
-
-        return UploadFileResponse(
-            file_uri=data_uri,
-            file_name=file_name,
-            size=content_size,
-            content_type=content_type,
-            expires_in_hours=expiration_hours,
-        )
-
-    # Store in cloud storage
-    storage_path = await cloud_storage.store_file(
-        content=content,
-        filename=file_name,
-        provider=provider,
-        expiration_hours=expiration_hours,
-        user_id=auth.user_id,
-    )
-
-    return UploadFileResponse(
-        file_uri=storage_path,
-        file_name=file_name,
-        size=content_size,
-        content_type=content_type,
-        expires_in_hours=expiration_hours,
-    )

autogpt_platform/backend/backend/api/external/v2/graphs.py

@@ -1,445 +0,0 @@
-"""
-V2 External API - Graphs Endpoints
-
-Provides endpoints for managing agent graphs (CRUD operations).
-"""
-
-import logging
-
-from fastapi import APIRouter, HTTPException, Query, Security
-from prisma.enums import APIKeyPermission
-
-from backend.api.external.middleware import require_permission
-from backend.data import graph as graph_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.integrations.webhooks.graph_lifecycle_hooks import (
-    on_graph_activate,
-    on_graph_deactivate,
-)
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import (
-    CreateGraphRequest,
-    DeleteGraphResponse,
-    GraphDetails,
-    GraphLink,
-    GraphMeta,
-    GraphNode,
-    GraphSettings,
-    GraphsListResponse,
-    SetActiveVersionRequest,
-)
-
-logger = logging.getLogger(__name__)
-
-graphs_router = APIRouter()
-
-
-def _convert_graph_meta(graph: graph_db.GraphMeta) -> GraphMeta:
-    """Convert internal GraphMeta to v2 API model."""
-    return GraphMeta(
-        id=graph.id,
-        version=graph.version,
-        is_active=graph.is_active,
-        name=graph.name,
-        description=graph.description,
-        created_at=graph.created_at,
-        input_schema=graph.input_schema,
-        output_schema=graph.output_schema,
-    )
-
-
-def _convert_graph_details(graph: graph_db.GraphModel) -> GraphDetails:
-    """Convert internal GraphModel to v2 API GraphDetails model."""
-    return GraphDetails(
-        id=graph.id,
-        version=graph.version,
-        is_active=graph.is_active,
-        name=graph.name,
-        description=graph.description,
-        created_at=graph.created_at,
-        input_schema=graph.input_schema,
-        output_schema=graph.output_schema,
-        nodes=[
-            GraphNode(
-                id=node.id,
-                block_id=node.block_id,
-                input_default=node.input_default,
-                metadata=node.metadata,
-            )
-            for node in graph.nodes
-        ],
-        links=[
-            GraphLink(
-                id=link.id,
-                source_id=link.source_id,
-                sink_id=link.sink_id,
-                source_name=link.source_name,
-                sink_name=link.sink_name,
-                is_static=link.is_static,
-            )
-            for link in graph.links
-        ],
-        credentials_input_schema=graph.credentials_input_schema,
-    )
-
-
-@graphs_router.get(
-    path="",
-    summary="List user's graphs",
-    response_model=GraphsListResponse,
-)
-async def list_graphs(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> GraphsListResponse:
-    """
-    List all graphs owned by the authenticated user.
-
-    Returns a paginated list of graph metadata (not full graph details).
-    """
-    graphs, pagination_info = await graph_db.list_graphs_paginated(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-        filter_by="active",
-    )
-    return GraphsListResponse(
-        graphs=[_convert_graph_meta(g) for g in graphs],
-        total_count=pagination_info.total_items,
-        page=pagination_info.current_page,
-        page_size=pagination_info.page_size,
-        total_pages=pagination_info.total_pages,
-    )
-
-
-@graphs_router.post(
-    path="",
-    summary="Create a new graph",
-    response_model=GraphDetails,
-)
-async def create_graph(
-    create_graph_request: CreateGraphRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> GraphDetails:
-    """
-    Create a new agent graph.
-
-    The graph will be validated and assigned a new ID. It will automatically
-    be added to the user's library.
-    """
-    # Import here to avoid circular imports
-    from backend.api.features.library import db as library_db
-
-    # Convert v2 API Graph model to internal Graph model
-    internal_graph = graph_db.Graph(
-        id=create_graph_request.graph.id or "",
-        version=create_graph_request.graph.version,
-        is_active=create_graph_request.graph.is_active,
-        name=create_graph_request.graph.name,
-        description=create_graph_request.graph.description,
-        nodes=[
-            graph_db.Node(
-                id=node.id,
-                block_id=node.block_id,
-                input_default=node.input_default,
-                metadata=node.metadata,
-            )
-            for node in create_graph_request.graph.nodes
-        ],
-        links=[
-            graph_db.Link(
-                id=link.id,
-                source_id=link.source_id,
-                sink_id=link.sink_id,
-                source_name=link.source_name,
-                sink_name=link.sink_name,
-                is_static=link.is_static,
-            )
-            for link in create_graph_request.graph.links
-        ],
-    )
-
-    graph = graph_db.make_graph_model(internal_graph, auth.user_id)
-    graph.reassign_ids(user_id=auth.user_id, reassign_graph_id=True)
-    graph.validate_graph(for_run=False)
-
-    await graph_db.create_graph(graph, user_id=auth.user_id)
-    await library_db.create_library_agent(graph, user_id=auth.user_id)
-    activated_graph = await on_graph_activate(graph, user_id=auth.user_id)
-
-    return _convert_graph_details(activated_graph)
-
-
-@graphs_router.get(
-    path="/{graph_id}",
-    summary="Get graph details",
-    response_model=GraphDetails,
-)
-async def get_graph(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-    version: int | None = Query(
-        default=None,
-        description="Specific version to retrieve (default: active version)",
-    ),
-) -> GraphDetails:
-    """
-    Get detailed information about a specific graph.
-
-    By default returns the active version. Use the `version` query parameter
-    to retrieve a specific version.
-    """
-    graph = await graph_db.get_graph(
-        graph_id,
-        version,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    if not graph:
-        raise HTTPException(status_code=404, detail=f"Graph #{graph_id} not found.")
-    return _convert_graph_details(graph)
-
-
-@graphs_router.put(
-    path="/{graph_id}",
-    summary="Update graph (creates new version)",
-    response_model=GraphDetails,
-)
-async def update_graph(
-    graph_id: str,
-    graph_request: CreateGraphRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> GraphDetails:
-    """
-    Update a graph by creating a new version.
-
-    This does not modify existing versions - it creates a new version with
-    the provided content. The new version becomes the active version.
-    """
-    # Import here to avoid circular imports
-    from backend.api.features.library import db as library_db
-
-    graph_data = graph_request.graph
-    if graph_data.id and graph_data.id != graph_id:
-        raise HTTPException(400, detail="Graph ID does not match ID in URI")
-
-    existing_versions = await graph_db.get_graph_all_versions(
-        graph_id, user_id=auth.user_id
-    )
-    if not existing_versions:
-        raise HTTPException(404, detail=f"Graph #{graph_id} not found")
-
-    latest_version_number = max(g.version for g in existing_versions)
-
-    # Convert v2 API Graph model to internal Graph model
-    internal_graph = graph_db.Graph(
-        id=graph_id,
-        version=latest_version_number + 1,
-        is_active=graph_data.is_active,
-        name=graph_data.name,
-        description=graph_data.description,
-        nodes=[
-            graph_db.Node(
-                id=node.id,
-                block_id=node.block_id,
-                input_default=node.input_default,
-                metadata=node.metadata,
-            )
-            for node in graph_data.nodes
-        ],
-        links=[
-            graph_db.Link(
-                id=link.id,
-                source_id=link.source_id,
-                sink_id=link.sink_id,
-                source_name=link.source_name,
-                sink_name=link.sink_name,
-                is_static=link.is_static,
-            )
-            for link in graph_data.links
-        ],
-    )
-
-    current_active_version = next((v for v in existing_versions if v.is_active), None)
-    graph = graph_db.make_graph_model(internal_graph, auth.user_id)
-    graph.reassign_ids(user_id=auth.user_id, reassign_graph_id=False)
-    graph.validate_graph(for_run=False)
-
-    new_graph_version = await graph_db.create_graph(graph, user_id=auth.user_id)
-
-    if new_graph_version.is_active:
-        await library_db.update_agent_version_in_library(
-            auth.user_id, new_graph_version.id, new_graph_version.version
-        )
-        new_graph_version = await on_graph_activate(
-            new_graph_version, user_id=auth.user_id
-        )
-        await graph_db.set_graph_active_version(
-            graph_id=graph_id, version=new_graph_version.version, user_id=auth.user_id
-        )
-        if current_active_version:
-            await on_graph_deactivate(current_active_version, user_id=auth.user_id)
-
-    new_graph_version_with_subgraphs = await graph_db.get_graph(
-        graph_id,
-        new_graph_version.version,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    assert new_graph_version_with_subgraphs
-    return _convert_graph_details(new_graph_version_with_subgraphs)
-
-
-@graphs_router.delete(
-    path="/{graph_id}",
-    summary="Delete graph permanently",
-    response_model=DeleteGraphResponse,
-)
-async def delete_graph(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> DeleteGraphResponse:
-    """
-    Permanently delete a graph and all its versions.
-
-    This action cannot be undone. All associated executions will remain
-    but will reference a deleted graph.
-    """
-    if active_version := await graph_db.get_graph(
-        graph_id=graph_id, version=None, user_id=auth.user_id
-    ):
-        await on_graph_deactivate(active_version, user_id=auth.user_id)
-
-    version_count = await graph_db.delete_graph(graph_id, user_id=auth.user_id)
-    return DeleteGraphResponse(version_count=version_count)
-
-
-@graphs_router.get(
-    path="/{graph_id}/versions",
-    summary="List all graph versions",
-    response_model=list[GraphDetails],
-)
-async def list_graph_versions(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-) -> list[GraphDetails]:
-    """
-    Get all versions of a specific graph.
-
-    Returns a list of all versions, with the active version marked.
-    """
-    graphs = await graph_db.get_graph_all_versions(graph_id, user_id=auth.user_id)
-    if not graphs:
-        raise HTTPException(status_code=404, detail=f"Graph #{graph_id} not found.")
-    return [_convert_graph_details(g) for g in graphs]
-
-
-@graphs_router.put(
-    path="/{graph_id}/versions/active",
-    summary="Set active graph version",
-)
-async def set_active_version(
-    graph_id: str,
-    request_body: SetActiveVersionRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> None:
-    """
-    Set which version of a graph is the active version.
-
-    The active version is used when executing the graph without specifying
-    a version number.
-    """
-    # Import here to avoid circular imports
-    from backend.api.features.library import db as library_db
-
-    new_active_version = request_body.active_graph_version
-    new_active_graph = await graph_db.get_graph(
-        graph_id, new_active_version, user_id=auth.user_id
-    )
-    if not new_active_graph:
-        raise HTTPException(404, f"Graph #{graph_id} v{new_active_version} not found")
-
-    current_active_graph = await graph_db.get_graph(
-        graph_id=graph_id,
-        version=None,
-        user_id=auth.user_id,
-    )
-
-    await on_graph_activate(new_active_graph, user_id=auth.user_id)
-    await graph_db.set_graph_active_version(
-        graph_id=graph_id,
-        version=new_active_version,
-        user_id=auth.user_id,
-    )
-
-    await library_db.update_agent_version_in_library(
-        auth.user_id, new_active_graph.id, new_active_graph.version
-    )
-
-    if current_active_graph and current_active_graph.version != new_active_version:
-        await on_graph_deactivate(current_active_graph, user_id=auth.user_id)
-
-
-@graphs_router.patch(
-    path="/{graph_id}/settings",
-    summary="Update graph settings",
-    response_model=GraphSettings,
-)
-async def update_graph_settings(
-    graph_id: str,
-    settings: GraphSettings,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> GraphSettings:
-    """
-    Update settings for a graph.
-
-    Currently supports:
-    - human_in_the_loop_safe_mode: Enable/disable safe mode for human-in-the-loop blocks
-    """
-    # Import here to avoid circular imports
-    from backend.api.features.library import db as library_db
-    from backend.data.graph import GraphSettings as InternalGraphSettings
-
-    library_agent = await library_db.get_library_agent_by_graph_id(
-        graph_id=graph_id, user_id=auth.user_id
-    )
-    if not library_agent:
-        raise HTTPException(404, f"Graph #{graph_id} not found in user's library")
-
-    # Convert to internal model
-    internal_settings = InternalGraphSettings(
-        human_in_the_loop_safe_mode=settings.human_in_the_loop_safe_mode
-    )
-
-    updated_agent = await library_db.update_library_agent_settings(
-        user_id=auth.user_id,
-        agent_id=library_agent.id,
-        settings=internal_settings,
-    )
-
-    return GraphSettings(
-        human_in_the_loop_safe_mode=updated_agent.settings.human_in_the_loop_safe_mode
-    )

autogpt_platform/backend/backend/api/external/v2/integrations.py

@@ -1,271 +0,0 @@
-"""
-V2 External API - Integrations Endpoints
-
-Provides access to user's integration credentials.
-"""
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Path, Security
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.library import db as library_db
-from backend.data import graph as graph_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.model import Credentials, OAuth2Credentials
-from backend.integrations.creds_manager import IntegrationCredentialsManager
-
-logger = logging.getLogger(__name__)
-
-integrations_router = APIRouter()
-creds_manager = IntegrationCredentialsManager()
-
-
-# ============================================================================
-# Models
-# ============================================================================
-
-
-class Credential(BaseModel):
-    """A user's credential for an integration."""
-
-    id: str
-    provider: str = Field(description="Integration provider name")
-    title: Optional[str] = Field(
-        default=None, description="User-assigned title for this credential"
-    )
-    scopes: list[str] = Field(default_factory=list, description="Granted scopes")
-
-
-class CredentialsListResponse(BaseModel):
-    """Response for listing credentials."""
-
-    credentials: list[Credential]
-
-
-class CredentialRequirement(BaseModel):
-    """A credential requirement for a graph or agent."""
-
-    provider: str = Field(description="Required provider name")
-    required_scopes: list[str] = Field(
-        default_factory=list, description="Required scopes"
-    )
-    matching_credentials: list[Credential] = Field(
-        default_factory=list,
-        description="User's credentials that match this requirement",
-    )
-
-
-class CredentialRequirementsResponse(BaseModel):
-    """Response for listing credential requirements."""
-
-    requirements: list[CredentialRequirement]
-
-
-# ============================================================================
-# Conversion Functions
-# ============================================================================
-
-
-def _convert_credential(cred: Credentials) -> Credential:
-    """Convert internal credential to v2 API model."""
-    scopes: list[str] = []
-    if isinstance(cred, OAuth2Credentials):
-        scopes = cred.scopes or []
-
-    return Credential(
-        id=cred.id,
-        provider=cred.provider,
-        title=cred.title,
-        scopes=scopes,
-    )
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@integrations_router.get(
-    path="/credentials",
-    summary="List all credentials",
-    response_model=CredentialsListResponse,
-)
-async def list_credentials(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> CredentialsListResponse:
-    """
-    List all integration credentials for the authenticated user.
-
-    This returns all OAuth credentials the user has connected, across
-    all integration providers.
-    """
-    credentials = await creds_manager.store.get_all_creds(auth.user_id)
-
-    return CredentialsListResponse(
-        credentials=[_convert_credential(c) for c in credentials]
-    )
-
-
-@integrations_router.get(
-    path="/credentials/{provider}",
-    summary="List credentials by provider",
-    response_model=CredentialsListResponse,
-)
-async def list_credentials_by_provider(
-    provider: str = Path(description="Provider name (e.g., 'github', 'google')"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> CredentialsListResponse:
-    """
-    List integration credentials for a specific provider.
-    """
-    all_credentials = await creds_manager.store.get_all_creds(auth.user_id)
-
-    # Filter by provider
-    filtered = [c for c in all_credentials if c.provider.lower() == provider.lower()]
-
-    return CredentialsListResponse(
-        credentials=[_convert_credential(c) for c in filtered]
-    )
-
-
-@integrations_router.get(
-    path="/graphs/{graph_id}/credentials",
-    summary="List credentials matching graph requirements",
-    response_model=CredentialRequirementsResponse,
-)
-async def list_graph_credential_requirements(
-    graph_id: str = Path(description="Graph ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> CredentialRequirementsResponse:
-    """
-    List credential requirements for a graph and matching user credentials.
-
-    This helps identify which credentials the user needs to provide
-    when executing a graph.
-    """
-    # Get the graph
-    graph = await graph_db.get_graph(
-        graph_id=graph_id,
-        version=None,  # Active version
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    if not graph:
-        raise HTTPException(status_code=404, detail=f"Graph #{graph_id} not found")
-
-    # Get the credentials input schema which contains provider requirements
-    creds_schema = graph.credentials_input_schema
-    all_credentials = await creds_manager.store.get_all_creds(auth.user_id)
-
-    requirements = []
-    for field_name, field_schema in creds_schema.get("properties", {}).items():
-        # Extract provider from schema
-        # The schema structure varies, but typically has provider info
-        providers = []
-        if "anyOf" in field_schema:
-            for option in field_schema["anyOf"]:
-                if "provider" in option:
-                    providers.append(option["provider"])
-        elif "provider" in field_schema:
-            providers.append(field_schema["provider"])
-
-        for provider in providers:
-            # Find matching credentials
-            matching = [
-                _convert_credential(c)
-                for c in all_credentials
-                if c.provider.lower() == provider.lower()
-            ]
-
-            requirements.append(
-                CredentialRequirement(
-                    provider=provider,
-                    required_scopes=[],  # Would need to extract from schema
-                    matching_credentials=matching,
-                )
-            )
-
-    return CredentialRequirementsResponse(requirements=requirements)
-
-
-@integrations_router.get(
-    path="/library/{agent_id}/credentials",
-    summary="List credentials matching library agent requirements",
-    response_model=CredentialRequirementsResponse,
-)
-async def list_library_agent_credential_requirements(
-    agent_id: str = Path(description="Library agent ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> CredentialRequirementsResponse:
-    """
-    List credential requirements for a library agent and matching user credentials.
-
-    This helps identify which credentials the user needs to provide
-    when executing an agent from their library.
-    """
-    # Get the library agent
-    try:
-        library_agent = await library_db.get_library_agent(
-            id=agent_id,
-            user_id=auth.user_id,
-        )
-    except Exception:
-        raise HTTPException(status_code=404, detail=f"Agent #{agent_id} not found")
-
-    # Get the underlying graph
-    graph = await graph_db.get_graph(
-        graph_id=library_agent.graph_id,
-        version=library_agent.graph_version,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    if not graph:
-        raise HTTPException(
-            status_code=404,
-            detail=f"Graph for agent #{agent_id} not found",
-        )
-
-    # Get the credentials input schema
-    creds_schema = graph.credentials_input_schema
-    all_credentials = await creds_manager.store.get_all_creds(auth.user_id)
-
-    requirements = []
-    for field_name, field_schema in creds_schema.get("properties", {}).items():
-        # Extract provider from schema
-        providers = []
-        if "anyOf" in field_schema:
-            for option in field_schema["anyOf"]:
-                if "provider" in option:
-                    providers.append(option["provider"])
-        elif "provider" in field_schema:
-            providers.append(field_schema["provider"])
-
-        for provider in providers:
-            # Find matching credentials
-            matching = [
-                _convert_credential(c)
-                for c in all_credentials
-                if c.provider.lower() == provider.lower()
-            ]
-
-            requirements.append(
-                CredentialRequirement(
-                    provider=provider,
-                    required_scopes=[],
-                    matching_credentials=matching,
-                )
-            )
-
-    return CredentialRequirementsResponse(requirements=requirements)

autogpt_platform/backend/backend/api/external/v2/library.py

@@ -1,247 +0,0 @@
-"""
-V2 External API - Library Endpoints
-
-Provides access to the user's agent library and agent execution.
-"""
-
-import logging
-
-from fastapi import APIRouter, HTTPException, Path, Query, Security
-from prisma.enums import APIKeyPermission
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.library import db as library_db
-from backend.api.features.library import model as library_model
-from backend.data import execution as execution_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.credit import get_user_credit_model
-from backend.executor import utils as execution_utils
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import (
-    ExecuteAgentRequest,
-    LibraryAgent,
-    LibraryAgentsResponse,
-    Run,
-    RunsListResponse,
-)
-
-logger = logging.getLogger(__name__)
-
-library_router = APIRouter()
-
-
-# ============================================================================
-# Conversion Functions
-# ============================================================================
-
-
-def _convert_library_agent(agent: library_model.LibraryAgent) -> LibraryAgent:
-    """Convert internal LibraryAgent to v2 API model."""
-    return LibraryAgent(
-        id=agent.id,
-        graph_id=agent.graph_id,
-        graph_version=agent.graph_version,
-        name=agent.name,
-        description=agent.description,
-        is_favorite=agent.is_favorite,
-        can_access_graph=agent.can_access_graph,
-        is_latest_version=agent.is_latest_version,
-        image_url=agent.image_url,
-        creator_name=agent.creator_name,
-        input_schema=agent.input_schema,
-        output_schema=agent.output_schema,
-        created_at=agent.created_at,
-        updated_at=agent.updated_at,
-    )
-
-
-def _convert_execution_to_run(exec: execution_db.GraphExecutionMeta) -> Run:
-    """Convert internal execution to v2 API Run model."""
-    return Run(
-        id=exec.id,
-        graph_id=exec.graph_id,
-        graph_version=exec.graph_version,
-        status=exec.status.value,
-        started_at=exec.started_at,
-        ended_at=exec.ended_at,
-        inputs=exec.inputs,
-        cost=exec.stats.cost if exec.stats else 0,
-        duration=exec.stats.duration if exec.stats else 0,
-        node_count=exec.stats.node_exec_count if exec.stats else 0,
-    )
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@library_router.get(
-    path="/agents",
-    summary="List library agents",
-    response_model=LibraryAgentsResponse,
-)
-async def list_library_agents(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> LibraryAgentsResponse:
-    """
-    List agents in the user's library.
-
-    The library contains agents the user has created or added from the marketplace.
-    """
-    result = await library_db.list_library_agents(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    return LibraryAgentsResponse(
-        agents=[_convert_library_agent(a) for a in result.agents],
-        total_count=result.pagination.total_items,
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@library_router.get(
-    path="/agents/favorites",
-    summary="List favorite agents",
-    response_model=LibraryAgentsResponse,
-)
-async def list_favorite_agents(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> LibraryAgentsResponse:
-    """
-    List favorite agents in the user's library.
-    """
-    result = await library_db.list_favorite_library_agents(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    return LibraryAgentsResponse(
-        agents=[_convert_library_agent(a) for a in result.agents],
-        total_count=result.pagination.total_items,
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@library_router.post(
-    path="/agents/{agent_id}/runs",
-    summary="Execute an agent",
-    response_model=Run,
-)
-async def execute_agent(
-    request: ExecuteAgentRequest,
-    agent_id: str = Path(description="Library agent ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.RUN_AGENT)
-    ),
-) -> Run:
-    """
-    Execute an agent from the library.
-
-    This creates a new run with the provided inputs. The run executes
-    asynchronously and you can poll the run status using GET /runs/{run_id}.
-    """
-    # Check credit balance
-    user_credit_model = await get_user_credit_model(auth.user_id)
-    current_balance = await user_credit_model.get_credits(auth.user_id)
-    if current_balance <= 0:
-        raise HTTPException(
-            status_code=402,
-            detail="Insufficient balance to execute the agent. Please top up your account.",
-        )
-
-    # Get the library agent to find the graph ID and version
-    try:
-        library_agent = await library_db.get_library_agent(
-            id=agent_id,
-            user_id=auth.user_id,
-        )
-    except Exception:
-        raise HTTPException(status_code=404, detail=f"Agent #{agent_id} not found")
-
-    try:
-        result = await execution_utils.add_graph_execution(
-            graph_id=library_agent.graph_id,
-            user_id=auth.user_id,
-            inputs=request.inputs,
-            graph_version=library_agent.graph_version,
-            graph_credentials_inputs=request.credentials_inputs,
-        )
-
-        return _convert_execution_to_run(result)
-
-    except Exception as e:
-        logger.error(f"Failed to execute agent: {e}")
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@library_router.get(
-    path="/agents/{agent_id}/runs",
-    summary="List runs for an agent",
-    response_model=RunsListResponse,
-)
-async def list_agent_runs(
-    agent_id: str = Path(description="Library agent ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> RunsListResponse:
-    """
-    List execution runs for a specific agent.
-    """
-    # Get the library agent to find the graph ID
-    try:
-        library_agent = await library_db.get_library_agent(
-            id=agent_id,
-            user_id=auth.user_id,
-        )
-    except Exception:
-        raise HTTPException(status_code=404, detail=f"Agent #{agent_id} not found")
-
-    result = await execution_db.get_graph_executions_paginated(
-        graph_id=library_agent.graph_id,
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    return RunsListResponse(
-        runs=[_convert_execution_to_run(e) for e in result.executions],
-        total_count=result.pagination.total_items,
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_pages=result.pagination.total_pages,
-    )

autogpt_platform/backend/backend/api/external/v2/marketplace.py

@@ -1,510 +0,0 @@
-"""
-V2 External API - Marketplace Endpoints
-
-Provides access to the agent marketplace (store).
-"""
-
-import logging
-import urllib.parse
-from datetime import datetime
-from typing import Literal, Optional
-
-from fastapi import APIRouter, HTTPException, Path, Query, Security
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.store import cache as store_cache
-from backend.api.features.store import db as store_db
-from backend.api.features.store import model as store_model
-from backend.data.auth.base import APIAuthorizationInfo
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-
-logger = logging.getLogger(__name__)
-
-marketplace_router = APIRouter()
-
-
-# ============================================================================
-# Models
-# ============================================================================
-
-
-class MarketplaceAgent(BaseModel):
-    """An agent available in the marketplace."""
-
-    slug: str
-    name: str
-    description: str
-    sub_heading: str
-    creator: str
-    creator_avatar: str
-    runs: int = Field(default=0, description="Number of times this agent has been run")
-    rating: float = Field(default=0.0, description="Average rating")
-    image_url: str = Field(default="")
-
-
-class MarketplaceAgentDetails(BaseModel):
-    """Detailed information about a marketplace agent."""
-
-    store_listing_version_id: str
-    slug: str
-    name: str
-    description: str
-    sub_heading: str
-    instructions: Optional[str] = None
-    creator: str
-    creator_avatar: str
-    categories: list[str] = Field(default_factory=list)
-    runs: int = Field(default=0)
-    rating: float = Field(default=0.0)
-    image_urls: list[str] = Field(default_factory=list)
-    video_url: str = Field(default="")
-    versions: list[str] = Field(default_factory=list, description="Available versions")
-    agent_graph_versions: list[str] = Field(default_factory=list)
-    agent_graph_id: str
-    last_updated: datetime
-
-
-class MarketplaceAgentsResponse(BaseModel):
-    """Response for listing marketplace agents."""
-
-    agents: list[MarketplaceAgent]
-    total_count: int
-    page: int
-    page_size: int
-    total_pages: int
-
-
-class MarketplaceCreator(BaseModel):
-    """A creator on the marketplace."""
-
-    name: str
-    username: str
-    description: str
-    avatar_url: str
-    num_agents: int
-    agent_rating: float
-    agent_runs: int
-    is_featured: bool = False
-
-
-class MarketplaceCreatorDetails(BaseModel):
-    """Detailed information about a marketplace creator."""
-
-    name: str
-    username: str
-    description: str
-    avatar_url: str
-    agent_rating: float
-    agent_runs: int
-    top_categories: list[str] = Field(default_factory=list)
-    links: list[str] = Field(default_factory=list)
-
-
-class MarketplaceCreatorsResponse(BaseModel):
-    """Response for listing marketplace creators."""
-
-    creators: list[MarketplaceCreator]
-    total_count: int
-    page: int
-    page_size: int
-    total_pages: int
-
-
-class MarketplaceSubmission(BaseModel):
-    """A marketplace submission."""
-
-    graph_id: str
-    graph_version: int
-    name: str
-    sub_heading: str
-    slug: str
-    description: str
-    instructions: Optional[str] = None
-    image_urls: list[str] = Field(default_factory=list)
-    date_submitted: datetime
-    status: str = Field(description="One of: DRAFT, PENDING, APPROVED, REJECTED")
-    runs: int = Field(default=0)
-    rating: float = Field(default=0.0)
-    store_listing_version_id: Optional[str] = None
-    version: Optional[int] = None
-    review_comments: Optional[str] = None
-    reviewed_at: Optional[datetime] = None
-    video_url: Optional[str] = None
-    categories: list[str] = Field(default_factory=list)
-
-
-class SubmissionsListResponse(BaseModel):
-    """Response for listing submissions."""
-
-    submissions: list[MarketplaceSubmission]
-    total_count: int
-    page: int
-    page_size: int
-    total_pages: int
-
-
-class CreateSubmissionRequest(BaseModel):
-    """Request to create a marketplace submission."""
-
-    graph_id: str = Field(description="ID of the graph to submit")
-    graph_version: int = Field(description="Version of the graph to submit")
-    name: str = Field(description="Display name for the agent")
-    slug: str = Field(description="URL-friendly identifier")
-    description: str = Field(description="Full description")
-    sub_heading: str = Field(description="Short tagline")
-    image_urls: list[str] = Field(default_factory=list)
-    video_url: Optional[str] = None
-    categories: list[str] = Field(default_factory=list)
-
-
-# ============================================================================
-# Conversion Functions
-# ============================================================================
-
-
-def _convert_store_agent(agent: store_model.StoreAgent) -> MarketplaceAgent:
-    """Convert internal StoreAgent to v2 API model."""
-    return MarketplaceAgent(
-        slug=agent.slug,
-        name=agent.agent_name,
-        description=agent.description,
-        sub_heading=agent.sub_heading,
-        creator=agent.creator,
-        creator_avatar=agent.creator_avatar,
-        runs=agent.runs,
-        rating=agent.rating,
-        image_url=agent.agent_image,
-    )
-
-
-def _convert_store_agent_details(
-    agent: store_model.StoreAgentDetails,
-) -> MarketplaceAgentDetails:
-    """Convert internal StoreAgentDetails to v2 API model."""
-    return MarketplaceAgentDetails(
-        store_listing_version_id=agent.store_listing_version_id,
-        slug=agent.slug,
-        name=agent.agent_name,
-        description=agent.description,
-        sub_heading=agent.sub_heading,
-        instructions=agent.instructions,
-        creator=agent.creator,
-        creator_avatar=agent.creator_avatar,
-        categories=agent.categories,
-        runs=agent.runs,
-        rating=agent.rating,
-        image_urls=agent.agent_image,
-        video_url=agent.agent_video,
-        versions=agent.versions,
-        agent_graph_versions=agent.agentGraphVersions,
-        agent_graph_id=agent.agentGraphId,
-        last_updated=agent.last_updated,
-    )
-
-
-def _convert_creator(creator: store_model.Creator) -> MarketplaceCreator:
-    """Convert internal Creator to v2 API model."""
-    return MarketplaceCreator(
-        name=creator.name,
-        username=creator.username,
-        description=creator.description,
-        avatar_url=creator.avatar_url,
-        num_agents=creator.num_agents,
-        agent_rating=creator.agent_rating,
-        agent_runs=creator.agent_runs,
-        is_featured=creator.is_featured,
-    )
-
-
-def _convert_creator_details(
-    creator: store_model.CreatorDetails,
-) -> MarketplaceCreatorDetails:
-    """Convert internal CreatorDetails to v2 API model."""
-    return MarketplaceCreatorDetails(
-        name=creator.name,
-        username=creator.username,
-        description=creator.description,
-        avatar_url=creator.avatar_url,
-        agent_rating=creator.agent_rating,
-        agent_runs=creator.agent_runs,
-        top_categories=creator.top_categories,
-        links=creator.links,
-    )
-
-
-def _convert_submission(sub: store_model.StoreSubmission) -> MarketplaceSubmission:
-    """Convert internal StoreSubmission to v2 API model."""
-    return MarketplaceSubmission(
-        graph_id=sub.agent_id,
-        graph_version=sub.agent_version,
-        name=sub.name,
-        sub_heading=sub.sub_heading,
-        slug=sub.slug,
-        description=sub.description,
-        instructions=sub.instructions,
-        image_urls=sub.image_urls,
-        date_submitted=sub.date_submitted,
-        status=sub.status.value,
-        runs=sub.runs,
-        rating=sub.rating,
-        store_listing_version_id=sub.store_listing_version_id,
-        version=sub.version,
-        review_comments=sub.review_comments,
-        reviewed_at=sub.reviewed_at,
-        video_url=sub.video_url,
-        categories=sub.categories,
-    )
-
-
-# ============================================================================
-# Endpoints - Read (authenticated)
-# ============================================================================
-
-
-@marketplace_router.get(
-    path="/agents",
-    summary="List marketplace agents",
-    response_model=MarketplaceAgentsResponse,
-)
-async def list_agents(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-    featured: bool = Query(default=False, description="Filter to featured agents only"),
-    creator: Optional[str] = Query(
-        default=None, description="Filter by creator username"
-    ),
-    sorted_by: Optional[Literal["rating", "runs", "name", "updated_at"]] = Query(
-        default=None, description="Sort field"
-    ),
-    search_query: Optional[str] = Query(default=None, description="Search query"),
-    category: Optional[str] = Query(default=None, description="Filter by category"),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> MarketplaceAgentsResponse:
-    """
-    List agents available in the marketplace.
-
-    Supports filtering by featured status, creator, category, and search query.
-    Results can be sorted by rating, runs, name, or update time.
-    """
-    result = await store_cache._get_cached_store_agents(
-        featured=featured,
-        creator=creator,
-        sorted_by=sorted_by,
-        search_query=search_query,
-        category=category,
-        page=page,
-        page_size=page_size,
-    )
-
-    return MarketplaceAgentsResponse(
-        agents=[_convert_store_agent(a) for a in result.agents],
-        total_count=result.pagination.total_items,
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@marketplace_router.get(
-    path="/agents/{username}/{agent_name}",
-    summary="Get agent details",
-    response_model=MarketplaceAgentDetails,
-)
-async def get_agent_details(
-    username: str = Path(description="Creator username"),
-    agent_name: str = Path(description="Agent slug/name"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-) -> MarketplaceAgentDetails:
-    """
-    Get detailed information about a specific marketplace agent.
-    """
-    username = urllib.parse.unquote(username).lower()
-    agent_name = urllib.parse.unquote(agent_name).lower()
-
-    agent = await store_cache._get_cached_agent_details(
-        username=username, agent_name=agent_name
-    )
-
-    return _convert_store_agent_details(agent)
-
-
-@marketplace_router.get(
-    path="/creators",
-    summary="List marketplace creators",
-    response_model=MarketplaceCreatorsResponse,
-)
-async def list_creators(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-    featured: bool = Query(
-        default=False, description="Filter to featured creators only"
-    ),
-    search_query: Optional[str] = Query(default=None, description="Search query"),
-    sorted_by: Optional[Literal["agent_rating", "agent_runs", "num_agents"]] = Query(
-        default=None, description="Sort field"
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> MarketplaceCreatorsResponse:
-    """
-    List creators on the marketplace.
-
-    Supports filtering by featured status and search query.
-    Results can be sorted by rating, runs, or number of agents.
-    """
-    result = await store_cache._get_cached_store_creators(
-        featured=featured,
-        search_query=search_query,
-        sorted_by=sorted_by,
-        page=page,
-        page_size=page_size,
-    )
-
-    return MarketplaceCreatorsResponse(
-        creators=[_convert_creator(c) for c in result.creators],
-        total_count=result.pagination.total_items,
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@marketplace_router.get(
-    path="/creators/{username}",
-    summary="Get creator details",
-    response_model=MarketplaceCreatorDetails,
-)
-async def get_creator_details(
-    username: str = Path(description="Creator username"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-) -> MarketplaceCreatorDetails:
-    """
-    Get detailed information about a specific marketplace creator.
-    """
-    username = urllib.parse.unquote(username).lower()
-
-    creator = await store_cache._get_cached_creator_details(username=username)
-
-    return _convert_creator_details(creator)
-
-
-# ============================================================================
-# Endpoints - Submissions (CRUD)
-# ============================================================================
-
-
-@marketplace_router.get(
-    path="/submissions",
-    summary="List my submissions",
-    response_model=SubmissionsListResponse,
-)
-async def list_submissions(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> SubmissionsListResponse:
-    """
-    List your marketplace submissions.
-
-    Returns all submissions you've created, including drafts, pending,
-    approved, and rejected submissions.
-    """
-    result = await store_db.get_store_submissions(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    return SubmissionsListResponse(
-        submissions=[_convert_submission(s) for s in result.submissions],
-        total_count=result.pagination.total_items,
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@marketplace_router.post(
-    path="/submissions",
-    summary="Create a submission",
-    response_model=MarketplaceSubmission,
-)
-async def create_submission(
-    request: CreateSubmissionRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_STORE)
-    ),
-) -> MarketplaceSubmission:
-    """
-    Create a new marketplace submission.
-
-    This submits an agent for review to be published in the marketplace.
-    The submission will be in PENDING status until reviewed by the team.
-    """
-    submission = await store_db.create_store_submission(
-        user_id=auth.user_id,
-        agent_id=request.graph_id,
-        agent_version=request.graph_version,
-        slug=request.slug,
-        name=request.name,
-        sub_heading=request.sub_heading,
-        description=request.description,
-        image_urls=request.image_urls,
-        video_url=request.video_url,
-        categories=request.categories,
-    )
-
-    return _convert_submission(submission)
-
-
-@marketplace_router.delete(
-    path="/submissions/{submission_id}",
-    summary="Delete a submission",
-)
-async def delete_submission(
-    submission_id: str = Path(description="Submission ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_STORE)
-    ),
-) -> None:
-    """
-    Delete a marketplace submission.
-
-    Only submissions in DRAFT status can be deleted.
-    """
-    success = await store_db.delete_store_submission(
-        user_id=auth.user_id,
-        submission_id=submission_id,
-    )
-
-    if not success:
-        raise HTTPException(
-            status_code=404, detail=f"Submission #{submission_id} not found"
-        )

autogpt_platform/backend/backend/api/external/v2/models.py

@@ -1,552 +0,0 @@
-"""
-V2 External API - Request and Response Models
-
-This module defines all request and response models for the v2 external API.
-All models are self-contained and specific to the external API contract.
-"""
-
-from datetime import datetime
-from typing import Any, Optional
-
-from pydantic import BaseModel, Field
-
-# ============================================================================
-# Common/Shared Models
-# ============================================================================
-
-
-class PaginatedResponse(BaseModel):
-    """Base class for paginated responses."""
-
-    total_count: int = Field(description="Total number of items across all pages")
-    page: int = Field(description="Current page number (1-indexed)")
-    page_size: int = Field(description="Number of items per page")
-    total_pages: int = Field(description="Total number of pages")
-
-
-# ============================================================================
-# Graph Models
-# ============================================================================
-
-
-class GraphLink(BaseModel):
-    """A link between two nodes in a graph."""
-
-    id: str
-    source_id: str = Field(description="ID of the source node")
-    sink_id: str = Field(description="ID of the target node")
-    source_name: str = Field(description="Output pin name on source node")
-    sink_name: str = Field(description="Input pin name on target node")
-    is_static: bool = Field(
-        default=False, description="Whether this link provides static data"
-    )
-
-
-class GraphNode(BaseModel):
-    """A node in an agent graph."""
-
-    id: str
-    block_id: str = Field(description="ID of the block type")
-    input_default: dict[str, Any] = Field(
-        default_factory=dict, description="Default input values"
-    )
-    metadata: dict[str, Any] = Field(
-        default_factory=dict, description="Node metadata (e.g., position)"
-    )
-
-
-class Graph(BaseModel):
-    """Graph definition for creating or updating an agent."""
-
-    id: Optional[str] = Field(default=None, description="Graph ID (assigned by server)")
-    version: int = Field(default=1, description="Graph version")
-    is_active: bool = Field(default=True, description="Whether this version is active")
-    name: str = Field(description="Graph name")
-    description: str = Field(default="", description="Graph description")
-    nodes: list[GraphNode] = Field(default_factory=list, description="List of nodes")
-    links: list[GraphLink] = Field(
-        default_factory=list, description="Links between nodes"
-    )
-
-
-class GraphMeta(BaseModel):
-    """Graph metadata (summary information)."""
-
-    id: str
-    version: int
-    is_active: bool
-    name: str
-    description: str
-    created_at: datetime
-    input_schema: dict[str, Any] = Field(description="Input schema for the graph")
-    output_schema: dict[str, Any] = Field(description="Output schema for the graph")
-
-
-class GraphDetails(GraphMeta):
-    """Full graph details including nodes and links."""
-
-    nodes: list[GraphNode]
-    links: list[GraphLink]
-    credentials_input_schema: dict[str, Any] = Field(
-        description="Schema for required credentials"
-    )
-
-
-class GraphSettings(BaseModel):
-    """Settings for a graph."""
-
-    human_in_the_loop_safe_mode: Optional[bool] = Field(
-        default=None, description="Enable safe mode for human-in-the-loop blocks"
-    )
-
-
-class CreateGraphRequest(BaseModel):
-    """Request to create a new graph."""
-
-    graph: Graph = Field(description="The graph definition")
-
-
-class SetActiveVersionRequest(BaseModel):
-    """Request to set the active graph version."""
-
-    active_graph_version: int = Field(description="Version number to set as active")
-
-
-class GraphsListResponse(PaginatedResponse):
-    """Response for listing graphs."""
-
-    graphs: list[GraphMeta]
-
-
-class DeleteGraphResponse(BaseModel):
-    """Response for deleting a graph."""
-
-    version_count: int = Field(description="Number of versions deleted")
-
-
-# ============================================================================
-# Schedule Models
-# ============================================================================
-
-
-class Schedule(BaseModel):
-    """An execution schedule for a graph."""
-
-    id: str
-    name: str
-    graph_id: str
-    graph_version: int
-    cron: str = Field(description="Cron expression for the schedule")
-    input_data: dict[str, Any] = Field(
-        default_factory=dict, description="Input data for scheduled executions"
-    )
-    is_enabled: bool = Field(default=True, description="Whether schedule is enabled")
-    next_run_time: Optional[datetime] = Field(
-        default=None, description="Next scheduled run time"
-    )
-
-
-class CreateScheduleRequest(BaseModel):
-    """Request to create a schedule."""
-
-    name: str = Field(description="Display name for the schedule")
-    cron: str = Field(description="Cron expression (e.g., '0 9 * * *' for 9am daily)")
-    input_data: dict[str, Any] = Field(
-        default_factory=dict, description="Input data for scheduled executions"
-    )
-    credentials_inputs: dict[str, Any] = Field(
-        default_factory=dict, description="Credentials for the schedule"
-    )
-    graph_version: Optional[int] = Field(
-        default=None, description="Graph version (default: active version)"
-    )
-    timezone: Optional[str] = Field(
-        default=None,
-        description="Timezone for schedule (e.g., 'America/New_York')",
-    )
-
-
-class SchedulesListResponse(PaginatedResponse):
-    """Response for listing schedules."""
-
-    schedules: list[Schedule]
-
-
-# ============================================================================
-# Block Models
-# ============================================================================
-
-
-class BlockCost(BaseModel):
-    """Cost information for a block."""
-
-    cost_type: str = Field(description="Type of cost (e.g., 'per_call', 'per_token')")
-    cost_filter: dict[str, Any] = Field(
-        default_factory=dict, description="Conditions for this cost"
-    )
-    cost_amount: int = Field(description="Cost amount in credits")
-
-
-class Block(BaseModel):
-    """A building block that can be used in graphs."""
-
-    id: str
-    name: str
-    description: str
-    categories: list[str] = Field(default_factory=list)
-    input_schema: dict[str, Any]
-    output_schema: dict[str, Any]
-    costs: list[BlockCost] = Field(default_factory=list)
-
-
-class BlocksListResponse(BaseModel):
-    """Response for listing blocks."""
-
-    blocks: list[Block]
-
-
-# ============================================================================
-# Marketplace Models
-# ============================================================================
-
-
-class MarketplaceAgent(BaseModel):
-    """An agent available in the marketplace."""
-
-    slug: str
-    agent_name: str
-    agent_image: str
-    creator: str
-    creator_avatar: str
-    sub_heading: str
-    description: str
-    runs: int = Field(default=0, description="Number of times this agent has been run")
-    rating: float = Field(default=0.0, description="Average rating")
-
-
-class MarketplaceAgentDetails(BaseModel):
-    """Detailed information about a marketplace agent."""
-
-    store_listing_version_id: str
-    slug: str
-    agent_name: str
-    agent_video: str
-    agent_output_demo: str
-    agent_image: list[str]
-    creator: str
-    creator_avatar: str
-    sub_heading: str
-    description: str
-    instructions: Optional[str] = None
-    categories: list[str]
-    runs: int
-    rating: float
-    versions: list[str]
-    agent_graph_versions: list[str]
-    agent_graph_id: str
-    last_updated: datetime
-    recommended_schedule_cron: Optional[str] = None
-
-
-class MarketplaceCreator(BaseModel):
-    """A creator on the marketplace."""
-
-    name: str
-    username: str
-    description: str
-    avatar_url: str
-    num_agents: int
-    agent_rating: float
-    agent_runs: int
-    is_featured: bool = False
-
-
-class MarketplaceAgentsResponse(PaginatedResponse):
-    """Response for listing marketplace agents."""
-
-    agents: list[MarketplaceAgent]
-
-
-class MarketplaceCreatorsResponse(PaginatedResponse):
-    """Response for listing marketplace creators."""
-
-    creators: list[MarketplaceCreator]
-
-
-# Submission models
-class MarketplaceSubmission(BaseModel):
-    """A marketplace submission."""
-
-    agent_id: str
-    agent_version: int
-    name: str
-    sub_heading: str
-    slug: str
-    description: str
-    instructions: Optional[str] = None
-    image_urls: list[str] = Field(default_factory=list)
-    date_submitted: datetime
-    status: str = Field(description="One of: DRAFT, PENDING, APPROVED, REJECTED")
-    runs: int
-    rating: float
-    store_listing_version_id: Optional[str] = None
-    version: Optional[int] = None
-
-    # Review fields
-    review_comments: Optional[str] = None
-    reviewed_at: Optional[datetime] = None
-
-    # Additional optional fields
-    video_url: Optional[str] = None
-    categories: list[str] = Field(default_factory=list)
-
-
-class CreateSubmissionRequest(BaseModel):
-    """Request to create a marketplace submission."""
-
-    agent_id: str = Field(description="ID of the graph to submit")
-    agent_version: int = Field(description="Version of the graph to submit")
-    name: str = Field(description="Display name for the agent")
-    slug: str = Field(description="URL-friendly identifier")
-    description: str = Field(description="Full description")
-    sub_heading: str = Field(description="Short tagline")
-    image_urls: list[str] = Field(default_factory=list)
-    video_url: Optional[str] = None
-    categories: list[str] = Field(default_factory=list)
-
-
-class UpdateSubmissionRequest(BaseModel):
-    """Request to update a marketplace submission."""
-
-    name: Optional[str] = None
-    description: Optional[str] = None
-    sub_heading: Optional[str] = None
-    image_urls: Optional[list[str]] = None
-    video_url: Optional[str] = None
-    categories: Optional[list[str]] = None
-
-
-class SubmissionsListResponse(PaginatedResponse):
-    """Response for listing submissions."""
-
-    submissions: list[MarketplaceSubmission]
-
-
-# ============================================================================
-# Library Models
-# ============================================================================
-
-
-class LibraryAgent(BaseModel):
-    """An agent in the user's library."""
-
-    id: str
-    graph_id: str
-    graph_version: int
-    name: str
-    description: str
-    is_favorite: bool = False
-    can_access_graph: bool = False
-    is_latest_version: bool = False
-    image_url: Optional[str] = None
-    creator_name: str
-    input_schema: dict[str, Any] = Field(description="Input schema for the agent")
-    output_schema: dict[str, Any] = Field(description="Output schema for the agent")
-    created_at: datetime
-    updated_at: datetime
-
-
-class LibraryAgentsResponse(PaginatedResponse):
-    """Response for listing library agents."""
-
-    agents: list[LibraryAgent]
-
-
-class ExecuteAgentRequest(BaseModel):
-    """Request to execute an agent."""
-
-    inputs: dict[str, Any] = Field(
-        default_factory=dict, description="Input values for the agent"
-    )
-    credentials_inputs: dict[str, Any] = Field(
-        default_factory=dict, description="Credentials for the agent"
-    )
-
-
-# ============================================================================
-# Run Models
-# ============================================================================
-
-
-class Run(BaseModel):
-    """An execution run."""
-
-    id: str
-    graph_id: str
-    graph_version: int
-    status: str = Field(
-        description="One of: INCOMPLETE, QUEUED, RUNNING, COMPLETED, TERMINATED, FAILED, REVIEW"
-    )
-    started_at: datetime
-    ended_at: Optional[datetime] = None
-    inputs: Optional[dict[str, Any]] = None
-    cost: int = Field(default=0, description="Cost in credits")
-    duration: float = Field(default=0, description="Duration in seconds")
-    node_count: int = Field(default=0, description="Number of nodes executed")
-
-
-class RunDetails(Run):
-    """Detailed information about a run including node executions."""
-
-    outputs: Optional[dict[str, list[Any]]] = None
-    node_executions: list[dict[str, Any]] = Field(
-        default_factory=list, description="Individual node execution results"
-    )
-
-
-class RunsListResponse(PaginatedResponse):
-    """Response for listing runs."""
-
-    runs: list[Run]
-
-
-# ============================================================================
-# Run Review Models (Human-in-the-loop)
-# ============================================================================
-
-
-class PendingReview(BaseModel):
-    """A pending human-in-the-loop review."""
-
-    id: str  # node_exec_id
-    run_id: str
-    graph_id: str
-    graph_version: int
-    payload: Any = Field(description="Data to be reviewed")
-    instructions: Optional[str] = Field(
-        default=None, description="Instructions for the reviewer"
-    )
-    editable: bool = Field(
-        default=True, description="Whether the reviewer can edit the data"
-    )
-    status: str = Field(description="One of: WAITING, APPROVED, REJECTED")
-    created_at: datetime
-
-
-class PendingReviewsResponse(PaginatedResponse):
-    """Response for listing pending reviews."""
-
-    reviews: list[PendingReview]
-
-
-class ReviewDecision(BaseModel):
-    """Decision for a single review item."""
-
-    node_exec_id: str = Field(description="Node execution ID (review ID)")
-    approved: bool = Field(description="Whether to approve the data")
-    edited_payload: Optional[Any] = Field(
-        default=None, description="Modified payload data (if editing)"
-    )
-    message: Optional[str] = Field(
-        default=None, description="Optional message from reviewer", max_length=2000
-    )
-
-
-class SubmitReviewsRequest(BaseModel):
-    """Request to submit review responses for all pending reviews of an execution."""
-
-    reviews: list[ReviewDecision] = Field(
-        description="All review decisions for the execution"
-    )
-
-
-class SubmitReviewsResponse(BaseModel):
-    """Response after submitting reviews."""
-
-    run_id: str
-    approved_count: int = Field(description="Number of reviews approved")
-    rejected_count: int = Field(description="Number of reviews rejected")
-
-
-# ============================================================================
-# Credit Models
-# ============================================================================
-
-
-class CreditBalance(BaseModel):
-    """User's credit balance."""
-
-    balance: int = Field(description="Current credit balance")
-
-
-class CreditTransaction(BaseModel):
-    """A credit transaction."""
-
-    transaction_key: str
-    amount: int
-    transaction_type: str = Field(description="Transaction type")
-    transaction_time: datetime
-    running_balance: int
-    description: Optional[str] = None
-
-
-class CreditTransactionsResponse(PaginatedResponse):
-    """Response for listing credit transactions."""
-
-    transactions: list[CreditTransaction]
-
-
-# ============================================================================
-# Integration Models
-# ============================================================================
-
-
-class Credential(BaseModel):
-    """A user's credential for an integration."""
-
-    id: str
-    provider: str = Field(description="Integration provider name")
-    title: Optional[str] = Field(
-        default=None, description="User-assigned title for this credential"
-    )
-    scopes: list[str] = Field(default_factory=list, description="Granted scopes")
-
-
-class CredentialsListResponse(BaseModel):
-    """Response for listing credentials."""
-
-    credentials: list[Credential]
-
-
-class CredentialRequirement(BaseModel):
-    """A credential requirement for a graph or agent."""
-
-    provider: str = Field(description="Required provider name")
-    required_scopes: list[str] = Field(
-        default_factory=list, description="Required scopes"
-    )
-    matching_credentials: list[Credential] = Field(
-        default_factory=list,
-        description="User's credentials that match this requirement",
-    )
-
-
-class CredentialRequirementsResponse(BaseModel):
-    """Response for listing credential requirements."""
-
-    requirements: list[CredentialRequirement]
-
-
-# ============================================================================
-# File Models
-# ============================================================================
-
-
-class UploadFileResponse(BaseModel):
-    """Response after uploading a file."""
-
-    file_uri: str = Field(description="URI to reference the uploaded file")
-    file_name: str
-    size: int = Field(description="File size in bytes")
-    content_type: str
-    expires_in_hours: int

autogpt_platform/backend/backend/api/external/v2/routes.py

@@ -1,35 +0,0 @@
-"""
-V2 External API Routes
-
-This module defines the main v2 router that aggregates all v2 API endpoints.
-"""
-
-from fastapi import APIRouter
-
-from .blocks import blocks_router
-from .credits import credits_router
-from .files import files_router
-from .graphs import graphs_router
-from .integrations import integrations_router
-from .library import library_router
-from .marketplace import marketplace_router
-from .runs import runs_router
-from .schedules import graph_schedules_router, schedules_router
-
-v2_router = APIRouter()
-
-# Include all sub-routers
-v2_router.include_router(graphs_router, prefix="/graphs", tags=["graphs"])
-v2_router.include_router(graph_schedules_router, prefix="/graphs", tags=["schedules"])
-v2_router.include_router(schedules_router, prefix="/schedules", tags=["schedules"])
-v2_router.include_router(blocks_router, prefix="/blocks", tags=["blocks"])
-v2_router.include_router(
-    marketplace_router, prefix="/marketplace", tags=["marketplace"]
-)
-v2_router.include_router(library_router, prefix="/library", tags=["library"])
-v2_router.include_router(runs_router, prefix="/runs", tags=["runs"])
-v2_router.include_router(credits_router, prefix="/credits", tags=["credits"])
-v2_router.include_router(
-    integrations_router, prefix="/integrations", tags=["integrations"]
-)
-v2_router.include_router(files_router, prefix="/files", tags=["files"])

autogpt_platform/backend/backend/api/external/v2/runs.py

@@ -1,451 +0,0 @@
-"""
-V2 External API - Runs Endpoints
-
-Provides access to execution runs and human-in-the-loop reviews.
-"""
-
-import logging
-from datetime import datetime
-from typing import Any, Optional
-
-from fastapi import APIRouter, HTTPException, Path, Query, Security
-from prisma.enums import APIKeyPermission, ReviewStatus
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.executions.review.model import (
-    PendingHumanReviewModel,
-    SafeJsonData,
-)
-from backend.data import execution as execution_db
-from backend.data import human_review as review_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.executor import utils as execution_utils
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-
-logger = logging.getLogger(__name__)
-
-runs_router = APIRouter()
-
-
-# ============================================================================
-# Models
-# ============================================================================
-
-
-class Run(BaseModel):
-    """An execution run."""
-
-    id: str
-    graph_id: str
-    graph_version: int
-    status: str = Field(
-        description="One of: INCOMPLETE, QUEUED, RUNNING, COMPLETED, TERMINATED, FAILED, REVIEW"
-    )
-    started_at: datetime
-    ended_at: Optional[datetime] = None
-    inputs: Optional[dict[str, Any]] = None
-    cost: int = Field(default=0, description="Cost in credits")
-    duration: float = Field(default=0, description="Duration in seconds")
-    node_count: int = Field(default=0, description="Number of nodes executed")
-
-
-class RunDetails(Run):
-    """Detailed information about a run including outputs and node executions."""
-
-    outputs: Optional[dict[str, list[Any]]] = None
-    node_executions: list[dict[str, Any]] = Field(
-        default_factory=list, description="Individual node execution results"
-    )
-
-
-class RunsListResponse(BaseModel):
-    """Response for listing runs."""
-
-    runs: list[Run]
-    total_count: int
-    page: int
-    page_size: int
-    total_pages: int
-
-
-class PendingReview(BaseModel):
-    """A pending human-in-the-loop review."""
-
-    id: str  # node_exec_id
-    run_id: str
-    graph_id: str
-    graph_version: int
-    payload: SafeJsonData = Field(description="Data to be reviewed")
-    instructions: Optional[str] = Field(
-        default=None, description="Instructions for the reviewer"
-    )
-    editable: bool = Field(
-        default=True, description="Whether the reviewer can edit the data"
-    )
-    status: str = Field(description="One of: WAITING, APPROVED, REJECTED")
-    created_at: datetime
-
-
-class PendingReviewsResponse(BaseModel):
-    """Response for listing pending reviews."""
-
-    reviews: list[PendingReview]
-    total_count: int
-    page: int
-    page_size: int
-    total_pages: int
-
-
-class ReviewDecision(BaseModel):
-    """Decision for a single review item."""
-
-    node_exec_id: str = Field(description="Node execution ID (review ID)")
-    approved: bool = Field(description="Whether to approve the data")
-    edited_payload: Optional[SafeJsonData] = Field(
-        default=None, description="Modified payload data (if editing)"
-    )
-    message: Optional[str] = Field(
-        default=None, description="Optional message from reviewer", max_length=2000
-    )
-
-
-class SubmitReviewsRequest(BaseModel):
-    """Request to submit review responses for all pending reviews of an execution."""
-
-    reviews: list[ReviewDecision] = Field(
-        description="All review decisions for the execution"
-    )
-
-
-class SubmitReviewsResponse(BaseModel):
-    """Response after submitting reviews."""
-
-    run_id: str
-    approved_count: int = Field(description="Number of reviews approved")
-    rejected_count: int = Field(description="Number of reviews rejected")
-
-
-# ============================================================================
-# Conversion Functions
-# ============================================================================
-
-
-def _convert_execution_to_run(exec: execution_db.GraphExecutionMeta) -> Run:
-    """Convert internal execution to v2 API Run model."""
-    return Run(
-        id=exec.id,
-        graph_id=exec.graph_id,
-        graph_version=exec.graph_version,
-        status=exec.status.value,
-        started_at=exec.started_at,
-        ended_at=exec.ended_at,
-        inputs=exec.inputs,
-        cost=exec.stats.cost if exec.stats else 0,
-        duration=exec.stats.duration if exec.stats else 0,
-        node_count=exec.stats.node_exec_count if exec.stats else 0,
-    )
-
-
-def _convert_execution_to_run_details(
-    exec: execution_db.GraphExecutionWithNodes,
-) -> RunDetails:
-    """Convert internal execution with nodes to v2 API RunDetails model."""
-    return RunDetails(
-        id=exec.id,
-        graph_id=exec.graph_id,
-        graph_version=exec.graph_version,
-        status=exec.status.value,
-        started_at=exec.started_at,
-        ended_at=exec.ended_at,
-        inputs=exec.inputs,
-        outputs=exec.outputs,
-        cost=exec.stats.cost if exec.stats else 0,
-        duration=exec.stats.duration if exec.stats else 0,
-        node_count=exec.stats.node_exec_count if exec.stats else 0,
-        node_executions=[
-            {
-                "node_id": node.node_id,
-                "status": node.status.value,
-                "input_data": node.input_data,
-                "output_data": node.output_data,
-                "started_at": node.start_time,
-                "ended_at": node.end_time,
-            }
-            for node in exec.node_executions
-        ],
-    )
-
-
-def _convert_pending_review(review: PendingHumanReviewModel) -> PendingReview:
-    """Convert internal PendingHumanReviewModel to v2 API PendingReview model."""
-    return PendingReview(
-        id=review.node_exec_id,
-        run_id=review.graph_exec_id,
-        graph_id=review.graph_id,
-        graph_version=review.graph_version,
-        payload=review.payload,
-        instructions=review.instructions,
-        editable=review.editable,
-        status=review.status.value,
-        created_at=review.created_at,
-    )
-
-
-# ============================================================================
-# Endpoints - Runs
-# ============================================================================
-
-
-@runs_router.get(
-    path="",
-    summary="List all runs",
-    response_model=RunsListResponse,
-)
-async def list_runs(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> RunsListResponse:
-    """
-    List all execution runs for the authenticated user.
-
-    Returns runs across all agents, sorted by most recent first.
-    """
-    result = await execution_db.get_graph_executions_paginated(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    return RunsListResponse(
-        runs=[_convert_execution_to_run(e) for e in result.executions],
-        total_count=result.pagination.total_items,
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@runs_router.get(
-    path="/{run_id}",
-    summary="Get run details",
-    response_model=RunDetails,
-)
-async def get_run(
-    run_id: str = Path(description="Run ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN)
-    ),
-) -> RunDetails:
-    """
-    Get detailed information about a specific run.
-
-    Includes outputs and individual node execution results.
-    """
-    result = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-        include_node_executions=True,
-    )
-
-    if not result:
-        raise HTTPException(status_code=404, detail=f"Run #{run_id} not found")
-
-    return _convert_execution_to_run_details(result)
-
-
-@runs_router.post(
-    path="/{run_id}/stop",
-    summary="Stop a run",
-)
-async def stop_run(
-    run_id: str = Path(description="Run ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_RUN)
-    ),
-) -> Run:
-    """
-    Stop a running execution.
-
-    Only runs in QUEUED or RUNNING status can be stopped.
-    """
-    # Verify the run exists and belongs to the user
-    exec = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-    )
-    if not exec:
-        raise HTTPException(status_code=404, detail=f"Run #{run_id} not found")
-
-    # Stop the execution
-    await execution_utils.stop_graph_execution(
-        graph_exec_id=run_id,
-        user_id=auth.user_id,
-    )
-
-    # Fetch updated execution
-    updated_exec = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-    )
-
-    if not updated_exec:
-        raise HTTPException(status_code=404, detail=f"Run #{run_id} not found")
-
-    return _convert_execution_to_run(updated_exec)
-
-
-@runs_router.delete(
-    path="/{run_id}",
-    summary="Delete a run",
-)
-async def delete_run(
-    run_id: str = Path(description="Run ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_RUN)
-    ),
-) -> None:
-    """
-    Delete an execution run.
-
-    This marks the run as deleted. The data may still be retained for
-    some time for recovery purposes.
-    """
-    await execution_db.delete_graph_execution(
-        graph_exec_id=run_id,
-        user_id=auth.user_id,
-    )
-
-
-# ============================================================================
-# Endpoints - Reviews (Human-in-the-loop)
-# ============================================================================
-
-
-@runs_router.get(
-    path="/reviews",
-    summary="List all pending reviews",
-    response_model=PendingReviewsResponse,
-)
-async def list_pending_reviews(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN_REVIEW)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> PendingReviewsResponse:
-    """
-    List all pending human-in-the-loop reviews.
-
-    These are blocks that require human approval or input before the
-    agent can continue execution.
-    """
-    reviews = await review_db.get_pending_reviews_for_user(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    # Note: get_pending_reviews_for_user returns list directly, not a paginated result
-    # We compute pagination info based on results
-    total_count = len(reviews)
-    total_pages = max(1, (total_count + page_size - 1) // page_size)
-
-    return PendingReviewsResponse(
-        reviews=[_convert_pending_review(r) for r in reviews],
-        total_count=total_count,
-        page=page,
-        page_size=page_size,
-        total_pages=total_pages,
-    )
-
-
-@runs_router.get(
-    path="/{run_id}/reviews",
-    summary="List reviews for a run",
-    response_model=list[PendingReview],
-)
-async def list_run_reviews(
-    run_id: str = Path(description="Run ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN_REVIEW)
-    ),
-) -> list[PendingReview]:
-    """
-    List all human-in-the-loop reviews for a specific run.
-    """
-    reviews = await review_db.get_pending_reviews_for_execution(
-        graph_exec_id=run_id,
-        user_id=auth.user_id,
-    )
-
-    return [_convert_pending_review(r) for r in reviews]
-
-
-@runs_router.post(
-    path="/{run_id}/reviews",
-    summary="Submit review responses for a run",
-    response_model=SubmitReviewsResponse,
-)
-async def submit_reviews(
-    request: SubmitReviewsRequest,
-    run_id: str = Path(description="Run ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_RUN_REVIEW)
-    ),
-) -> SubmitReviewsResponse:
-    """
-    Submit responses to all pending human-in-the-loop reviews for a run.
-
-    All pending reviews for the execution must be included. Approving
-    a review will allow the agent to continue; rejecting will terminate
-    execution at that point.
-    """
-    # Build review decisions dict for process_all_reviews_for_execution
-    review_decisions: dict[
-        str, tuple[ReviewStatus, SafeJsonData | None, str | None]
-    ] = {}
-
-    for decision in request.reviews:
-        status = ReviewStatus.APPROVED if decision.approved else ReviewStatus.REJECTED
-        review_decisions[decision.node_exec_id] = (
-            status,
-            decision.edited_payload,
-            decision.message,
-        )
-
-    try:
-        results = await review_db.process_all_reviews_for_execution(
-            user_id=auth.user_id,
-            review_decisions=review_decisions,
-        )
-
-        approved_count = sum(
-            1 for r in results.values() if r.status == ReviewStatus.APPROVED
-        )
-        rejected_count = sum(
-            1 for r in results.values() if r.status == ReviewStatus.REJECTED
-        )
-
-        return SubmitReviewsResponse(
-            run_id=run_id,
-            approved_count=approved_count,
-            rejected_count=rejected_count,
-        )
-
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))

autogpt_platform/backend/backend/api/external/v2/schedules.py

@@ -1,250 +0,0 @@
-"""
-V2 External API - Schedules Endpoints
-
-Provides endpoints for managing execution schedules.
-"""
-
-import logging
-from datetime import datetime
-from typing import Any, Optional
-
-from fastapi import APIRouter, HTTPException, Path, Query, Security
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.data import graph as graph_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.user import get_user_by_id
-from backend.executor import scheduler
-from backend.util.clients import get_scheduler_client
-from backend.util.timezone_utils import get_user_timezone_or_utc
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-
-logger = logging.getLogger(__name__)
-
-schedules_router = APIRouter()
-
-
-# ============================================================================
-# Request/Response Models
-# ============================================================================
-
-
-class Schedule(BaseModel):
-    """An execution schedule for a graph."""
-
-    id: str
-    name: str
-    graph_id: str
-    graph_version: int
-    cron: str = Field(description="Cron expression for the schedule")
-    input_data: dict[str, Any] = Field(
-        default_factory=dict, description="Input data for scheduled executions"
-    )
-    next_run_time: Optional[datetime] = Field(
-        default=None, description="Next scheduled run time"
-    )
-    is_enabled: bool = Field(default=True, description="Whether schedule is enabled")
-
-
-class SchedulesListResponse(BaseModel):
-    """Response for listing schedules."""
-
-    schedules: list[Schedule]
-    total_count: int
-    page: int
-    page_size: int
-    total_pages: int
-
-
-class CreateScheduleRequest(BaseModel):
-    """Request to create a schedule."""
-
-    name: str = Field(description="Display name for the schedule")
-    cron: str = Field(description="Cron expression (e.g., '0 9 * * *' for 9am daily)")
-    input_data: dict[str, Any] = Field(
-        default_factory=dict, description="Input data for scheduled executions"
-    )
-    credentials_inputs: dict[str, Any] = Field(
-        default_factory=dict, description="Credentials for the schedule"
-    )
-    graph_version: Optional[int] = Field(
-        default=None, description="Graph version (default: active version)"
-    )
-    timezone: Optional[str] = Field(
-        default=None,
-        description=(
-            "Timezone for schedule (e.g., 'America/New_York'). "
-            "Defaults to user's timezone."
-        ),
-    )
-
-
-def _convert_schedule(job: scheduler.GraphExecutionJobInfo) -> Schedule:
-    """Convert internal schedule job info to v2 API model."""
-    # Parse the ISO format string to datetime
-    next_run = datetime.fromisoformat(job.next_run_time) if job.next_run_time else None
-
-    return Schedule(
-        id=job.id,
-        name=job.name or "",
-        graph_id=job.graph_id,
-        graph_version=job.graph_version,
-        cron=job.cron,
-        input_data=job.input_data,
-        next_run_time=next_run,
-        is_enabled=True,  # All returned schedules are enabled
-    )
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@schedules_router.get(
-    path="",
-    summary="List all user schedules",
-    response_model=SchedulesListResponse,
-)
-async def list_all_schedules(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_SCHEDULE)
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-) -> SchedulesListResponse:
-    """
-    List all schedules for the authenticated user across all graphs.
-    """
-    schedules = await get_scheduler_client().get_execution_schedules(
-        user_id=auth.user_id
-    )
-    converted = [_convert_schedule(s) for s in schedules]
-
-    # Manual pagination (scheduler doesn't support pagination natively)
-    total_count = len(converted)
-    total_pages = (total_count + page_size - 1) // page_size if total_count > 0 else 1
-    start = (page - 1) * page_size
-    end = start + page_size
-    paginated = converted[start:end]
-
-    return SchedulesListResponse(
-        schedules=paginated,
-        total_count=total_count,
-        page=page,
-        page_size=page_size,
-        total_pages=total_pages,
-    )
-
-
-@schedules_router.delete(
-    path="/{schedule_id}",
-    summary="Delete a schedule",
-)
-async def delete_schedule(
-    schedule_id: str = Path(description="Schedule ID to delete"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_SCHEDULE)
-    ),
-) -> None:
-    """
-    Delete an execution schedule.
-    """
-    try:
-        await get_scheduler_client().delete_schedule(
-            schedule_id=schedule_id,
-            user_id=auth.user_id,
-        )
-    except Exception as e:
-        if "not found" in str(e).lower():
-            raise HTTPException(
-                status_code=404, detail=f"Schedule #{schedule_id} not found"
-            )
-        raise
-
-
-# ============================================================================
-# Graph-specific Schedule Endpoints (nested under /graphs)
-# These are included in the graphs router via include_router
-# ============================================================================
-
-graph_schedules_router = APIRouter()
-
-
-@graph_schedules_router.get(
-    path="/{graph_id}/schedules",
-    summary="List schedules for a graph",
-    response_model=list[Schedule],
-)
-async def list_graph_schedules(
-    graph_id: str = Path(description="Graph ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_SCHEDULE)
-    ),
-) -> list[Schedule]:
-    """
-    List all schedules for a specific graph.
-    """
-    schedules = await get_scheduler_client().get_execution_schedules(
-        user_id=auth.user_id,
-        graph_id=graph_id,
-    )
-    return [_convert_schedule(s) for s in schedules]
-
-
-@graph_schedules_router.post(
-    path="/{graph_id}/schedules",
-    summary="Create a schedule for a graph",
-    response_model=Schedule,
-)
-async def create_graph_schedule(
-    request: CreateScheduleRequest,
-    graph_id: str = Path(description="Graph ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_SCHEDULE)
-    ),
-) -> Schedule:
-    """
-    Create a new execution schedule for a graph.
-
-    The schedule will execute the graph at times matching the cron expression,
-    using the provided input data.
-    """
-    graph = await graph_db.get_graph(
-        graph_id=graph_id,
-        version=request.graph_version,
-        user_id=auth.user_id,
-    )
-    if not graph:
-        raise HTTPException(
-            status_code=404,
-            detail=f"Graph #{graph_id} v{request.graph_version} not found.",
-        )
-
-    # Determine timezone
-    if request.timezone:
-        user_timezone = request.timezone
-    else:
-        user = await get_user_by_id(auth.user_id)
-        user_timezone = get_user_timezone_or_utc(user.timezone if user else None)
-
-    result = await get_scheduler_client().add_execution_schedule(
-        user_id=auth.user_id,
-        graph_id=graph_id,
-        graph_version=graph.version,
-        name=request.name,
-        cron=request.cron,
-        input_data=request.input_data,
-        input_credentials=request.credentials_inputs,
-        user_timezone=user_timezone,
-    )
-
-    return _convert_schedule(result)

autogpt_platform/backend/backend/api/features/chat/config.py

@@ -1,6 +1,7 @@
 """Configuration management for chat system."""
 
 import os
+from pathlib import Path
 
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings
@@ -26,6 +27,12 @@ class ChatConfig(BaseSettings):
     # Session TTL Configuration - 12 hours
     session_ttl: int = Field(default=43200, description="Session TTL in seconds")
 
+    # System Prompt Configuration
+    system_prompt_path: str = Field(
+        default="prompts/chat_system.md",
+        description="Path to system prompt file relative to chat module",
+    )
+
     # Streaming Configuration
     max_context_messages: int = Field(
         default=50, ge=1, le=200, description="Maximum context messages"
@@ -38,13 +45,6 @@ class ChatConfig(BaseSettings):
         default=3, description="Maximum number of agent schedules"
     )
 
-    # Langfuse Prompt Management Configuration
-    # Note: Langfuse credentials are in Settings().secrets (settings.py)
-    langfuse_prompt_name: str = Field(
-        default="CoPilot Prompt",
-        description="Name of the prompt in Langfuse to fetch",
-    )
-
     @field_validator("api_key", mode="before")
     @classmethod
     def get_api_key(cls, v):
@@ -82,6 +82,73 @@ class ChatConfig(BaseSettings):
         "onboarding": "prompts/onboarding_system.md",
     }
 
+    def get_system_prompt_for_type(
+        self, prompt_type: str = "default", **template_vars
+    ) -> str:
+        """Load and render a system prompt by type.
+
+        Args:
+            prompt_type: The type of prompt to load ("default" or "onboarding")
+            **template_vars: Variables to substitute in the template
+
+        Returns:
+            Rendered system prompt string
+        """
+        prompt_path_str = self.PROMPT_PATHS.get(
+            prompt_type, self.PROMPT_PATHS["default"]
+        )
+        return self._load_prompt_from_path(prompt_path_str, **template_vars)
+
+    def get_system_prompt(self, **template_vars) -> str:
+        """Load and render the default system prompt from file.
+
+        Args:
+            **template_vars: Variables to substitute in the template
+
+        Returns:
+            Rendered system prompt string
+
+        """
+        return self._load_prompt_from_path(self.system_prompt_path, **template_vars)
+
+    def _load_prompt_from_path(self, prompt_path_str: str, **template_vars) -> str:
+        """Load and render a system prompt from a given path.
+
+        Args:
+            prompt_path_str: Path to the prompt file relative to chat module
+            **template_vars: Variables to substitute in the template
+
+        Returns:
+            Rendered system prompt string
+        """
+        # Get the path relative to this module
+        module_dir = Path(__file__).parent
+        prompt_path = module_dir / prompt_path_str
+
+        # Check for .j2 extension first (Jinja2 template)
+        j2_path = Path(str(prompt_path) + ".j2")
+        if j2_path.exists():
+            try:
+                from jinja2 import Template
+
+                template = Template(j2_path.read_text())
+                return template.render(**template_vars)
+            except ImportError:
+                # Jinja2 not installed, fall back to reading as plain text
+                return j2_path.read_text()
+
+        # Check for markdown file
+        if prompt_path.exists():
+            content = prompt_path.read_text()
+
+            # Simple variable substitution if Jinja2 is not available
+            for key, value in template_vars.items():
+                placeholder = f"{{{key}}}"
+                content = content.replace(placeholder, str(value))
+
+            return content
+        raise FileNotFoundError(f"System prompt file not found: {prompt_path}")
+
     class Config:
         """Pydantic config."""
 

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

@@ -1,6 +1,5 @@
 """Database operations for chat sessions."""
 
-import asyncio
 import logging
 from datetime import UTC, datetime
 from typing import Any, cast
@@ -11,10 +10,8 @@ from prisma.types import (
     ChatMessageCreateInput,
     ChatSessionCreateInput,
     ChatSessionUpdateInput,
-    ChatSessionWhereInput,
 )
 
-from backend.data.db import transaction
 from backend.util.json import SafeJson
 
 logger = logging.getLogger(__name__)
@@ -27,15 +24,14 @@ async def get_chat_session(session_id: str) -> PrismaChatSession | None:
         include={"Messages": True},
     )
     if session and session.Messages:
-        # Sort messages by sequence in Python - Prisma Python client doesn't support
-        # order_by in include clauses (unlike Prisma JS), so we sort after fetching
+        # Sort messages by sequence in Python since Prisma doesn't support order_by in include
         session.Messages.sort(key=lambda m: m.sequence)
     return session
 
 
 async def create_chat_session(
     session_id: str,
-    user_id: str,
+    user_id: str | None,
 ) -> PrismaChatSession:
     """Create a new chat session in the database."""
     data = ChatSessionCreateInput(
@@ -82,7 +78,6 @@ async def update_chat_session(
         include={"Messages": True},
     )
     if session and session.Messages:
-        # Sort in Python - Prisma Python doesn't support order_by in include clauses
         session.Messages.sort(key=lambda m: m.sequence)
     return session
 
@@ -99,9 +94,9 @@ async def add_chat_message(
     function_call: dict[str, Any] | None = None,
 ) -> PrismaChatMessage:
     """Add a message to a chat session."""
-    # Build input dict dynamically rather than using ChatMessageCreateInput directly
-    # because Prisma's TypedDict validation rejects optional fields set to None.
-    # We only include fields that have values, then cast at the end.
+    # Build the input dict dynamically - only include optional fields when they
+    # have values, as Prisma TypedDict validation fails when optional fields
+    # are explicitly set to None
     data: dict[str, Any] = {
         "Session": {"connect": {"id": session_id}},
         "role": role,
@@ -124,15 +119,15 @@ async def add_chat_message(
     if function_call is not None:
         data["functionCall"] = SafeJson(function_call)
 
-    # Run message create and session timestamp update in parallel for lower latency
-    _, message = await asyncio.gather(
-        PrismaChatSession.prisma().update(
-            where={"id": session_id},
-            data={"updatedAt": datetime.now(UTC)},
-        ),
-        PrismaChatMessage.prisma().create(data=cast(ChatMessageCreateInput, data)),
+    # Update session's updatedAt timestamp
+    await PrismaChatSession.prisma().update(
+        where={"id": session_id},
+        data={"updatedAt": datetime.now(UTC)},
+    )
+
+    return await PrismaChatMessage.prisma().create(
+        data=cast(ChatMessageCreateInput, data)
     )
-    return message
 
 
 async def add_chat_messages_batch(
@@ -140,55 +135,47 @@ async def add_chat_messages_batch(
     messages: list[dict[str, Any]],
     start_sequence: int,
 ) -> list[PrismaChatMessage]:
-    """Add multiple messages to a chat session in a batch.
-
-    Uses a transaction for atomicity - if any message creation fails,
-    the entire batch is rolled back.
-    """
+    """Add multiple messages to a chat session in a batch."""
     if not messages:
         return []
 
     created_messages = []
+    for i, msg in enumerate(messages):
+        # Build the input dict dynamically - only include optional JSON fields
+        # when they have values, as Prisma TypedDict validation fails when
+        # optional fields are explicitly set to None
+        data: dict[str, Any] = {
+            "Session": {"connect": {"id": session_id}},
+            "role": msg["role"],
+            "sequence": start_sequence + i,
+        }
 
-    async with transaction() as tx:
-        for i, msg in enumerate(messages):
-            # Build input dict dynamically rather than using ChatMessageCreateInput
-            # directly because Prisma's TypedDict validation rejects optional fields
-            # set to None. We only include fields that have values, then cast.
-            data: dict[str, Any] = {
-                "Session": {"connect": {"id": session_id}},
-                "role": msg["role"],
-                "sequence": start_sequence + i,
-            }
+        # Add optional string fields
+        if msg.get("content") is not None:
+            data["content"] = msg["content"]
+        if msg.get("name") is not None:
+            data["name"] = msg["name"]
+        if msg.get("tool_call_id") is not None:
+            data["toolCallId"] = msg["tool_call_id"]
+        if msg.get("refusal") is not None:
+            data["refusal"] = msg["refusal"]
 
-            # Add optional string fields
-            if msg.get("content") is not None:
-                data["content"] = msg["content"]
-            if msg.get("name") is not None:
-                data["name"] = msg["name"]
-            if msg.get("tool_call_id") is not None:
-                data["toolCallId"] = msg["tool_call_id"]
-            if msg.get("refusal") is not None:
-                data["refusal"] = msg["refusal"]
+        # Add optional JSON fields only when they have values
+        if msg.get("tool_calls") is not None:
+            data["toolCalls"] = SafeJson(msg["tool_calls"])
+        if msg.get("function_call") is not None:
+            data["functionCall"] = SafeJson(msg["function_call"])
 
-            # Add optional JSON fields only when they have values
-            if msg.get("tool_calls") is not None:
-                data["toolCalls"] = SafeJson(msg["tool_calls"])
-            if msg.get("function_call") is not None:
-                data["functionCall"] = SafeJson(msg["function_call"])
-
-            created = await PrismaChatMessage.prisma(tx).create(
-                data=cast(ChatMessageCreateInput, data)
-            )
-            created_messages.append(created)
-
-        # Update session's updatedAt timestamp within the same transaction.
-        # Note: Token usage (total_prompt_tokens, total_completion_tokens) is updated
-        # separately via update_chat_session() after streaming completes.
-        await PrismaChatSession.prisma(tx).update(
-            where={"id": session_id},
-            data={"updatedAt": datetime.now(UTC)},
+        created = await PrismaChatMessage.prisma().create(
+            data=cast(ChatMessageCreateInput, data)
         )
+        created_messages.append(created)
+
+    # Update session's updatedAt timestamp
+    await PrismaChatSession.prisma().update(
+        where={"id": session_id},
+        data={"updatedAt": datetime.now(UTC)},
+    )
 
     return created_messages
 
@@ -212,31 +199,10 @@ async def get_user_session_count(user_id: str) -> int:
     return await PrismaChatSession.prisma().count(where={"userId": user_id})
 
 
-async def delete_chat_session(session_id: str, user_id: str | None = None) -> bool:
-    """Delete a chat session and all its messages.
-
-    Args:
-        session_id: The session ID to delete.
-        user_id: If provided, validates that the session belongs to this user
-            before deletion. This prevents unauthorized deletion of other
-            users' sessions.
-
-    Returns:
-        True if deleted successfully, False otherwise.
-    """
+async def delete_chat_session(session_id: str) -> bool:
+    """Delete a chat session and all its messages."""
     try:
-        # Build typed where clause with optional user_id validation
-        where_clause: ChatSessionWhereInput = {"id": session_id}
-        if user_id is not None:
-            where_clause["userId"] = user_id
-
-        result = await PrismaChatSession.prisma().delete_many(where=where_clause)
-        if result == 0:
-            logger.warning(
-                f"No session deleted for {session_id} "
-                f"(user_id validation: {user_id is not None})"
-            )
-            return False
+        await PrismaChatSession.prisma().delete(where={"id": session_id})
         return True
     except Exception as e:
         logger.error(f"Failed to delete chat session {session_id}: {e}")

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

@@ -1,9 +1,6 @@
-import asyncio
 import logging
 import uuid
 from datetime import UTC, datetime
-from typing import Any
-from weakref import WeakValueDictionary
 
 from openai.types.chat import (
     ChatCompletionAssistantMessageParam,
@@ -25,7 +22,7 @@ from pydantic import BaseModel
 
 from backend.data.redis_client import get_redis_async
 from backend.util import json
-from backend.util.exceptions import DatabaseError, RedisError
+from backend.util.exceptions import RedisError
 
 from . import db as chat_db
 from .config import ChatConfig
@@ -34,48 +31,6 @@ logger = logging.getLogger(__name__)
 config = ChatConfig()
 
 
-def _parse_json_field(value: str | dict | list | None, default: Any = None) -> Any:
-    """Parse a JSON field that may be stored as string or already parsed."""
-    if value is None:
-        return default
-    if isinstance(value, str):
-        return json.loads(value)
-    return value
-
-
-# Redis cache key prefix for chat sessions
-CHAT_SESSION_CACHE_PREFIX = "chat:session:"
-
-
-def _get_session_cache_key(session_id: str) -> str:
-    """Get the Redis cache key for a chat session."""
-    return f"{CHAT_SESSION_CACHE_PREFIX}{session_id}"
-
-
-# Session-level locks to prevent race conditions during concurrent upserts.
-# Uses WeakValueDictionary to automatically garbage collect locks when no longer referenced,
-# preventing unbounded memory growth while maintaining lock semantics for active sessions.
-# Invalidation: Locks are auto-removed by GC when no coroutine holds a reference (after
-# async with lock: completes). Explicit cleanup also occurs in delete_chat_session().
-_session_locks: WeakValueDictionary[str, asyncio.Lock] = WeakValueDictionary()
-_session_locks_mutex = asyncio.Lock()
-
-
-async def _get_session_lock(session_id: str) -> asyncio.Lock:
-    """Get or create a lock for a specific session to prevent concurrent upserts.
-
-    Uses WeakValueDictionary for automatic cleanup: locks are garbage collected
-    when no coroutine holds a reference to them, preventing memory leaks from
-    unbounded growth of session locks.
-    """
-    async with _session_locks_mutex:
-        lock = _session_locks.get(session_id)
-        if lock is None:
-            lock = asyncio.Lock()
-            _session_locks[session_id] = lock
-        return lock
-
-
 class ChatMessage(BaseModel):
     role: str
     content: str | None = None
@@ -94,7 +49,7 @@ class Usage(BaseModel):
 
 class ChatSession(BaseModel):
     session_id: str
-    user_id: str
+    user_id: str | None
     title: str | None = None
     messages: list[ChatMessage]
     usage: list[Usage]
@@ -105,7 +60,7 @@ class ChatSession(BaseModel):
     successful_agent_schedules: dict[str, int] = {}
 
     @staticmethod
-    def new(user_id: str) -> "ChatSession":
+    def new(user_id: str | None) -> "ChatSession":
         return ChatSession(
             session_id=str(uuid.uuid4()),
             user_id=user_id,
@@ -118,7 +73,7 @@ class ChatSession(BaseModel):
         )
 
     @staticmethod
-    def from_db(
+    def from_prisma(
         prisma_session: PrismaChatSession,
         prisma_messages: list[PrismaChatMessage] | None = None,
     ) -> "ChatSession":
@@ -126,6 +81,22 @@ class ChatSession(BaseModel):
         messages = []
         if prisma_messages:
             for msg in prisma_messages:
+                tool_calls = None
+                if msg.toolCalls:
+                    tool_calls = (
+                        json.loads(msg.toolCalls)
+                        if isinstance(msg.toolCalls, str)
+                        else msg.toolCalls
+                    )
+
+                function_call = None
+                if msg.functionCall:
+                    function_call = (
+                        json.loads(msg.functionCall)
+                        if isinstance(msg.functionCall, str)
+                        else msg.functionCall
+                    )
+
                 messages.append(
                     ChatMessage(
                         role=msg.role,
@@ -133,18 +104,26 @@ class ChatSession(BaseModel):
                         name=msg.name,
                         tool_call_id=msg.toolCallId,
                         refusal=msg.refusal,
-                        tool_calls=_parse_json_field(msg.toolCalls),
-                        function_call=_parse_json_field(msg.functionCall),
+                        tool_calls=tool_calls,
+                        function_call=function_call,
                     )
                 )
 
         # Parse JSON fields from Prisma
-        credentials = _parse_json_field(prisma_session.credentials, default={})
-        successful_agent_runs = _parse_json_field(
-            prisma_session.successfulAgentRuns, default={}
+        credentials = (
+            json.loads(prisma_session.credentials)
+            if isinstance(prisma_session.credentials, str)
+            else prisma_session.credentials or {}
         )
-        successful_agent_schedules = _parse_json_field(
-            prisma_session.successfulAgentSchedules, default={}
+        successful_agent_runs = (
+            json.loads(prisma_session.successfulAgentRuns)
+            if isinstance(prisma_session.successfulAgentRuns, str)
+            else prisma_session.successfulAgentRuns or {}
+        )
+        successful_agent_schedules = (
+            json.loads(prisma_session.successfulAgentSchedules)
+            if isinstance(prisma_session.successfulAgentSchedules, str)
+            else prisma_session.successfulAgentSchedules or {}
         )
 
         # Calculate usage from token counts
@@ -263,7 +242,7 @@ class ChatSession(BaseModel):
 
 async def _get_session_from_cache(session_id: str) -> ChatSession | None:
     """Get a chat session from Redis cache."""
-    redis_key = _get_session_cache_key(session_id)
+    redis_key = f"chat:session:{session_id}"
     async_redis = await get_redis_async()
     raw_session: bytes | None = await async_redis.get(redis_key)
 
@@ -285,7 +264,7 @@ async def _get_session_from_cache(session_id: str) -> ChatSession | None:
 
 async def _cache_session(session: ChatSession) -> None:
     """Cache a chat session in Redis."""
-    redis_key = _get_session_cache_key(session.session_id)
+    redis_key = f"chat:session:{session.session_id}"
     async_redis = await get_redis_async()
     await async_redis.setex(redis_key, config.session_ttl, session.model_dump_json())
 
@@ -304,7 +283,7 @@ async def _get_session_from_db(session_id: str) -> ChatSession | None:
         f"roles={[m.role for m in messages] if messages else []}"
     )
 
-    return ChatSession.from_db(prisma_session, messages)
+    return ChatSession.from_prisma(prisma_session, messages)
 
 
 async def _save_session_to_db(
@@ -366,24 +345,19 @@ async def _save_session_to_db(
 
 async def get_chat_session(
     session_id: str,
-    user_id: str | None = None,
+    user_id: str | None,
 ) -> ChatSession | None:
     """Get a chat session by ID.
 
     Checks Redis cache first, falls back to database if not found.
     Caches database results back to Redis.
-
-    Args:
-        session_id: The session ID to fetch.
-        user_id: If provided, validates that the session belongs to this user.
-            If None, ownership is not validated (admin/system access).
     """
     # Try cache first
     try:
         session = await _get_session_from_cache(session_id)
         if session:
-            # Verify user ownership if user_id was provided for validation
-            if user_id is not None and session.user_id != user_id:
+            # Verify user ownership
+            if session.user_id is not None and session.user_id != user_id:
                 logger.warning(
                     f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
                 )
@@ -402,8 +376,8 @@ async def get_chat_session(
         logger.warning(f"Session {session_id} not found in cache or database")
         return None
 
-    # Verify user ownership if user_id was provided for validation
-    if user_id is not None and session.user_id != user_id:
+    # Verify user ownership
+    if session.user_id is not None and session.user_id != user_id:
         logger.warning(
             f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
         )
@@ -422,88 +396,49 @@ async def get_chat_session(
 async def upsert_chat_session(
     session: ChatSession,
 ) -> ChatSession:
-    """Update a chat session in both cache and database.
+    """Update a chat session in both cache and database."""
+    # Get existing message count from DB for incremental saves
+    existing_message_count = await chat_db.get_chat_session_message_count(
+        session.session_id
+    )
 
-    Uses session-level locking to prevent race conditions when concurrent
-    operations (e.g., background title update and main stream handler)
-    attempt to upsert the same session simultaneously.
+    # Save to database
+    try:
+        await _save_session_to_db(session, existing_message_count)
+    except Exception as e:
+        logger.error(f"Failed to save session {session.session_id} to database: {e}")
+        # Continue to cache even if DB fails
 
-    Raises:
-        DatabaseError: If the database write fails. The cache is still updated
-            as a best-effort optimization, but the error is propagated to ensure
-            callers are aware of the persistence failure.
-        RedisError: If the cache write fails (after successful DB write).
-    """
-    # Acquire session-specific lock to prevent concurrent upserts
-    lock = await _get_session_lock(session.session_id)
+    # Save to cache
+    try:
+        await _cache_session(session)
+    except Exception as e:
+        raise RedisError(
+            f"Failed to persist chat session {session.session_id} to Redis: {e}"
+        ) from e
 
-    async with lock:
-        # Get existing message count from DB for incremental saves
-        existing_message_count = await chat_db.get_chat_session_message_count(
-            session.session_id
-        )
-
-        db_error: Exception | None = None
-
-        # Save to database (primary storage)
-        try:
-            await _save_session_to_db(session, existing_message_count)
-        except Exception as e:
-            logger.error(
-                f"Failed to save session {session.session_id} to database: {e}"
-            )
-            db_error = e
-
-        # Save to cache (best-effort, even if DB failed)
-        try:
-            await _cache_session(session)
-        except Exception as e:
-            # If DB succeeded but cache failed, raise cache error
-            if db_error is None:
-                raise RedisError(
-                    f"Failed to persist chat session {session.session_id} to Redis: {e}"
-                ) from e
-            # If both failed, log cache error but raise DB error (more critical)
-            logger.warning(
-                f"Cache write also failed for session {session.session_id}: {e}"
-            )
-
-        # Propagate DB error after attempting cache (prevents data loss)
-        if db_error is not None:
-            raise DatabaseError(
-                f"Failed to persist chat session {session.session_id} to database"
-            ) from db_error
-
-        return session
+    return session
 
 
-async def create_chat_session(user_id: str) -> ChatSession:
-    """Create a new chat session and persist it.
-
-    Raises:
-        DatabaseError: If the database write fails. We fail fast to ensure
-            callers never receive a non-persisted session that only exists
-            in cache (which would be lost when the cache expires).
-    """
+async def create_chat_session(user_id: str | None) -> ChatSession:
+    """Create a new chat session and persist it."""
     session = ChatSession.new(user_id)
 
-    # Create in database first - fail fast if this fails
+    # Create in database first
     try:
         await chat_db.create_chat_session(
             session_id=session.session_id,
             user_id=user_id,
         )
     except Exception as e:
-        logger.error(f"Failed to create session {session.session_id} in database: {e}")
-        raise DatabaseError(
-            f"Failed to create chat session {session.session_id} in database"
-        ) from e
+        logger.error(f"Failed to create session in database: {e}")
+        # Continue even if DB fails - cache will still work
 
-    # Cache the session (best-effort optimization, DB is source of truth)
+    # Cache the session
     try:
         await _cache_session(session)
     except Exception as e:
-        logger.warning(f"Failed to cache new session {session.session_id}: {e}")
+        logger.warning(f"Failed to cache new session: {e}")
 
     return session
 
@@ -512,86 +447,27 @@ async def get_user_sessions(
     user_id: str,
     limit: int = 50,
     offset: int = 0,
-) -> tuple[list[ChatSession], int]:
-    """Get chat sessions for a user from the database with total count.
-
-    Returns:
-        A tuple of (sessions, total_count) where total_count is the overall
-        number of sessions for the user (not just the current page).
-    """
+) -> list[ChatSession]:
+    """Get all chat sessions for a user from the database."""
     prisma_sessions = await chat_db.get_user_chat_sessions(user_id, limit, offset)
-    total_count = await chat_db.get_user_session_count(user_id)
 
     sessions = []
     for prisma_session in prisma_sessions:
         # Convert without messages for listing (lighter weight)
-        sessions.append(ChatSession.from_db(prisma_session, None))
+        sessions.append(ChatSession.from_prisma(prisma_session, None))
 
-    return sessions, total_count
+    return sessions
 
 
-async def delete_chat_session(session_id: str, user_id: str | None = None) -> bool:
-    """Delete a chat session from both cache and database.
-
-    Args:
-        session_id: The session ID to delete.
-        user_id: If provided, validates that the session belongs to this user
-            before deletion. This prevents unauthorized deletion.
-
-    Returns:
-        True if deleted successfully, False otherwise.
-    """
-    # Delete from database first (with optional user_id validation)
-    # This confirms ownership before invalidating cache
-    deleted = await chat_db.delete_chat_session(session_id, user_id)
-
-    if not deleted:
-        return False
-
-    # Only invalidate cache and clean up lock after DB confirms deletion
+async def delete_chat_session(session_id: str) -> bool:
+    """Delete a chat session from both cache and database."""
+    # Delete from cache
     try:
-        redis_key = _get_session_cache_key(session_id)
+        redis_key = f"chat:session:{session_id}"
         async_redis = await get_redis_async()
         await async_redis.delete(redis_key)
     except Exception as e:
         logger.warning(f"Failed to delete session {session_id} from cache: {e}")
 
-    # Clean up session lock (belt-and-suspenders with WeakValueDictionary)
-    async with _session_locks_mutex:
-        _session_locks.pop(session_id, None)
-
-    return True
-
-
-async def update_session_title(session_id: str, title: str) -> bool:
-    """Update only the title of a chat session.
-
-    This is a lightweight operation that doesn't touch messages, avoiding
-    race conditions with concurrent message updates. Use this for background
-    title generation instead of upsert_chat_session.
-
-    Args:
-        session_id: The session ID to update.
-        title: The new title to set.
-
-    Returns:
-        True if updated successfully, False otherwise.
-    """
-    try:
-        result = await chat_db.update_chat_session(session_id=session_id, title=title)
-        if result is None:
-            logger.warning(f"Session {session_id} not found for title update")
-            return False
-
-        # Invalidate cache so next fetch gets updated title
-        try:
-            redis_key = _get_session_cache_key(session_id)
-            async_redis = await get_redis_async()
-            await async_redis.delete(redis_key)
-        except Exception as e:
-            logger.warning(f"Failed to invalidate cache for session {session_id}: {e}")
-
-        return True
-    except Exception as e:
-        logger.error(f"Failed to update title for session {session_id}: {e}")
-        return False
+    # Delete from database
+    return await chat_db.delete_chat_session(session_id)

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

@@ -43,9 +43,9 @@ async def test_chatsession_serialization_deserialization():
 
 
 @pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_redis_storage(setup_test_user, test_user_id):
+async def test_chatsession_redis_storage():
 
-    s = ChatSession.new(user_id=test_user_id)
+    s = ChatSession.new(user_id=None)
     s.messages = messages
 
     s = await upsert_chat_session(s)
@@ -59,26 +59,24 @@ async def test_chatsession_redis_storage(setup_test_user, test_user_id):
 
 
 @pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_redis_storage_user_id_mismatch(
-    setup_test_user, test_user_id
-):
+async def test_chatsession_redis_storage_user_id_mismatch():
 
-    s = ChatSession.new(user_id=test_user_id)
+    s = ChatSession.new(user_id="abc123")
     s.messages = messages
     s = await upsert_chat_session(s)
 
-    s2 = await get_chat_session(s.session_id, "different_user_id")
+    s2 = await get_chat_session(s.session_id, None)
 
     assert s2 is None
 
 
 @pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_db_storage(setup_test_user, test_user_id):
+async def test_chatsession_db_storage():
     """Test that messages are correctly saved to and loaded from DB (not cache)."""
     from backend.data.redis_client import get_redis_async
 
     # Create session with messages including assistant message
-    s = ChatSession.new(user_id=test_user_id)
+    s = ChatSession.new(user_id=None)
     s.messages = messages  # Contains user, assistant, and tool messages
     assert s.session_id is not None, "Session id is not set"
     # Upsert to save to both cache and DB

autogpt_platform/backend/backend/api/features/chat/prompts/chat_system.md

@@ -0,0 +1,192 @@
+You are Otto, an AI Co-Pilot and Forward Deployed Engineer for AutoGPT, an AI Business Automation tool. Your mission is to help users quickly find, create, and set up AutoGPT agents to solve their business problems.
+
+Here are the functions available to you:
+
+<functions>
+**Understanding & Discovery:**
+1. **add_understanding** - Save information about the user's business context (use this as you learn about them)
+2. **find_agent** - Search the marketplace for pre-built agents that solve the user's problem
+3. **find_library_agent** - Search the user's personal library of saved agents
+4. **find_block** - Search for individual blocks (building components for agents)
+5. **search_platform_docs** - Search AutoGPT documentation for help
+
+**Agent Creation & Editing:**
+6. **create_agent** - Create a new custom agent from scratch based on user requirements
+7. **edit_agent** - Modify an existing agent (add/remove blocks, change configuration)
+
+**Execution & Output:**
+8. **run_agent** - Run or schedule an agent (automatically handles setup)
+9. **run_block** - Run a single block directly without creating an agent
+10. **agent_output** - Get the output/results from a running or completed agent execution
+</functions>
+
+## ALWAYS GET THE USER'S NAME
+
+**This is critical:** If you don't know the user's name, ask for it in your first response. Use a friendly, natural approach:
+- "Hi! I'm Otto. What's your name?"
+- "Hey there! Before we dive in, what should I call you?"
+
+Once you have their name, immediately save it with `add_understanding(user_name="...")` and use it throughout the conversation.
+
+## BUILDING USER UNDERSTANDING
+
+**If no User Business Context is provided below**, gather information naturally during conversation - don't interrogate them.
+
+**Key information to gather (in priority order):**
+1. Their name (ALWAYS first if unknown)
+2. Their job title and role
+3. Their business/company and industry
+4. Pain points and what they want to automate
+5. Tools they currently use
+
+**How to gather this information:**
+- Ask naturally as part of helping them (e.g., "What's your role?" or "What industry are you in?")
+- When they share information, immediately save it using `add_understanding`
+- Don't ask all questions at once - spread them across the conversation
+- Prioritize understanding their immediate problem first
+
+**Example:**
+```
+User: "I need help automating my social media"
+Otto: I can help with that! I'm Otto - what's your name?
+User: "I'm Sarah"
+Otto: [calls add_understanding with user_name="Sarah"]
+Nice to meet you, Sarah! What's your role - are you a social media manager or business owner?
+User: "I'm the marketing director at a fintech startup"
+Otto: [calls add_understanding with job_title="Marketing Director", industry="fintech", business_size="startup"]
+Great! Let me find social media automation agents for you.
+[calls find_agent with query="social media automation marketing"]
+```
+
+## WHEN TO USE WHICH TOOL
+
+**Finding existing agents:**
+- `find_agent` - Search the marketplace for pre-built agents others have created
+- `find_library_agent` - Search agents the user has already saved to their library
+
+**Creating/editing agents:**
+- `create_agent` - When user wants a custom agent that doesn't exist, or has specific requirements
+- `edit_agent` - When user wants to modify an existing agent (change inputs, add blocks, etc.)
+
+**Running agents:**
+- `run_agent` - To execute an agent (handles credentials and inputs automatically)
+- `agent_output` - To check the results of a running or completed agent execution
+
+**Direct execution:**
+- `run_block` - Run a single block directly without needing a full agent
+
+## HOW run_agent WORKS
+
+The `run_agent` tool automatically handles the entire setup flow:
+
+1. **First call** (no inputs) → Returns available inputs so user can decide what values to use
+2. **Credentials check** → If missing, UI automatically prompts user to add them (you don't need to mention this)
+3. **Execution** → Runs when you provide `inputs` OR set `use_defaults=true`
+
+Parameters:
+- `username_agent_slug` (required): Agent identifier like "creator/agent-name"
+- `inputs`: Object with input values for the agent
+- `use_defaults`: Set to `true` to run with default values (only after user confirms)
+- `schedule_name` + `cron`: For scheduled execution
+
+## HOW create_agent WORKS
+
+Use `create_agent` when the user wants to build a custom automation:
+- Describe what the agent should do
+- The tool will create the agent structure with appropriate blocks
+- Returns the agent ID for further editing or running
+
+## HOW agent_output WORKS
+
+Use `agent_output` to get results from agent executions:
+- Pass the execution_id from a run_agent response
+- Returns the current status and any outputs produced
+- Useful for checking if an agent has completed and what it produced
+
+## WORKFLOW
+
+1. **Get their name** - If unknown, ask for it first
+2. **Understand context** - Ask 1-2 questions about their problem while helping
+3. **Find or create** - Use find_agent for existing solutions, create_agent for custom needs
+4. **Set up and run** - Use run_agent to execute, agent_output to get results
+
+## YOUR APPROACH
+
+**Step 1: Greet and Identify**
+- If you don't know their name, ask for it
+- Be friendly and conversational
+
+**Step 2: Understand the Problem**
+- Ask maximum 1-2 targeted questions
+- Focus on: What business problem are they solving?
+- If they want to create/edit an agent, understand what it should do
+
+**Step 3: Find or Create**
+- For existing solutions: Use `find_agent` with relevant keywords
+- For custom needs: Use `create_agent` with their requirements
+- For modifications: Use `edit_agent` on an existing agent
+
+**Step 4: Execute**
+- Call `run_agent` without inputs first to see what's available
+- Ask user what values they want or if defaults are okay
+- Call `run_agent` again with inputs or `use_defaults=true`
+- Use `agent_output` to check results when needed
+
+## USING add_understanding
+
+Call `add_understanding` whenever you learn something about the user:
+
+**User info:** `user_name`, `job_title`
+**Business:** `business_name`, `industry`, `business_size` (1-10, 11-50, 51-200, 201-1000, 1000+), `user_role` (decision maker, implementer, end user)
+**Processes:** `key_workflows` (array), `daily_activities` (array)
+**Pain points:** `pain_points` (array), `bottlenecks` (array), `manual_tasks` (array), `automation_goals` (array)
+**Tools:** `current_software` (array), `existing_automation` (array)
+**Other:** `additional_notes`
+
+Example: `add_understanding(user_name="Sarah", job_title="Marketing Director", industry="fintech")`
+
+## KEY RULES
+
+**What You DON'T Do:**
+- Don't help with login (frontend handles this)
+- Don't mention or explain credentials to the user (frontend handles this automatically)
+- Don't run agents without first showing available inputs to the user
+- Don't use `use_defaults=true` without user explicitly confirming
+- Don't write responses longer than 3 sentences
+- Don't interrogate users with many questions - gather info naturally
+
+**What You DO:**
+- ALWAYS ask for user's name if you don't have it
+- Save user information with `add_understanding` as you learn it
+- Use their name when addressing them
+- Always call run_agent first without inputs to see what's available
+- Ask user what values they want OR if they want to use defaults
+- Keep all responses to maximum 3 sentences
+- Include the agent link in your response after successful execution
+
+**Error Handling:**
+- Authentication needed → "Please sign in via the interface"
+- Credentials missing → The UI handles this automatically. Focus on asking the user about input values instead.
+
+## RESPONSE STRUCTURE
+
+Before responding, wrap your analysis in <thinking> tags to systematically plan your approach:
+- Check if you know the user's name - if not, ask for it
+- Check if you have user context - if not, plan to gather some naturally
+- Extract the key business problem or request from the user's message
+- Determine what function call (if any) you need to make next
+- Plan your response to stay under the 3-sentence maximum
+
+Example interaction:
+```
+User: "Hi, I want to build an agent that monitors my competitors"
+Otto: <thinking>I don't know this user's name. I should ask for it while acknowledging their request.</thinking>
+Hi! I'm Otto and I'd love to help you build a competitor monitoring agent. What's your name?
+User: "I'm Mike"
+Otto: [calls add_understanding with user_name="Mike"]
+<thinking>Now I know Mike wants competitor monitoring. I should search for existing agents first.</thinking>
+Great to meet you, Mike! Let me search for competitor monitoring agents.
+[calls find_agent with query="competitor monitoring analysis"]
+```
+
+KEEP ANSWERS TO 3 SENTENCES

autogpt_platform/backend/backend/api/features/chat/prompts/onboarding_system.md

@@ -0,0 +1,155 @@
+You are Otto, an AI Co-Pilot helping new users get started with AutoGPT, an AI Business Automation platform. Your mission is to welcome them, learn about their needs, and help them run their first successful agent.
+
+Here are the functions available to you:
+
+<functions>
+**Understanding & Discovery:**
+1. **add_understanding** - Save information about the user's business context (use this as you learn about them)
+2. **find_agent** - Search the marketplace for pre-built agents that solve the user's problem
+3. **find_library_agent** - Search the user's personal library of saved agents
+4. **find_block** - Search for individual blocks (building components for agents)
+5. **search_platform_docs** - Search AutoGPT documentation for help
+
+**Agent Creation & Editing:**
+6. **create_agent** - Create a new custom agent from scratch based on user requirements
+7. **edit_agent** - Modify an existing agent (add/remove blocks, change configuration)
+
+**Execution & Output:**
+8. **run_agent** - Run or schedule an agent (automatically handles setup)
+9. **run_block** - Run a single block directly without creating an agent
+10. **agent_output** - Get the output/results from a running or completed agent execution
+</functions>
+
+## YOUR ONBOARDING MISSION
+
+You are guiding a new user through their first experience with AutoGPT. Your goal is to:
+1. Welcome them warmly and get their name
+2. Learn about them and their business
+3. Find or create an agent that solves a real problem for them
+4. Get that agent running successfully
+5. Celebrate their success and point them to next steps
+
+## PHASE 1: WELCOME & INTRODUCTION
+
+**Start every conversation by:**
+- Giving a warm, friendly greeting
+- Introducing yourself as Otto, their AI assistant
+- Asking for their name immediately
+
+**Example opening:**
+```
+Hi! I'm Otto, your AI assistant. Welcome to AutoGPT! I'm here to help you set up your first automation. What's your name?
+```
+
+Once you have their name, save it immediately with `add_understanding(user_name="...")` and use it throughout.
+
+## PHASE 2: DISCOVERY
+
+**After getting their name, learn about them:**
+- What's their role/job title?
+- What industry/business are they in?
+- What's one thing they'd love to automate?
+
+**Keep it conversational - don't interrogate. Example:**
+```
+Nice to meet you, Sarah! What do you do for work, and what's one task you wish you could automate?
+```
+
+Save everything you learn with `add_understanding`.
+
+## PHASE 3: FIND OR CREATE AN AGENT
+
+**Once you understand their need:**
+- Search for existing agents with `find_agent`
+- Present the best match and explain how it helps them
+- If nothing fits, offer to create a custom agent with `create_agent`
+
+**Be enthusiastic about the solution:**
+```
+I found a great agent for you! The "Social Media Scheduler" can automatically post to your accounts on a schedule. Want to try it?
+```
+
+## PHASE 4: SETUP & RUN
+
+**Guide them through running the agent:**
+1. Call `run_agent` without inputs first to see what's needed
+2. Explain each input in simple terms
+3. Ask what values they want to use
+4. Run the agent with their inputs or defaults
+
+**Don't mention credentials** - the UI handles that automatically.
+
+## PHASE 5: CELEBRATE & HANDOFF
+
+**After successful execution:**
+- Congratulate them on their first automation!
+- Tell them where to find this agent (their Library)
+- Mention they can explore more agents in the Marketplace
+- Offer to help with anything else
+
+**Example:**
+```
+You did it! Your first agent is running. You can find it anytime in your Library. Ready to explore more automations?
+```
+
+## KEY RULES
+
+**What You DON'T Do:**
+- Don't help with login (frontend handles this)
+- Don't mention credentials (UI handles automatically)
+- Don't run agents without showing inputs first
+- Don't use `use_defaults=true` without explicit confirmation
+- Don't write responses longer than 3 sentences
+- Don't overwhelm with too many questions at once
+
+**What You DO:**
+- ALWAYS get the user's name first
+- Be warm, encouraging, and celebratory
+- Save info with `add_understanding` as you learn it
+- Use their name when addressing them
+- Keep responses to maximum 3 sentences
+- Make them feel successful at each step
+
+## USING add_understanding
+
+Save information as you learn it:
+
+**User info:** `user_name`, `job_title`
+**Business:** `business_name`, `industry`, `business_size`, `user_role`
+**Pain points:** `pain_points`, `manual_tasks`, `automation_goals`
+**Tools:** `current_software`
+
+Example: `add_understanding(user_name="Sarah", job_title="Marketing Manager", automation_goals=["social media scheduling"])`
+
+## HOW run_agent WORKS
+
+1. **First call** (no inputs) → Shows available inputs
+2. **Credentials** → UI handles automatically (don't mention)
+3. **Execution** → Run with `inputs={...}` or `use_defaults=true`
+
+## RESPONSE STRUCTURE
+
+Before responding, plan your approach in <thinking> tags:
+- What phase am I in? (Welcome/Discovery/Find/Setup/Celebrate)
+- Do I know their name? If not, ask for it
+- What's the next step to move them forward?
+- Keep response under 3 sentences
+
+**Example flow:**
+```
+User: "Hi"
+Otto: <thinking>Phase 1 - I need to welcome them and get their name.</thinking>
+Hi! I'm Otto, welcome to AutoGPT! I'm here to help you set up your first automation - what's your name?
+
+User: "I'm Alex"
+Otto: [calls add_understanding with user_name="Alex"]
+<thinking>Got their name. Phase 2 - learn about them.</thinking>
+Great to meet you, Alex! What do you do for work, and what's one task you'd love to automate?
+
+User: "I run an e-commerce store and spend hours on customer support emails"
+Otto: [calls add_understanding with industry="e-commerce", pain_points=["customer support emails"]]
+<thinking>Phase 3 - search for agents.</thinking>
+[calls find_agent with query="customer support email automation"]
+```
+
+KEEP ANSWERS TO 3 SENTENCES - Be warm, helpful, and focused on their success!

autogpt_platform/backend/backend/api/features/chat/response_model.py

@@ -1,10 +1,3 @@
-"""
-Response models for Vercel AI SDK UI Stream Protocol.
-
-This module implements the AI SDK UI Stream Protocol (v1) for streaming chat responses.
-See: https://ai-sdk.dev/docs/ai-sdk-ui/stream-protocol
-"""
-
 from enum import Enum
 from typing import Any
 
@@ -12,133 +5,97 @@ from pydantic import BaseModel, Field
 
 
 class ResponseType(str, Enum):
-    """Types of streaming responses following AI SDK protocol."""
+    """Types of streaming responses."""
 
-    # Message lifecycle
-    START = "start"
-    FINISH = "finish"
-
-    # Text streaming
-    TEXT_START = "text-start"
-    TEXT_DELTA = "text-delta"
-    TEXT_END = "text-end"
-
-    # Tool interaction
-    TOOL_INPUT_START = "tool-input-start"
-    TOOL_INPUT_AVAILABLE = "tool-input-available"
-    TOOL_OUTPUT_AVAILABLE = "tool-output-available"
-
-    # Other
+    TEXT_CHUNK = "text_chunk"
+    TEXT_ENDED = "text_ended"
+    TOOL_CALL = "tool_call"
+    TOOL_CALL_START = "tool_call_start"
+    TOOL_RESPONSE = "tool_response"
     ERROR = "error"
     USAGE = "usage"
+    STREAM_END = "stream_end"
 
 
 class StreamBaseResponse(BaseModel):
     """Base response model for all streaming responses."""
 
     type: ResponseType
+    timestamp: str | None = None
 
     def to_sse(self) -> str:
         """Convert to SSE format."""
         return f"data: {self.model_dump_json()}\n\n"
 
 
-# ========== Message Lifecycle ==========
+class StreamTextChunk(StreamBaseResponse):
+    """Streaming text content from the assistant."""
+
+    type: ResponseType = ResponseType.TEXT_CHUNK
+    content: str = Field(..., description="Text content chunk")
 
 
-class StreamStart(StreamBaseResponse):
-    """Start of a new message."""
-
-    type: ResponseType = ResponseType.START
-    messageId: str = Field(..., description="Unique message ID")
-
-
-class StreamFinish(StreamBaseResponse):
-    """End of message/stream."""
-
-    type: ResponseType = ResponseType.FINISH
-
-
-# ========== Text Streaming ==========
-
-
-class StreamTextStart(StreamBaseResponse):
-    """Start of a text block."""
-
-    type: ResponseType = ResponseType.TEXT_START
-    id: str = Field(..., description="Text block ID")
-
-
-class StreamTextDelta(StreamBaseResponse):
-    """Streaming text content delta."""
-
-    type: ResponseType = ResponseType.TEXT_DELTA
-    id: str = Field(..., description="Text block ID")
-    delta: str = Field(..., description="Text content delta")
-
-
-class StreamTextEnd(StreamBaseResponse):
-    """End of a text block."""
-
-    type: ResponseType = ResponseType.TEXT_END
-    id: str = Field(..., description="Text block ID")
-
-
-# ========== Tool Interaction ==========
-
-
-class StreamToolInputStart(StreamBaseResponse):
+class StreamToolCallStart(StreamBaseResponse):
     """Tool call started notification."""
 
-    type: ResponseType = ResponseType.TOOL_INPUT_START
-    toolCallId: str = Field(..., description="Unique tool call ID")
-    toolName: str = Field(..., description="Name of the tool being called")
+    type: ResponseType = ResponseType.TOOL_CALL_START
+    tool_name: str = Field(..., description="Name of the tool that was executed")
+    tool_id: str = Field(..., description="Unique tool call ID")
 
 
-class StreamToolInputAvailable(StreamBaseResponse):
-    """Tool input is ready for execution."""
+class StreamToolCall(StreamBaseResponse):
+    """Tool invocation notification."""
 
-    type: ResponseType = ResponseType.TOOL_INPUT_AVAILABLE
-    toolCallId: str = Field(..., description="Unique tool call ID")
-    toolName: str = Field(..., description="Name of the tool being called")
-    input: dict[str, Any] = Field(
-        default_factory=dict, description="Tool input arguments"
+    type: ResponseType = ResponseType.TOOL_CALL
+    tool_id: str = Field(..., description="Unique tool call ID")
+    tool_name: str = Field(..., description="Name of the tool being called")
+    arguments: dict[str, Any] = Field(
+        default_factory=dict, description="Tool arguments"
     )
 
 
-class StreamToolOutputAvailable(StreamBaseResponse):
+class StreamToolExecutionResult(StreamBaseResponse):
     """Tool execution result."""
 
-    type: ResponseType = ResponseType.TOOL_OUTPUT_AVAILABLE
-    toolCallId: str = Field(..., description="Tool call ID this responds to")
-    output: str | dict[str, Any] = Field(..., description="Tool execution output")
-    # Additional fields for internal use (not part of AI SDK spec but useful)
-    toolName: str | None = Field(
-        default=None, description="Name of the tool that was executed"
-    )
+    type: ResponseType = ResponseType.TOOL_RESPONSE
+    tool_id: str = Field(..., description="Tool call ID this responds to")
+    tool_name: str = Field(..., description="Name of the tool that was executed")
+    result: str | dict[str, Any] = Field(..., description="Tool execution result")
     success: bool = Field(
         default=True, description="Whether the tool execution succeeded"
     )
 
 
-# ========== Other ==========
-
-
 class StreamUsage(StreamBaseResponse):
     """Token usage statistics."""
 
     type: ResponseType = ResponseType.USAGE
-    promptTokens: int = Field(..., description="Number of prompt tokens")
-    completionTokens: int = Field(..., description="Number of completion tokens")
-    totalTokens: int = Field(..., description="Total number of tokens")
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
 
 
 class StreamError(StreamBaseResponse):
     """Error response."""
 
     type: ResponseType = ResponseType.ERROR
-    errorText: str = Field(..., description="Error message text")
+    message: str = Field(..., description="Error message")
     code: str | None = Field(default=None, description="Error code")
     details: dict[str, Any] | None = Field(
         default=None, description="Additional error details"
     )
+
+
+class StreamTextEnded(StreamBaseResponse):
+    """Text streaming completed marker."""
+
+    type: ResponseType = ResponseType.TEXT_ENDED
+
+
+class StreamEnd(StreamBaseResponse):
+    """End of stream marker."""
+
+    type: ResponseType = ResponseType.STREAM_END
+    summary: dict[str, Any] | None = Field(
+        default=None, description="Stream summary statistics"
+    )

autogpt_platform/backend/backend/api/features/chat/routes.py

@@ -13,25 +13,12 @@ from backend.util.exceptions import NotFoundError
 
 from . import service as chat_service
 from .config import ChatConfig
-from .model import ChatSession, create_chat_session, get_chat_session, get_user_sessions
 
 config = ChatConfig()
 
 
 logger = logging.getLogger(__name__)
 
-
-async def _validate_and_get_session(
-    session_id: str,
-    user_id: str | None,
-) -> ChatSession:
-    """Validate session exists and belongs to user."""
-    session = await get_chat_session(session_id, user_id)
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found.")
-    return session
-
-
 router = APIRouter(
     tags=["chat"],
 )
@@ -107,7 +94,7 @@ async def list_sessions(
     Returns:
         ListSessionsResponse: List of session summaries and total count.
     """
-    sessions, total_count = await get_user_sessions(user_id, limit, offset)
+    sessions = await chat_service.get_user_sessions(user_id, limit, offset)
 
     return ListSessionsResponse(
         sessions=[
@@ -115,11 +102,11 @@ async def list_sessions(
                 id=session.session_id,
                 created_at=session.started_at.isoformat(),
                 updated_at=session.updated_at.isoformat(),
-                title=session.title,
+                title=None,  # TODO: Add title support
             )
             for session in sessions
         ],
-        total=total_count,
+        total=len(sessions),
     )
 
 
@@ -127,15 +114,15 @@ async def list_sessions(
     "/sessions",
 )
 async def create_session(
-    user_id: Annotated[str, Depends(auth.get_user_id)],
+    user_id: Annotated[str | None, Depends(auth.get_user_id)],
 ) -> CreateSessionResponse:
     """
     Create a new chat session.
 
-    Initiates a new chat session for the authenticated user.
+    Initiates a new chat session for either an authenticated or anonymous user.
 
     Args:
-        user_id: The authenticated user ID parsed from the JWT (required).
+        user_id: The optional authenticated user ID parsed from the JWT. If missing, creates an anonymous session.
 
     Returns:
         CreateSessionResponse: Details of the created session.
@@ -143,15 +130,15 @@ async def create_session(
     """
     logger.info(
         f"Creating session with user_id: "
-        f"...{user_id[-8:] if len(user_id) > 8 else '<redacted>'}"
+        f"...{user_id[-8:] if user_id and len(user_id) > 8 else '<redacted>'}"
     )
 
-    session = await create_chat_session(user_id)
+    session = await chat_service.create_chat_session(user_id)
 
     return CreateSessionResponse(
         id=session.session_id,
         created_at=session.started_at.isoformat(),
-        user_id=session.user_id,
+        user_id=session.user_id or None,
     )
 
 
@@ -175,7 +162,7 @@ async def get_session(
         SessionDetailResponse: Details for the requested session; raises NotFoundError if not found.
 
     """
-    session = await get_chat_session(session_id, user_id)
+    session = await chat_service.get_session(session_id, user_id)
     if not session:
         raise NotFoundError(f"Session {session_id} not found")
 
@@ -219,7 +206,14 @@ async def stream_chat_post(
         StreamingResponse: SSE-formatted response chunks.
 
     """
-    session = await _validate_and_get_session(session_id, user_id)
+    # Validate session exists before starting the stream
+    # This prevents errors after the response has already started
+    session = await chat_service.get_session(session_id, user_id)
+
+    if not session:
+        raise NotFoundError(f"Session {session_id} not found. ")
+    if session.user_id is None and user_id is not None:
+        session = await chat_service.assign_user_to_session(session_id, user_id)
 
     async def event_generator() -> AsyncGenerator[str, None]:
         async for chunk in chat_service.stream_chat_completion(
@@ -231,8 +225,6 @@ async def stream_chat_post(
             context=request.context,
         ):
             yield chunk.to_sse()
-        # AI SDK protocol termination
-        yield "data: [DONE]\n\n"
 
     return StreamingResponse(
         event_generator(),
@@ -241,7 +233,6 @@ async def stream_chat_post(
             "Cache-Control": "no-cache",
             "Connection": "keep-alive",
             "X-Accel-Buffering": "no",  # Disable nginx buffering
-            "x-vercel-ai-ui-message-stream": "v1",  # AI SDK protocol header
         },
     )
 
@@ -272,7 +263,14 @@ async def stream_chat_get(
         StreamingResponse: SSE-formatted response chunks.
 
     """
-    session = await _validate_and_get_session(session_id, user_id)
+    # Validate session exists before starting the stream
+    # This prevents errors after the response has already started
+    session = await chat_service.get_session(session_id, user_id)
+
+    if not session:
+        raise NotFoundError(f"Session {session_id} not found. ")
+    if session.user_id is None and user_id is not None:
+        session = await chat_service.assign_user_to_session(session_id, user_id)
 
     async def event_generator() -> AsyncGenerator[str, None]:
         async for chunk in chat_service.stream_chat_completion(
@@ -283,8 +281,6 @@ async def stream_chat_get(
             session=session,  # Pass pre-fetched session to avoid double-fetch
         ):
             yield chunk.to_sse()
-        # AI SDK protocol termination
-        yield "data: [DONE]\n\n"
 
     return StreamingResponse(
         event_generator(),
@@ -293,7 +289,6 @@ async def stream_chat_get(
             "Cache-Control": "no-cache",
             "Connection": "keep-alive",
             "X-Accel-Buffering": "no",  # Disable nginx buffering
-            "x-vercel-ai-ui-message-stream": "v1",  # AI SDK protocol header
         },
     )
 
@@ -324,6 +319,133 @@ async def session_assign_user(
     return {"status": "ok"}
 
 
+# ========== Onboarding Routes ==========
+# These routes use a specialized onboarding system prompt
+
+
+@router.post(
+    "/onboarding/sessions",
+)
+async def create_onboarding_session(
+    user_id: Annotated[str | None, Depends(auth.get_user_id)],
+) -> CreateSessionResponse:
+    """
+    Create a new onboarding chat session.
+
+    Initiates a new chat session specifically for user onboarding,
+    using a specialized prompt that guides users through their first
+    experience with AutoGPT.
+
+    Args:
+        user_id: The optional authenticated user ID parsed from the JWT.
+
+    Returns:
+        CreateSessionResponse: Details of the created onboarding session.
+    """
+    logger.info(
+        f"Creating onboarding session with user_id: "
+        f"...{user_id[-8:] if user_id and len(user_id) > 8 else '<redacted>'}"
+    )
+
+    session = await chat_service.create_chat_session(user_id)
+
+    return CreateSessionResponse(
+        id=session.session_id,
+        created_at=session.started_at.isoformat(),
+        user_id=session.user_id or None,
+    )
+
+
+@router.get(
+    "/onboarding/sessions/{session_id}",
+)
+async def get_onboarding_session(
+    session_id: str,
+    user_id: Annotated[str | None, Depends(auth.get_user_id)],
+) -> SessionDetailResponse:
+    """
+    Retrieve the details of an onboarding chat session.
+
+    Args:
+        session_id: The unique identifier for the onboarding session.
+        user_id: The optional authenticated user ID.
+
+    Returns:
+        SessionDetailResponse: Details for the requested session.
+    """
+    session = await chat_service.get_session(session_id, user_id)
+    if not session:
+        raise NotFoundError(f"Session {session_id} not found")
+
+    messages = [message.model_dump() for message in session.messages]
+    logger.info(
+        f"Returning onboarding session {session_id}: "
+        f"message_count={len(messages)}, "
+        f"roles={[m.get('role') for m in messages]}"
+    )
+
+    return SessionDetailResponse(
+        id=session.session_id,
+        created_at=session.started_at.isoformat(),
+        updated_at=session.updated_at.isoformat(),
+        user_id=session.user_id or None,
+        messages=messages,
+    )
+
+
+@router.post(
+    "/onboarding/sessions/{session_id}/stream",
+)
+async def stream_onboarding_chat(
+    session_id: str,
+    request: StreamChatRequest,
+    user_id: str | None = Depends(auth.get_user_id),
+):
+    """
+    Stream onboarding chat responses for a session.
+
+    Uses the specialized onboarding system prompt to guide new users
+    through their first experience with AutoGPT. Streams AI responses
+    in real time over Server-Sent Events (SSE).
+
+    Args:
+        session_id: The onboarding session identifier.
+        request: Request body containing message and optional context.
+        user_id: Optional authenticated user ID.
+
+    Returns:
+        StreamingResponse: SSE-formatted response chunks.
+    """
+    session = await chat_service.get_session(session_id, user_id)
+
+    if not session:
+        raise NotFoundError(f"Session {session_id} not found.")
+    if session.user_id is None and user_id is not None:
+        session = await chat_service.assign_user_to_session(session_id, user_id)
+
+    async def event_generator() -> AsyncGenerator[str, None]:
+        async for chunk in chat_service.stream_chat_completion(
+            session_id,
+            request.message,
+            is_user_message=request.is_user_message,
+            user_id=user_id,
+            session=session,
+            context=request.context,
+            prompt_type="onboarding",  # Use onboarding system prompt
+        ):
+            yield chunk.to_sse()
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
 # ========== Health Check ==========
 
 
@@ -332,28 +454,16 @@ async def health_check() -> dict:
     """
     Health check endpoint for the chat service.
 
-    Performs a full cycle test of session creation and retrieval. Should always return healthy
+    Performs a full cycle test of session creation, assignment, and retrieval. Should always return healthy
     if the service and data layer are operational.
 
     Returns:
         dict: A status dictionary indicating health, service name, and API version.
 
     """
-    from backend.data.user import get_or_create_user
-
-    # Ensure health check user exists (required for FK constraint)
-    health_check_user_id = "health-check-user"
-    await get_or_create_user(
-        {
-            "sub": health_check_user_id,
-            "email": "health-check@system.local",
-            "user_metadata": {"name": "Health Check User"},
-        }
-    )
-
-    # Create and retrieve session to verify full data layer
-    session = await create_chat_session(health_check_user_id)
-    await get_chat_session(session.session_id, health_check_user_id)
+    session = await chat_service.create_chat_session(None)
+    await chat_service.assign_user_to_session(session.session_id, "test_user")
+    await chat_service.get_session(session.session_id, "test_user")
 
     return {
         "status": "healthy",

autogpt_platform/backend/backend/api/features/chat/service_test.py

@@ -4,19 +4,18 @@ from os import getenv
 import pytest
 
 from . import service as chat_service
-from .model import create_chat_session, get_chat_session, upsert_chat_session
 from .response_model import (
+    StreamEnd,
     StreamError,
-    StreamFinish,
-    StreamTextDelta,
-    StreamToolOutputAvailable,
+    StreamTextChunk,
+    StreamToolExecutionResult,
 )
 
 logger = logging.getLogger(__name__)
 
 
 @pytest.mark.asyncio(loop_scope="session")
-async def test_stream_chat_completion(setup_test_user, test_user_id):
+async def test_stream_chat_completion():
     """
     Test the stream_chat_completion function.
     """
@@ -24,7 +23,7 @@ async def test_stream_chat_completion(setup_test_user, test_user_id):
     if not api_key:
         return pytest.skip("OPEN_ROUTER_API_KEY is not set, skipping test")
 
-    session = await create_chat_session(test_user_id)
+    session = await chat_service.create_chat_session()
 
     has_errors = False
     has_ended = False
@@ -35,9 +34,9 @@ async def test_stream_chat_completion(setup_test_user, test_user_id):
         logger.info(chunk)
         if isinstance(chunk, StreamError):
             has_errors = True
-        if isinstance(chunk, StreamTextDelta):
-            assistant_message += chunk.delta
-        if isinstance(chunk, StreamFinish):
+        if isinstance(chunk, StreamTextChunk):
+            assistant_message += chunk.content
+        if isinstance(chunk, StreamEnd):
             has_ended = True
 
     assert has_ended, "Chat completion did not end"
@@ -46,7 +45,7 @@ async def test_stream_chat_completion(setup_test_user, test_user_id):
 
 
 @pytest.mark.asyncio(loop_scope="session")
-async def test_stream_chat_completion_with_tool_calls(setup_test_user, test_user_id):
+async def test_stream_chat_completion_with_tool_calls():
     """
     Test the stream_chat_completion function.
     """
@@ -54,8 +53,8 @@ async def test_stream_chat_completion_with_tool_calls(setup_test_user, test_user
     if not api_key:
         return pytest.skip("OPEN_ROUTER_API_KEY is not set, skipping test")
 
-    session = await create_chat_session(test_user_id)
-    session = await upsert_chat_session(session)
+    session = await chat_service.create_chat_session()
+    session = await chat_service.upsert_chat_session(session)
 
     has_errors = False
     has_ended = False
@@ -69,14 +68,14 @@ async def test_stream_chat_completion_with_tool_calls(setup_test_user, test_user
         if isinstance(chunk, StreamError):
             has_errors = True
 
-        if isinstance(chunk, StreamFinish):
+        if isinstance(chunk, StreamEnd):
             has_ended = True
-        if isinstance(chunk, StreamToolOutputAvailable):
+        if isinstance(chunk, StreamToolExecutionResult):
             had_tool_calls = True
 
     assert has_ended, "Chat completion did not end"
     assert not has_errors, "Error occurred while streaming chat completion"
     assert had_tool_calls, "Tool calls did not occur"
-    session = await get_chat_session(session.session_id)
+    session = await chat_service.get_session(session.session_id)
     assert session, "Session not found"
     assert session.usage, "Usage is empty"

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

@@ -12,24 +12,22 @@ from .find_library_agent import FindLibraryAgentTool
 from .run_agent import RunAgentTool
 
 if TYPE_CHECKING:
-    from backend.api.features.chat.response_model import StreamToolOutputAvailable
+    from backend.api.features.chat.response_model import StreamToolExecutionResult
 
-# Single source of truth for all tools
-TOOL_REGISTRY: dict[str, BaseTool] = {
-    "add_understanding": AddUnderstandingTool(),
-    "find_agent": FindAgentTool(),
-    "find_library_agent": FindLibraryAgentTool(),
-    "run_agent": RunAgentTool(),
-    "agent_output": AgentOutputTool(),
-}
+# Initialize tool instances
+add_understanding_tool = AddUnderstandingTool()
+find_agent_tool = FindAgentTool()
+find_library_agent_tool = FindLibraryAgentTool()
+run_agent_tool = RunAgentTool()
+agent_output_tool = AgentOutputTool()
 
-# Export individual tool instances for backwards compatibility
-find_agent_tool = TOOL_REGISTRY["find_agent"]
-run_agent_tool = TOOL_REGISTRY["run_agent"]
-
-# Generated from registry for OpenAI API
+# Export tools as OpenAI format
 tools: list[ChatCompletionToolParam] = [
-    tool.as_openai_tool() for tool in TOOL_REGISTRY.values()
+    add_understanding_tool.as_openai_tool(),
+    find_agent_tool.as_openai_tool(),
+    find_library_agent_tool.as_openai_tool(),
+    run_agent_tool.as_openai_tool(),
+    agent_output_tool.as_openai_tool(),
 ]
 
 
@@ -39,9 +37,17 @@ async def execute_tool(
     user_id: str | None,
     session: ChatSession,
     tool_call_id: str,
-) -> "StreamToolOutputAvailable":
-    """Execute a tool by name."""
-    tool = TOOL_REGISTRY.get(tool_name)
-    if not tool:
+) -> "StreamToolExecutionResult":
+
+    tool_map: dict[str, BaseTool] = {
+        "add_understanding": add_understanding_tool,
+        "find_agent": find_agent_tool,
+        "find_library_agent": find_library_agent_tool,
+        "run_agent": run_agent_tool,
+        "agent_output": agent_output_tool,
+    }
+    if tool_name not in tool_map:
         raise ValueError(f"Tool {tool_name} not found")
-    return await tool.execute(user_id, session, tool_call_id, **parameters)
+    return await tool_map[tool_name].execute(
+        user_id, session, tool_call_id, **parameters
+    )

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

@@ -18,7 +18,7 @@ from backend.data.user import get_or_create_user
 from backend.integrations.credentials_store import IntegrationCredentialsStore
 
 
-def make_session(user_id: str):
+def make_session(user_id: str | None = None):
     return ChatSession(
         session_id=str(uuid.uuid4()),
         user_id=user_id,

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

@@ -34,25 +34,80 @@ and automations for the user's specific needs."""
 
     @property
     def parameters(self) -> dict[str, Any]:
-        # Auto-generate from Pydantic model schema
-        schema = BusinessUnderstandingInput.model_json_schema()
-        properties = {}
-        for field_name, field_schema in schema.get("properties", {}).items():
-            prop: dict[str, Any] = {"description": field_schema.get("description", "")}
-            # Handle anyOf for Optional types
-            if "anyOf" in field_schema:
-                for option in field_schema["anyOf"]:
-                    if option.get("type") != "null":
-                        prop["type"] = option.get("type", "string")
-                        if "items" in option:
-                            prop["items"] = option["items"]
-                        break
-            else:
-                prop["type"] = field_schema.get("type", "string")
-                if "items" in field_schema:
-                    prop["items"] = field_schema["items"]
-            properties[field_name] = prop
-        return {"type": "object", "properties": properties, "required": []}
+        return {
+            "type": "object",
+            "properties": {
+                "user_name": {
+                    "type": "string",
+                    "description": "The user's name",
+                },
+                "job_title": {
+                    "type": "string",
+                    "description": "The user's job title (e.g., 'Marketing Manager', 'CEO', 'Software Engineer')",
+                },
+                "business_name": {
+                    "type": "string",
+                    "description": "Name of the user's business or organization",
+                },
+                "industry": {
+                    "type": "string",
+                    "description": "Industry or sector (e.g., 'e-commerce', 'healthcare', 'finance')",
+                },
+                "business_size": {
+                    "type": "string",
+                    "description": "Company size: '1-10', '11-50', '51-200', '201-1000', or '1000+'",
+                },
+                "user_role": {
+                    "type": "string",
+                    "description": "User's role in organization context (e.g., 'decision maker', 'implementer', 'end user')",
+                },
+                "key_workflows": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Key business workflows (e.g., 'lead qualification', 'content publishing')",
+                },
+                "daily_activities": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Regular daily activities the user performs",
+                },
+                "pain_points": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Current pain points or challenges",
+                },
+                "bottlenecks": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Process bottlenecks slowing things down",
+                },
+                "manual_tasks": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Manual or repetitive tasks that could be automated",
+                },
+                "automation_goals": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Desired automation outcomes or goals",
+                },
+                "current_software": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Software and tools currently in use",
+                },
+                "existing_automation": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Any existing automations or integrations",
+                },
+                "additional_notes": {
+                    "type": "string",
+                    "description": "Any other relevant context or notes",
+                },
+            },
+            "required": [],
+        }
 
     @property
     def requires_auth(self) -> bool:
@@ -87,26 +142,54 @@ and automations for the user's specific needs."""
                 session_id=session_id,
             )
 
-        # Build input model from kwargs (only include fields defined in the model)
-        valid_fields = set(BusinessUnderstandingInput.model_fields.keys())
+        # Build input model
         input_data = BusinessUnderstandingInput(
-            **{k: v for k, v in kwargs.items() if k in valid_fields}
+            user_name=kwargs.get("user_name"),
+            job_title=kwargs.get("job_title"),
+            business_name=kwargs.get("business_name"),
+            industry=kwargs.get("industry"),
+            business_size=kwargs.get("business_size"),
+            user_role=kwargs.get("user_role"),
+            key_workflows=kwargs.get("key_workflows"),
+            daily_activities=kwargs.get("daily_activities"),
+            pain_points=kwargs.get("pain_points"),
+            bottlenecks=kwargs.get("bottlenecks"),
+            manual_tasks=kwargs.get("manual_tasks"),
+            automation_goals=kwargs.get("automation_goals"),
+            current_software=kwargs.get("current_software"),
+            existing_automation=kwargs.get("existing_automation"),
+            additional_notes=kwargs.get("additional_notes"),
         )
 
         # Track which fields were updated
-        updated_fields = [
-            k for k, v in kwargs.items() if k in valid_fields and v is not None
-        ]
+        updated_fields = [k for k, v in kwargs.items() if v is not None]
 
         # Upsert with merge
         understanding = await upsert_business_understanding(user_id, input_data)
 
-        # Build current understanding summary (filter out empty values)
+        # Build current understanding summary for the response
+        current_understanding = {
+            "user_name": understanding.user_name,
+            "job_title": understanding.job_title,
+            "business_name": understanding.business_name,
+            "industry": understanding.industry,
+            "business_size": understanding.business_size,
+            "user_role": understanding.user_role,
+            "key_workflows": understanding.key_workflows,
+            "daily_activities": understanding.daily_activities,
+            "pain_points": understanding.pain_points,
+            "bottlenecks": understanding.bottlenecks,
+            "manual_tasks": understanding.manual_tasks,
+            "automation_goals": understanding.automation_goals,
+            "current_software": understanding.current_software,
+            "existing_automation": understanding.existing_automation,
+            "additional_notes": understanding.additional_notes,
+        }
+
+        # Filter out empty values for cleaner response
         current_understanding = {
             k: v
-            for k, v in understanding.model_dump(
-                exclude={"id", "user_id", "created_at", "updated_at"}
-            ).items()
+            for k, v in current_understanding.items()
             if v is not None and v != [] and v != ""
         }
 

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

@@ -55,47 +55,56 @@ def parse_time_expression(
     """
     Parse time expression into datetime range (start, end).
 
-    Supports: "latest", "yesterday", "today", "last week", "last 7 days",
-    "last month", "last 30 days", ISO date "YYYY-MM-DD", ISO datetime.
+    Supports:
+    - "latest" or None -> returns (None, None) to get most recent
+    - "yesterday" -> 24h window for yesterday
+    - "today" -> Today from midnight
+    - "last week" / "last 7 days" -> 7 day window
+    - "last month" / "last 30 days" -> 30 day window
+    - ISO date "YYYY-MM-DD" -> 24h window for that date
     """
     if not time_expr or time_expr.lower() == "latest":
         return None, None
 
     now = datetime.now(timezone.utc)
-    today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
     expr = time_expr.lower().strip()
 
-    # Relative time expressions lookup
-    relative_times: dict[str, tuple[datetime, datetime]] = {
-        "yesterday": (today_start - timedelta(days=1), today_start),
-        "today": (today_start, now),
-        "last week": (now - timedelta(days=7), now),
-        "last 7 days": (now - timedelta(days=7), now),
-        "last month": (now - timedelta(days=30), now),
-        "last 30 days": (now - timedelta(days=30), now),
-    }
-    if expr in relative_times:
-        return relative_times[expr]
+    # Relative expressions
+    if expr == "yesterday":
+        end = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        start = end - timedelta(days=1)
+        return start, end
+
+    if expr in ("last week", "last 7 days"):
+        return now - timedelta(days=7), now
+
+    if expr in ("last month", "last 30 days"):
+        return now - timedelta(days=30), now
+
+    if expr == "today":
+        start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        return start, now
 
     # Try ISO date format (YYYY-MM-DD)
     date_match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", expr)
     if date_match:
-        try:
-            year, month, day = map(int, date_match.groups())
-            start = datetime(year, month, day, 0, 0, 0, tzinfo=timezone.utc)
-            return start, start + timedelta(days=1)
-        except ValueError:
-            # Invalid date components (e.g., month=13, day=32)
-            pass
+        year, month, day = map(int, date_match.groups())
+        start = datetime(year, month, day, 0, 0, 0, tzinfo=timezone.utc)
+        end = start + timedelta(days=1)
+        return start, end
 
     # Try ISO datetime
     try:
         parsed = datetime.fromisoformat(expr.replace("Z", "+00:00"))
         if parsed.tzinfo is None:
             parsed = parsed.replace(tzinfo=timezone.utc)
+        # Return +/- 1 hour window around the specified time
         return parsed - timedelta(hours=1), parsed + timedelta(hours=1)
     except ValueError:
-        return None, None
+        pass
+
+    # Fallback: treat as "latest"
+    return None, None
 
 
 class AgentOutputTool(BaseTool):

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

@@ -1,151 +0,0 @@
-"""Shared agent search functionality for find_agent and find_library_agent tools."""
-
-import logging
-from typing import Literal
-
-from backend.api.features.library import db as library_db
-from backend.api.features.store import db as store_db
-from backend.util.exceptions import DatabaseError, NotFoundError
-
-from .models import (
-    AgentInfo,
-    AgentsFoundResponse,
-    ErrorResponse,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-
-logger = logging.getLogger(__name__)
-
-SearchSource = Literal["marketplace", "library"]
-
-
-async def search_agents(
-    query: str,
-    source: SearchSource,
-    session_id: str | None,
-    user_id: str | None = None,
-) -> ToolResponseBase:
-    """
-    Search for agents in marketplace or user library.
-
-    Args:
-        query: Search query string
-        source: "marketplace" or "library"
-        session_id: Chat session ID
-        user_id: User ID (required for library search)
-
-    Returns:
-        AgentsFoundResponse, NoResultsResponse, or ErrorResponse
-    """
-    if not query:
-        return ErrorResponse(
-            message="Please provide a search query", session_id=session_id
-        )
-
-    if source == "library" and not user_id:
-        return ErrorResponse(
-            message="User authentication required to search library",
-            session_id=session_id,
-        )
-
-    agents: list[AgentInfo] = []
-    try:
-        if source == "marketplace":
-            logger.info(f"Searching marketplace for: {query}")
-            results = await store_db.get_store_agents(search_query=query, page_size=5)
-            for agent in results.agents:
-                agents.append(
-                    AgentInfo(
-                        id=f"{agent.creator}/{agent.slug}",
-                        name=agent.agent_name,
-                        description=agent.description or "",
-                        source="marketplace",
-                        in_library=False,
-                        creator=agent.creator,
-                        category="general",
-                        rating=agent.rating,
-                        runs=agent.runs,
-                        is_featured=False,
-                    )
-                )
-        else:  # library
-            logger.info(f"Searching user library for: {query}")
-            results = await library_db.list_library_agents(
-                user_id=user_id,  # type: ignore[arg-type]
-                search_term=query,
-                page_size=10,
-            )
-            for agent in results.agents:
-                agents.append(
-                    AgentInfo(
-                        id=agent.id,
-                        name=agent.name,
-                        description=agent.description or "",
-                        source="library",
-                        in_library=True,
-                        creator=agent.creator_name,
-                        status=agent.status.value,
-                        can_access_graph=agent.can_access_graph,
-                        has_external_trigger=agent.has_external_trigger,
-                        new_output=agent.new_output,
-                        graph_id=agent.graph_id,
-                    )
-                )
-        logger.info(f"Found {len(agents)} agents in {source}")
-    except NotFoundError:
-        pass
-    except DatabaseError as e:
-        logger.error(f"Error searching {source}: {e}", exc_info=True)
-        return ErrorResponse(
-            message=f"Failed to search {source}. Please try again.",
-            error=str(e),
-            session_id=session_id,
-        )
-
-    if not agents:
-        suggestions = (
-            [
-                "Try more general terms",
-                "Browse categories in the marketplace",
-                "Check spelling",
-            ]
-            if source == "marketplace"
-            else [
-                "Try different keywords",
-                "Use find_agent to search the marketplace",
-                "Check your library at /library",
-            ]
-        )
-        no_results_msg = (
-            f"No agents found matching '{query}'. Try different keywords or browse the marketplace."
-            if source == "marketplace"
-            else f"No agents matching '{query}' found in your library."
-        )
-        return NoResultsResponse(
-            message=no_results_msg, session_id=session_id, suggestions=suggestions
-        )
-
-    title = f"Found {len(agents)} agent{'s' if len(agents) != 1 else ''} "
-    title += (
-        f"for '{query}'"
-        if source == "marketplace"
-        else f"in your library for '{query}'"
-    )
-
-    message = (
-        "Now you have found some options for the user to choose from. "
-        "You can add a link to a recommended agent at: /marketplace/agent/agent_id "
-        "Please ask the user if they would like to use any of these agents."
-        if source == "marketplace"
-        else "Found agents in the user's library. You can provide a link to view an agent at: "
-        "/library/agents/{agent_id}. Use agent_output to get execution results, or run_agent to execute."
-    )
-
-    return AgentsFoundResponse(
-        message=message,
-        title=title,
-        agents=agents,
-        count=len(agents),
-        session_id=session_id,
-    )

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

@@ -6,7 +6,7 @@ from typing import Any
 from openai.types.chat import ChatCompletionToolParam
 
 from backend.api.features.chat.model import ChatSession
-from backend.api.features.chat.response_model import StreamToolOutputAvailable
+from backend.api.features.chat.response_model import StreamToolExecutionResult
 
 from .models import ErrorResponse, NeedLoginResponse, ToolResponseBase
 
@@ -53,7 +53,7 @@ class BaseTool:
         session: ChatSession,
         tool_call_id: str,
         **kwargs,
-    ) -> StreamToolOutputAvailable:
+    ) -> StreamToolExecutionResult:
         """Execute the tool with authentication check.
 
         Args:
@@ -69,10 +69,10 @@ class BaseTool:
             logger.error(
                 f"Attempted tool call for {self.name} but user not authenticated"
             )
-            return StreamToolOutputAvailable(
-                toolCallId=tool_call_id,
-                toolName=self.name,
-                output=NeedLoginResponse(
+            return StreamToolExecutionResult(
+                tool_id=tool_call_id,
+                tool_name=self.name,
+                result=NeedLoginResponse(
                     message=f"Please sign in to use {self.name}",
                     session_id=session.session_id,
                 ).model_dump_json(),
@@ -81,17 +81,17 @@ class BaseTool:
 
         try:
             result = await self._execute(user_id, session, **kwargs)
-            return StreamToolOutputAvailable(
-                toolCallId=tool_call_id,
-                toolName=self.name,
-                output=result.model_dump_json(),
+            return StreamToolExecutionResult(
+                tool_id=tool_call_id,
+                tool_name=self.name,
+                result=result.model_dump_json(),
             )
         except Exception as e:
             logger.error(f"Error in {self.name}: {e}", exc_info=True)
-            return StreamToolOutputAvailable(
-                toolCallId=tool_call_id,
-                toolName=self.name,
-                output=ErrorResponse(
+            return StreamToolExecutionResult(
+                tool_id=tool_call_id,
+                tool_name=self.name,
+                result=ErrorResponse(
                     message=f"An error occurred while executing {self.name}",
                     error=str(e),
                     session_id=session.session_id,

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

@@ -1,16 +1,26 @@
-"""Tool for discovering agents from marketplace."""
+"""Tool for discovering agents from marketplace and user library."""
 
+import logging
 from typing import Any
 
 from backend.api.features.chat.model import ChatSession
+from backend.api.features.store import db as store_db
+from backend.util.exceptions import DatabaseError, NotFoundError
 
-from .agent_search import search_agents
 from .base import BaseTool
-from .models import ToolResponseBase
+from .models import (
+    AgentCarouselResponse,
+    AgentInfo,
+    ErrorResponse,
+    NoResultsResponse,
+    ToolResponseBase,
+)
+
+logger = logging.getLogger(__name__)
 
 
 class FindAgentTool(BaseTool):
-    """Tool for discovering agents from the marketplace."""
+    """Tool for discovering agents based on user needs."""
 
     @property
     def name(self) -> str:
@@ -36,11 +46,84 @@ class FindAgentTool(BaseTool):
         }
 
     async def _execute(
-        self, user_id: str | None, session: ChatSession, **kwargs
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        **kwargs,
     ) -> ToolResponseBase:
-        return await search_agents(
-            query=kwargs.get("query", "").strip(),
-            source="marketplace",
-            session_id=session.session_id,
-            user_id=user_id,
+        """Search for agents in the marketplace.
+
+        Args:
+            user_id: User ID (may be anonymous)
+            session_id: Chat session ID
+            query: Search query
+
+        Returns:
+            AgentCarouselResponse: List of agents found in the marketplace
+            NoResultsResponse: No agents found in the marketplace
+            ErrorResponse: Error message
+        """
+        query = kwargs.get("query", "").strip()
+        session_id = session.session_id
+        if not query:
+            return ErrorResponse(
+                message="Please provide a search query",
+                session_id=session_id,
+            )
+        agents = []
+        try:
+            logger.info(f"Searching marketplace for: {query}")
+            store_results = await store_db.get_store_agents(
+                search_query=query,
+                page_size=5,
+            )
+
+            logger.info(f"Find agents tool found {len(store_results.agents)} agents")
+            for agent in store_results.agents:
+                agent_id = f"{agent.creator}/{agent.slug}"
+                logger.info(f"Building agent ID = {agent_id}")
+                agents.append(
+                    AgentInfo(
+                        id=agent_id,
+                        name=agent.agent_name,
+                        description=agent.description or "",
+                        source="marketplace",
+                        in_library=False,
+                        creator=agent.creator,
+                        category="general",
+                        rating=agent.rating,
+                        runs=agent.runs,
+                        is_featured=False,
+                    ),
+                )
+        except NotFoundError:
+            pass
+        except DatabaseError as e:
+            logger.error(f"Error searching agents: {e}", exc_info=True)
+            return ErrorResponse(
+                message="Failed to search for agents. Please try again.",
+                error=str(e),
+                session_id=session_id,
+            )
+        if not agents:
+            return NoResultsResponse(
+                message=f"No agents found matching '{query}'. Try different keywords or browse the marketplace. If you have 3 consecutive find_agent tool calls results and found no agents. Please stop trying and ask the user if there is anything else you can help with.",
+                session_id=session_id,
+                suggestions=[
+                    "Try more general terms",
+                    "Browse categories in the marketplace",
+                    "Check spelling",
+                ],
+            )
+
+        # Return formatted carousel
+        title = (
+            f"Found {len(agents)} agent{'s' if len(agents) != 1 else ''} for '{query}'"
+        )
+        return AgentCarouselResponse(
+            message="Now you have found some options for the user to choose from. You can add a link to a recommended agent at: /marketplace/agent/agent_id Please ask the user if they would like to use any of these agents. If they do, please call the get_agent_details tool for this agent.",
+            title=title,
+            agents=agents,
+            count=len(agents),
+            session_id=session_id,
         )

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

@@ -1,12 +1,22 @@
 """Tool for searching agents in the user's library."""
 
+import logging
 from typing import Any
 
 from backend.api.features.chat.model import ChatSession
+from backend.api.features.library import db as library_db
+from backend.util.exceptions import DatabaseError
 
-from .agent_search import search_agents
 from .base import BaseTool
-from .models import ToolResponseBase
+from .models import (
+    AgentCarouselResponse,
+    AgentInfo,
+    ErrorResponse,
+    NoResultsResponse,
+    ToolResponseBase,
+)
+
+logger = logging.getLogger(__name__)
 
 
 class FindLibraryAgentTool(BaseTool):
@@ -31,7 +41,10 @@ class FindLibraryAgentTool(BaseTool):
             "properties": {
                 "query": {
                     "type": "string",
-                    "description": "Search query to find agents by name or description.",
+                    "description": (
+                        "Search query to find agents by name or description. "
+                        "Use keywords for best results."
+                    ),
                 },
             },
             "required": ["query"],
@@ -42,11 +55,103 @@ class FindLibraryAgentTool(BaseTool):
         return True
 
     async def _execute(
-        self, user_id: str | None, session: ChatSession, **kwargs
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        **kwargs,
     ) -> ToolResponseBase:
-        return await search_agents(
-            query=kwargs.get("query", "").strip(),
-            source="library",
-            session_id=session.session_id,
-            user_id=user_id,
+        """Search for agents in the user's library.
+
+        Args:
+            user_id: User ID (required)
+            session: Chat session
+            query: Search query
+
+        Returns:
+            AgentCarouselResponse: List of agents found in the library
+            NoResultsResponse: No agents found
+            ErrorResponse: Error message
+        """
+        query = kwargs.get("query", "").strip()
+        session_id = session.session_id
+
+        if not query:
+            return ErrorResponse(
+                message="Please provide a search query",
+                session_id=session_id,
+            )
+
+        if not user_id:
+            return ErrorResponse(
+                message="User authentication required to search library",
+                session_id=session_id,
+            )
+
+        agents = []
+        try:
+            logger.info(f"Searching user library for: {query}")
+            library_results = await library_db.list_library_agents(
+                user_id=user_id,
+                search_term=query,
+                page_size=10,
+            )
+
+            logger.info(
+                f"Find library agents tool found {len(library_results.agents)} agents"
+            )
+
+            for agent in library_results.agents:
+                agents.append(
+                    AgentInfo(
+                        id=agent.id,
+                        name=agent.name,
+                        description=agent.description or "",
+                        source="library",
+                        in_library=True,
+                        creator=agent.creator_name,
+                        status=agent.status.value,
+                        can_access_graph=agent.can_access_graph,
+                        has_external_trigger=agent.has_external_trigger,
+                        new_output=agent.new_output,
+                        graph_id=agent.graph_id,
+                    ),
+                )
+
+        except DatabaseError as e:
+            logger.error(f"Error searching library agents: {e}", exc_info=True)
+            return ErrorResponse(
+                message="Failed to search library. Please try again.",
+                error=str(e),
+                session_id=session_id,
+            )
+
+        if not agents:
+            return NoResultsResponse(
+                message=(
+                    f"No agents found matching '{query}' in your library. "
+                    "Try different keywords or use find_agent to search the marketplace."
+                ),
+                session_id=session_id,
+                suggestions=[
+                    "Try more general terms",
+                    "Use find_agent to search the marketplace",
+                    "Check your library at /library",
+                ],
+            )
+
+        title = (
+            f"Found {len(agents)} agent{'s' if len(agents) != 1 else ''} "
+            f"in your library for '{query}'"
+        )
+
+        return AgentCarouselResponse(
+            message=(
+                "Found agents in the user's library. You can provide a link to "
+                "view an agent at: /library/agents/{agent_id}. "
+                "Use agent_output to get execution results, or run_agent to execute."
+            ),
+            title=title,
+            agents=agents,
+            count=len(agents),
+            session_id=session_id,
         )

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

@@ -12,15 +12,23 @@ from backend.data.model import CredentialsMetaInput
 class ResponseType(str, Enum):
     """Types of tool responses."""
 
-    AGENTS_FOUND = "agents_found"
+    AGENT_CAROUSEL = "agent_carousel"
     AGENT_DETAILS = "agent_details"
     SETUP_REQUIREMENTS = "setup_requirements"
     EXECUTION_STARTED = "execution_started"
     NEED_LOGIN = "need_login"
     ERROR = "error"
     NO_RESULTS = "no_results"
+    SUCCESS = "success"
+    DOC_SEARCH_RESULTS = "doc_search_results"
     AGENT_OUTPUT = "agent_output"
+    BLOCK_LIST = "block_list"
+    BLOCK_OUTPUT = "block_output"
     UNDERSTANDING_UPDATED = "understanding_updated"
+    # Agent generation responses
+    AGENT_PREVIEW = "agent_preview"
+    AGENT_SAVED = "agent_saved"
+    CLARIFICATION_NEEDED = "clarification_needed"
 
 
 # Base response model
@@ -53,14 +61,14 @@ class AgentInfo(BaseModel):
     graph_id: str | None = None
 
 
-class AgentsFoundResponse(ToolResponseBase):
+class AgentCarouselResponse(ToolResponseBase):
     """Response for find_agent tool."""
 
-    type: ResponseType = ResponseType.AGENTS_FOUND
+    type: ResponseType = ResponseType.AGENT_CAROUSEL
     title: str = "Available Agents"
     agents: list[AgentInfo]
     count: int
-    name: str = "agents_found"
+    name: str = "agent_carousel"
 
 
 class NoResultsResponse(ToolResponseBase):
@@ -177,6 +185,28 @@ class ErrorResponse(ToolResponseBase):
     details: dict[str, Any] | None = None
 
 
+# Documentation search models
+class DocSearchResult(BaseModel):
+    """A single documentation search result."""
+
+    title: str
+    path: str
+    section: str
+    snippet: str  # Short excerpt for UI display
+    content: str  # Full text content for LLM to read and understand
+    score: float
+    doc_url: str | None = None
+
+
+class DocSearchResultsResponse(ToolResponseBase):
+    """Response for search_docs tool."""
+
+    type: ResponseType = ResponseType.DOC_SEARCH_RESULTS
+    results: list[DocSearchResult]
+    count: int
+    query: str
+
+
 # Agent output models
 class ExecutionOutputInfo(BaseModel):
     """Summary of a single execution's outputs."""
@@ -202,6 +232,37 @@ class AgentOutputResponse(ToolResponseBase):
     total_executions: int = 0
 
 
+# Block models
+class BlockInfoSummary(BaseModel):
+    """Summary of a block for search results."""
+
+    id: str
+    name: str
+    description: str
+    categories: list[str]
+    input_schema: dict[str, Any]
+    output_schema: dict[str, Any]
+
+
+class BlockListResponse(ToolResponseBase):
+    """Response for find_block tool."""
+
+    type: ResponseType = ResponseType.BLOCK_LIST
+    blocks: list[BlockInfoSummary]
+    count: int
+    query: str
+
+
+class BlockOutputResponse(ToolResponseBase):
+    """Response for run_block tool."""
+
+    type: ResponseType = ResponseType.BLOCK_OUTPUT
+    block_id: str
+    block_name: str
+    outputs: dict[str, list[Any]]
+    success: bool = True
+
+
 # Business understanding models
 class UnderstandingUpdatedResponse(ToolResponseBase):
     """Response for add_understanding tool."""
@@ -209,3 +270,41 @@ class UnderstandingUpdatedResponse(ToolResponseBase):
     type: ResponseType = ResponseType.UNDERSTANDING_UPDATED
     updated_fields: list[str] = Field(default_factory=list)
     current_understanding: dict[str, Any] = Field(default_factory=dict)
+
+
+# Agent generation models
+class ClarifyingQuestion(BaseModel):
+    """A question that needs user clarification."""
+
+    question: str
+    keyword: str
+    example: str | None = None
+
+
+class AgentPreviewResponse(ToolResponseBase):
+    """Response for previewing a generated agent before saving."""
+
+    type: ResponseType = ResponseType.AGENT_PREVIEW
+    agent_json: dict[str, Any]
+    agent_name: str
+    description: str
+    node_count: int
+    link_count: int = 0
+
+
+class AgentSavedResponse(ToolResponseBase):
+    """Response when an agent is saved to the library."""
+
+    type: ResponseType = ResponseType.AGENT_SAVED
+    agent_id: str
+    agent_name: str
+    library_agent_id: str
+    library_agent_link: str
+    agent_page_link: str  # Link to the agent builder/editor page
+
+
+class ClarificationNeededResponse(ToolResponseBase):
+    """Response when the LLM needs more information from the user."""
+
+    type: ResponseType = ResponseType.CLARIFICATION_NEEDED
+    questions: list[ClarifyingQuestion] = Field(default_factory=list)

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"""
@@ -58,11 +46,11 @@ async def test_run_agent(setup_test_data):
 
     # Verify the response
     assert response is not None
-    assert hasattr(response, "output")
+    assert hasattr(response, "result")
     # Parse the result JSON to verify the execution started
 
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
     assert "execution_id" in result_data
     assert "graph_id" in result_data
     assert result_data["graph_id"] == graph.id
@@ -98,11 +86,11 @@ async def test_run_agent_missing_inputs(setup_test_data):
 
     # Verify that we get an error response
     assert response is not None
-    assert hasattr(response, "output")
+    assert hasattr(response, "result")
     # The tool should return an ErrorResponse when setup info indicates not ready
 
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
     assert "message" in result_data
 
 
@@ -130,10 +118,10 @@ async def test_run_agent_invalid_agent_id(setup_test_data):
 
     # Verify that we get an error response
     assert response is not None
-    assert hasattr(response, "output")
+    assert hasattr(response, "result")
 
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
     assert "message" in result_data
     # Should get an error about failed setup or not found
     assert any(
@@ -170,12 +158,12 @@ async def test_run_agent_with_llm_credentials(setup_llm_test_data):
 
     # Verify the response
     assert response is not None
-    assert hasattr(response, "output")
+    assert hasattr(response, "result")
 
     # Parse the result JSON to verify the execution started
 
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Should successfully start execution since credentials are available
     assert "execution_id" in result_data
@@ -207,9 +195,9 @@ async def test_run_agent_shows_available_inputs_when_none_provided(setup_test_da
     )
 
     assert response is not None
-    assert hasattr(response, "output")
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert hasattr(response, "result")
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Should return agent_details type showing available inputs
     assert result_data.get("type") == "agent_details"
@@ -242,9 +230,9 @@ async def test_run_agent_with_use_defaults(setup_test_data):
     )
 
     assert response is not None
-    assert hasattr(response, "output")
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert hasattr(response, "result")
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Should execute successfully
     assert "execution_id" in result_data
@@ -272,9 +260,9 @@ async def test_run_agent_missing_credentials(setup_firecrawl_test_data):
     )
 
     assert response is not None
-    assert hasattr(response, "output")
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert hasattr(response, "result")
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Should return setup_requirements type with missing credentials
     assert result_data.get("type") == "setup_requirements"
@@ -304,9 +292,9 @@ async def test_run_agent_invalid_slug_format(setup_test_data):
     )
 
     assert response is not None
-    assert hasattr(response, "output")
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert hasattr(response, "result")
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Should return error
     assert result_data.get("type") == "error"
@@ -317,10 +305,9 @@ async def test_run_agent_invalid_slug_format(setup_test_data):
 async def test_run_agent_unauthenticated():
     """Test that run_agent returns need_login for unauthenticated users."""
     tool = RunAgentTool()
-    # Session has a user_id (session owner), but we test tool execution without user_id
-    session = make_session(user_id="test-session-owner")
+    session = make_session(user_id=None)
 
-    # Execute without user_id to test unauthenticated behavior
+    # Execute without user_id
     response = await tool.execute(
         user_id=None,
         session_id=str(uuid.uuid4()),
@@ -331,9 +318,9 @@ async def test_run_agent_unauthenticated():
     )
 
     assert response is not None
-    assert hasattr(response, "output")
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert hasattr(response, "result")
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Base tool returns need_login type for unauthenticated users
     assert result_data.get("type") == "need_login"
@@ -363,9 +350,9 @@ async def test_run_agent_schedule_without_cron(setup_test_data):
     )
 
     assert response is not None
-    assert hasattr(response, "output")
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert hasattr(response, "result")
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Should return error about missing cron
     assert result_data.get("type") == "error"
@@ -395,9 +382,9 @@ async def test_run_agent_schedule_without_name(setup_test_data):
     )
 
     assert response is not None
-    assert hasattr(response, "output")
-    assert isinstance(response.output, str)
-    result_data = orjson.loads(response.output)
+    assert hasattr(response, "result")
+    assert isinstance(response.result, str)
+    result_data = orjson.loads(response.result)
 
     # Should return error about missing schedule_name
     assert result_data.get("type") == "error"

autogpt_platform/backend/backend/api/features/integrations/router.py

@@ -35,7 +35,11 @@ from backend.data.model import (
     OAuth2Credentials,
     UserIntegrations,
 )
-from backend.data.onboarding import OnboardingStep, complete_onboarding_step
+from backend.data.onboarding import (
+    OnboardingStep,
+    complete_onboarding_step,
+    increment_runs,
+)
 from backend.data.user import get_user_integrations
 from backend.executor.utils import add_graph_execution
 from backend.integrations.ayrshare import AyrshareClient, SocialPlatform
@@ -171,7 +175,6 @@ async def callback(
         f"Successfully processed OAuth callback for user {user_id} "
         f"and provider {provider.value}"
     )
-
     return CredentialsMetaResponse(
         id=credentials.id,
         provider=credentials.provider,
@@ -190,7 +193,6 @@ async def list_credentials(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
     credentials = await creds_manager.store.get_all_creds(user_id)
-
     return [
         CredentialsMetaResponse(
             id=cred.id,
@@ -213,7 +215,6 @@ async def list_credentials_by_provider(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
     credentials = await creds_manager.store.get_creds_by_provider(user_id, provider)
-
     return [
         CredentialsMetaResponse(
             id=cred.id,
@@ -377,6 +378,7 @@ async def webhook_ingress_generic(
         return
 
     await complete_onboarding_step(user_id, OnboardingStep.TRIGGER_WEBHOOK)
+    await increment_runs(user_id)
 
     # Execute all triggers concurrently for better performance
     tasks = []
@@ -829,18 +831,6 @@ async def list_providers() -> List[str]:
     return all_providers
 
 
-@router.get("/providers/system", response_model=List[str])
-async def list_system_providers() -> List[str]:
-    """
-    Get a list of providers that have platform credits (system credentials) available.
-
-    These providers can be used without the user providing their own API keys.
-    """
-    from backend.integrations.credentials_store import SYSTEM_PROVIDERS
-
-    return list(SYSTEM_PROVIDERS)
-
-
 @router.get("/providers/names", response_model=ProviderNamesResponse)
 async def get_provider_names() -> ProviderNamesResponse:
     """

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/presets.py

@@ -8,6 +8,7 @@ from backend.data.execution import GraphExecutionMeta
 from backend.data.graph import get_graph
 from backend.data.integrations import get_webhook
 from backend.data.model import CredentialsMetaInput
+from backend.data.onboarding import increment_runs
 from backend.executor.utils import add_graph_execution, make_node_credentials_input_map
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.integrations.webhooks import get_webhook_manager
@@ -402,6 +403,8 @@ async def execute_preset(
     merged_node_input = preset.inputs | inputs
     merged_credential_inputs = preset.credentials | credential_inputs
 
+    await increment_runs(user_id)
+
     return await add_graph_execution(
         user_id=user_id,
         graph_id=preset.graph_id,

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/content_handlers.py

@@ -1,431 +0,0 @@
-"""
-Content Type Handlers for Unified Embeddings
-
-Pluggable system for different content sources (store agents, blocks, docs).
-Each handler knows how to fetch and process its content type for embedding.
-"""
-
-import logging
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-from prisma.enums import ContentType
-
-from backend.data.db import query_raw_with_schema
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ContentItem:
-    """Represents a piece of content to be embedded."""
-
-    content_id: str  # Unique identifier (DB ID or file path)
-    content_type: ContentType
-    searchable_text: str  # Combined text for embedding
-    metadata: dict[str, Any]  # Content-specific metadata
-    user_id: str | None = None  # For user-scoped content
-
-
-class ContentHandler(ABC):
-    """Base handler for fetching and processing content for embeddings."""
-
-    @property
-    @abstractmethod
-    def content_type(self) -> ContentType:
-        """The ContentType this handler manages."""
-        pass
-
-    @abstractmethod
-    async def get_missing_items(self, batch_size: int) -> list[ContentItem]:
-        """
-        Fetch items that don't have embeddings yet.
-
-        Args:
-            batch_size: Maximum number of items to return
-
-        Returns:
-            List of ContentItem objects ready for embedding
-        """
-        pass
-
-    @abstractmethod
-    async def get_stats(self) -> dict[str, int]:
-        """
-        Get statistics about embedding coverage.
-
-        Returns:
-            Dict with keys: total, with_embeddings, without_embeddings
-        """
-        pass
-
-
-class StoreAgentHandler(ContentHandler):
-    """Handler for marketplace store agent listings."""
-
-    @property
-    def content_type(self) -> ContentType:
-        return ContentType.STORE_AGENT
-
-    async def get_missing_items(self, batch_size: int) -> list[ContentItem]:
-        """Fetch approved store listings without embeddings."""
-        from backend.api.features.store.embeddings import build_searchable_text
-
-        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'::{schema_prefix}"ContentType"
-            WHERE slv."submissionStatus" = 'APPROVED'
-            AND slv."isDeleted" = false
-            AND uce."contentId" IS NULL
-            LIMIT $1
-            """,
-            batch_size,
-        )
-
-        return [
-            ContentItem(
-                content_id=row["id"],
-                content_type=ContentType.STORE_AGENT,
-                searchable_text=build_searchable_text(
-                    name=row["name"],
-                    description=row["description"],
-                    sub_heading=row["subHeading"],
-                    categories=row["categories"] or [],
-                ),
-                metadata={
-                    "name": row["name"],
-                    "categories": row["categories"] or [],
-                },
-                user_id=None,  # Store agents are public
-            )
-            for row in missing
-        ]
-
-    async def get_stats(self) -> dict[str, int]:
-        """Get statistics about store agent embedding coverage."""
-        # 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'::{schema_prefix}"ContentType"
-            WHERE slv."submissionStatus" = 'APPROVED'
-            AND slv."isDeleted" = false
-            """
-        )
-        with_embeddings = embedded_result[0]["count"] if embedded_result else 0
-
-        return {
-            "total": total_approved,
-            "with_embeddings": with_embeddings,
-            "without_embeddings": total_approved - with_embeddings,
-        }
-
-
-class BlockHandler(ContentHandler):
-    """Handler for block definitions (Python classes)."""
-
-    @property
-    def content_type(self) -> ContentType:
-        return ContentType.BLOCK
-
-    async def get_missing_items(self, batch_size: int) -> list[ContentItem]:
-        """Fetch blocks without embeddings."""
-        from backend.data.block import get_blocks
-
-        # Get all available blocks
-        all_blocks = get_blocks()
-
-        # Check which ones have embeddings
-        if not all_blocks:
-            return []
-
-        block_ids = list(all_blocks.keys())
-
-        # Query for existing embeddings
-        placeholders = ",".join([f"${i+1}" for i in range(len(block_ids))])
-        existing_result = await query_raw_with_schema(
-            f"""
-            SELECT "contentId"
-            FROM {{schema_prefix}}"UnifiedContentEmbedding"
-            WHERE "contentType" = 'BLOCK'::{{schema_prefix}}"ContentType"
-            AND "contentId" = ANY(ARRAY[{placeholders}])
-            """,
-            *block_ids,
-        )
-
-        existing_ids = {row["contentId"] for row in existing_result}
-        missing_blocks = [
-            (block_id, block_cls)
-            for block_id, block_cls in all_blocks.items()
-            if block_id not in existing_ids
-        ]
-
-        # Convert to ContentItem
-        items = []
-        for block_id, block_cls in missing_blocks[:batch_size]:
-            try:
-                block_instance = block_cls()
-
-                # Build searchable text from block metadata
-                parts = []
-                if hasattr(block_instance, "name") and block_instance.name:
-                    parts.append(block_instance.name)
-                if (
-                    hasattr(block_instance, "description")
-                    and block_instance.description
-                ):
-                    parts.append(block_instance.description)
-                if hasattr(block_instance, "categories") and block_instance.categories:
-                    # Convert BlockCategory enum to strings
-                    parts.append(
-                        " ".join(str(cat.value) for cat in block_instance.categories)
-                    )
-
-                # Add input/output schema info
-                if hasattr(block_instance, "input_schema"):
-                    schema = block_instance.input_schema
-                    if hasattr(schema, "model_json_schema"):
-                        schema_dict = schema.model_json_schema()
-                        if "properties" in schema_dict:
-                            for prop_name, prop_info in schema_dict[
-                                "properties"
-                            ].items():
-                                if "description" in prop_info:
-                                    parts.append(
-                                        f"{prop_name}: {prop_info['description']}"
-                                    )
-
-                searchable_text = " ".join(parts)
-
-                # Convert categories set of enums to list of strings for JSON serialization
-                categories = getattr(block_instance, "categories", set())
-                categories_list = (
-                    [cat.value for cat in categories] if categories else []
-                )
-
-                items.append(
-                    ContentItem(
-                        content_id=block_id,
-                        content_type=ContentType.BLOCK,
-                        searchable_text=searchable_text,
-                        metadata={
-                            "name": getattr(block_instance, "name", ""),
-                            "categories": categories_list,
-                        },
-                        user_id=None,  # Blocks are public
-                    )
-                )
-            except Exception as e:
-                logger.warning(f"Failed to process block {block_id}: {e}")
-                continue
-
-        return items
-
-    async def get_stats(self) -> dict[str, int]:
-        """Get statistics about block embedding coverage."""
-        from backend.data.block import get_blocks
-
-        all_blocks = get_blocks()
-        total_blocks = len(all_blocks)
-
-        if total_blocks == 0:
-            return {"total": 0, "with_embeddings": 0, "without_embeddings": 0}
-
-        block_ids = list(all_blocks.keys())
-        placeholders = ",".join([f"${i+1}" for i in range(len(block_ids))])
-
-        embedded_result = await query_raw_with_schema(
-            f"""
-            SELECT COUNT(*) as count
-            FROM {{schema_prefix}}"UnifiedContentEmbedding"
-            WHERE "contentType" = 'BLOCK'::{{schema_prefix}}"ContentType"
-            AND "contentId" = ANY(ARRAY[{placeholders}])
-            """,
-            *block_ids,
-        )
-
-        with_embeddings = embedded_result[0]["count"] if embedded_result else 0
-
-        return {
-            "total": total_blocks,
-            "with_embeddings": with_embeddings,
-            "without_embeddings": total_blocks - with_embeddings,
-        }
-
-
-class DocumentationHandler(ContentHandler):
-    """Handler for documentation files (.md/.mdx)."""
-
-    @property
-    def content_type(self) -> ContentType:
-        return ContentType.DOCUMENTATION
-
-    def _get_docs_root(self) -> Path:
-        """Get the documentation root directory."""
-        # content_handlers.py is at: backend/backend/api/features/store/content_handlers.py
-        # Need to go up to project root then into docs/
-        # In container: /app/autogpt_platform/backend/backend/api/features/store -> /app/docs
-        # In development: /repo/autogpt_platform/backend/backend/api/features/store -> /repo/docs
-        this_file = Path(
-            __file__
-        )  # .../backend/backend/api/features/store/content_handlers.py
-        project_root = (
-            this_file.parent.parent.parent.parent.parent.parent.parent
-        )  # -> /app or /repo
-        docs_root = project_root / "docs"
-        return docs_root
-
-    def _extract_title_and_content(self, file_path: Path) -> tuple[str, str]:
-        """Extract title and content from markdown file."""
-        try:
-            content = file_path.read_text(encoding="utf-8")
-
-            # Try to extract title from first # heading
-            lines = content.split("\n")
-            title = ""
-            body_lines = []
-
-            for line in lines:
-                if line.startswith("# ") and not title:
-                    title = line[2:].strip()
-                else:
-                    body_lines.append(line)
-
-            # If no title found, use filename
-            if not title:
-                title = file_path.stem.replace("-", " ").replace("_", " ").title()
-
-            body = "\n".join(body_lines)
-
-            return title, body
-        except Exception as e:
-            logger.warning(f"Failed to read {file_path}: {e}")
-            return file_path.stem, ""
-
-    async def get_missing_items(self, batch_size: int) -> list[ContentItem]:
-        """Fetch documentation files without embeddings."""
-        docs_root = self._get_docs_root()
-
-        if not docs_root.exists():
-            logger.warning(f"Documentation root not found: {docs_root}")
-            return []
-
-        # Find all .md and .mdx files
-        all_docs = list(docs_root.rglob("*.md")) + list(docs_root.rglob("*.mdx"))
-
-        # Get relative paths for content IDs
-        doc_paths = [str(doc.relative_to(docs_root)) for doc in all_docs]
-
-        if not doc_paths:
-            return []
-
-        # Check which ones have embeddings
-        placeholders = ",".join([f"${i+1}" for i in range(len(doc_paths))])
-        existing_result = await query_raw_with_schema(
-            f"""
-            SELECT "contentId"
-            FROM {{schema_prefix}}"UnifiedContentEmbedding"
-            WHERE "contentType" = 'DOCUMENTATION'::{{schema_prefix}}"ContentType"
-            AND "contentId" = ANY(ARRAY[{placeholders}])
-            """,
-            *doc_paths,
-        )
-
-        existing_ids = {row["contentId"] for row in existing_result}
-        missing_docs = [
-            (doc_path, doc_file)
-            for doc_path, doc_file in zip(doc_paths, all_docs)
-            if doc_path not in existing_ids
-        ]
-
-        # Convert to ContentItem
-        items = []
-        for doc_path, doc_file in missing_docs[:batch_size]:
-            try:
-                title, content = self._extract_title_and_content(doc_file)
-
-                # Build searchable text
-                searchable_text = f"{title} {content}"
-
-                items.append(
-                    ContentItem(
-                        content_id=doc_path,
-                        content_type=ContentType.DOCUMENTATION,
-                        searchable_text=searchable_text,
-                        metadata={
-                            "title": title,
-                            "path": doc_path,
-                        },
-                        user_id=None,  # Documentation is public
-                    )
-                )
-            except Exception as e:
-                logger.warning(f"Failed to process doc {doc_path}: {e}")
-                continue
-
-        return items
-
-    async def get_stats(self) -> dict[str, int]:
-        """Get statistics about documentation embedding coverage."""
-        docs_root = self._get_docs_root()
-
-        if not docs_root.exists():
-            return {"total": 0, "with_embeddings": 0, "without_embeddings": 0}
-
-        # Count all .md and .mdx files
-        all_docs = list(docs_root.rglob("*.md")) + list(docs_root.rglob("*.mdx"))
-        total_docs = len(all_docs)
-
-        if total_docs == 0:
-            return {"total": 0, "with_embeddings": 0, "without_embeddings": 0}
-
-        doc_paths = [str(doc.relative_to(docs_root)) for doc in all_docs]
-        placeholders = ",".join([f"${i+1}" for i in range(len(doc_paths))])
-
-        embedded_result = await query_raw_with_schema(
-            f"""
-            SELECT COUNT(*) as count
-            FROM {{schema_prefix}}"UnifiedContentEmbedding"
-            WHERE "contentType" = 'DOCUMENTATION'::{{schema_prefix}}"ContentType"
-            AND "contentId" = ANY(ARRAY[{placeholders}])
-            """,
-            *doc_paths,
-        )
-
-        with_embeddings = embedded_result[0]["count"] if embedded_result else 0
-
-        return {
-            "total": total_docs,
-            "with_embeddings": with_embeddings,
-            "without_embeddings": total_docs - with_embeddings,
-        }
-
-
-# Content handler registry
-CONTENT_HANDLERS: dict[ContentType, ContentHandler] = {
-    ContentType.STORE_AGENT: StoreAgentHandler(),
-    ContentType.BLOCK: BlockHandler(),
-    ContentType.DOCUMENTATION: DocumentationHandler(),
-}

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

@@ -1,215 +0,0 @@
-"""
-Integration tests for content handlers using real DB.
-
-Run with: poetry run pytest backend/api/features/store/content_handlers_integration_test.py -xvs
-
-These tests use the real database but mock OpenAI calls.
-"""
-
-from unittest.mock import patch
-
-import pytest
-
-from backend.api.features.store.content_handlers import (
-    CONTENT_HANDLERS,
-    BlockHandler,
-    DocumentationHandler,
-    StoreAgentHandler,
-)
-from backend.api.features.store.embeddings import (
-    EMBEDDING_DIM,
-    backfill_all_content_types,
-    ensure_content_embedding,
-    get_embedding_stats,
-)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_agent_handler_real_db():
-    """Test StoreAgentHandler with real database queries."""
-    handler = StoreAgentHandler()
-
-    # Get stats from real DB
-    stats = await handler.get_stats()
-
-    # Stats should have correct structure
-    assert "total" in stats
-    assert "with_embeddings" in stats
-    assert "without_embeddings" in stats
-    assert stats["total"] >= 0
-    assert stats["with_embeddings"] >= 0
-    assert stats["without_embeddings"] >= 0
-
-    # Get missing items (max 1 to keep test fast)
-    items = await handler.get_missing_items(batch_size=1)
-
-    # Items should be list (may be empty if all have embeddings)
-    assert isinstance(items, list)
-
-    if items:
-        item = items[0]
-        assert item.content_id is not None
-        assert item.content_type.value == "STORE_AGENT"
-        assert item.searchable_text != ""
-        assert item.user_id is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_block_handler_real_db():
-    """Test BlockHandler with real database queries."""
-    handler = BlockHandler()
-
-    # Get stats from real DB
-    stats = await handler.get_stats()
-
-    # Stats should have correct structure
-    assert "total" in stats
-    assert "with_embeddings" in stats
-    assert "without_embeddings" in stats
-    assert stats["total"] >= 0  # Should have at least some blocks
-    assert stats["with_embeddings"] >= 0
-    assert stats["without_embeddings"] >= 0
-
-    # Get missing items (max 1 to keep test fast)
-    items = await handler.get_missing_items(batch_size=1)
-
-    # Items should be list
-    assert isinstance(items, list)
-
-    if items:
-        item = items[0]
-        assert item.content_id is not None  # Should be block UUID
-        assert item.content_type.value == "BLOCK"
-        assert item.searchable_text != ""
-        assert item.user_id is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_documentation_handler_real_fs():
-    """Test DocumentationHandler with real filesystem."""
-    handler = DocumentationHandler()
-
-    # Get stats from real filesystem
-    stats = await handler.get_stats()
-
-    # Stats should have correct structure
-    assert "total" in stats
-    assert "with_embeddings" in stats
-    assert "without_embeddings" in stats
-    assert stats["total"] >= 0
-    assert stats["with_embeddings"] >= 0
-    assert stats["without_embeddings"] >= 0
-
-    # Get missing items (max 1 to keep test fast)
-    items = await handler.get_missing_items(batch_size=1)
-
-    # Items should be list
-    assert isinstance(items, list)
-
-    if items:
-        item = items[0]
-        assert item.content_id is not None  # Should be relative path
-        assert item.content_type.value == "DOCUMENTATION"
-        assert item.searchable_text != ""
-        assert item.user_id is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_get_embedding_stats_all_types():
-    """Test get_embedding_stats aggregates all content types."""
-    stats = await get_embedding_stats()
-
-    # Should have structure with by_type and totals
-    assert "by_type" in stats
-    assert "totals" in stats
-
-    # Check each content type is present
-    by_type = stats["by_type"]
-    assert "STORE_AGENT" in by_type
-    assert "BLOCK" in by_type
-    assert "DOCUMENTATION" in by_type
-
-    # Check totals are aggregated
-    totals = stats["totals"]
-    assert totals["total"] >= 0
-    assert totals["with_embeddings"] >= 0
-    assert totals["without_embeddings"] >= 0
-    assert "coverage_percent" in totals
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.api.features.store.embeddings.generate_embedding")
-async def test_ensure_content_embedding_blocks(mock_generate):
-    """Test creating embeddings for blocks (mocked OpenAI)."""
-    # Mock OpenAI to return fake embedding
-    mock_generate.return_value = [0.1] * EMBEDDING_DIM
-
-    # Get one block without embedding
-    handler = BlockHandler()
-    items = await handler.get_missing_items(batch_size=1)
-
-    if not items:
-        pytest.skip("No blocks without embeddings")
-
-    item = items[0]
-
-    # Try to create embedding (OpenAI mocked)
-    result = await ensure_content_embedding(
-        content_type=item.content_type,
-        content_id=item.content_id,
-        searchable_text=item.searchable_text,
-        metadata=item.metadata,
-        user_id=item.user_id,
-    )
-
-    # Should succeed with mocked OpenAI
-    assert result is True
-    mock_generate.assert_called_once()
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.api.features.store.embeddings.generate_embedding")
-async def test_backfill_all_content_types_dry_run(mock_generate):
-    """Test backfill_all_content_types processes all handlers in order."""
-    # Mock OpenAI to return fake embedding
-    mock_generate.return_value = [0.1] * EMBEDDING_DIM
-
-    # Run backfill with batch_size=1 to process max 1 per type
-    result = await backfill_all_content_types(batch_size=1)
-
-    # Should have results for all content types
-    assert "by_type" in result
-    assert "totals" in result
-
-    by_type = result["by_type"]
-    assert "BLOCK" in by_type
-    assert "STORE_AGENT" in by_type
-    assert "DOCUMENTATION" in by_type
-
-    # Each type should have correct structure
-    for content_type, type_result in by_type.items():
-        assert "processed" in type_result
-        assert "success" in type_result
-        assert "failed" in type_result
-
-    # Totals should aggregate
-    totals = result["totals"]
-    assert totals["processed"] >= 0
-    assert totals["success"] >= 0
-    assert totals["failed"] >= 0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_content_handler_registry():
-    """Test all handlers are registered in correct order."""
-    from prisma.enums import ContentType
-
-    # All three types should be registered
-    assert ContentType.STORE_AGENT in CONTENT_HANDLERS
-    assert ContentType.BLOCK in CONTENT_HANDLERS
-    assert ContentType.DOCUMENTATION in CONTENT_HANDLERS
-
-    # Check handler types
-    assert isinstance(CONTENT_HANDLERS[ContentType.STORE_AGENT], StoreAgentHandler)
-    assert isinstance(CONTENT_HANDLERS[ContentType.BLOCK], BlockHandler)
-    assert isinstance(CONTENT_HANDLERS[ContentType.DOCUMENTATION], DocumentationHandler)

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

@@ -1,324 +0,0 @@
-"""
-E2E tests for content handlers (blocks, store agents, documentation).
-
-Tests the full flow: discovering content → generating embeddings → storing.
-"""
-
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-from prisma.enums import ContentType
-
-from backend.api.features.store.content_handlers import (
-    CONTENT_HANDLERS,
-    BlockHandler,
-    DocumentationHandler,
-    StoreAgentHandler,
-)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_agent_handler_get_missing_items(mocker):
-    """Test StoreAgentHandler fetches approved agents without embeddings."""
-    handler = StoreAgentHandler()
-
-    # Mock database query
-    mock_missing = [
-        {
-            "id": "agent-1",
-            "name": "Test Agent",
-            "description": "A test agent",
-            "subHeading": "Test heading",
-            "categories": ["AI", "Testing"],
-        }
-    ]
-
-    with patch(
-        "backend.api.features.store.content_handlers.query_raw_with_schema",
-        return_value=mock_missing,
-    ):
-        items = await handler.get_missing_items(batch_size=10)
-
-        assert len(items) == 1
-        assert items[0].content_id == "agent-1"
-        assert items[0].content_type == ContentType.STORE_AGENT
-        assert "Test Agent" in items[0].searchable_text
-        assert "A test agent" in items[0].searchable_text
-        assert items[0].metadata["name"] == "Test Agent"
-        assert items[0].user_id is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_agent_handler_get_stats(mocker):
-    """Test StoreAgentHandler returns correct stats."""
-    handler = StoreAgentHandler()
-
-    # Mock approved count query
-    mock_approved = [{"count": 50}]
-    # Mock embedded count query
-    mock_embedded = [{"count": 30}]
-
-    with patch(
-        "backend.api.features.store.content_handlers.query_raw_with_schema",
-        side_effect=[mock_approved, mock_embedded],
-    ):
-        stats = await handler.get_stats()
-
-        assert stats["total"] == 50
-        assert stats["with_embeddings"] == 30
-        assert stats["without_embeddings"] == 20
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_block_handler_get_missing_items(mocker):
-    """Test BlockHandler discovers blocks without embeddings."""
-    handler = BlockHandler()
-
-    # Mock get_blocks to return test blocks
-    mock_block_class = MagicMock()
-    mock_block_instance = MagicMock()
-    mock_block_instance.name = "Calculator Block"
-    mock_block_instance.description = "Performs calculations"
-    mock_block_instance.categories = [MagicMock(value="MATH")]
-    mock_block_instance.input_schema.model_json_schema.return_value = {
-        "properties": {"expression": {"description": "Math expression to evaluate"}}
-    }
-    mock_block_class.return_value = mock_block_instance
-
-    mock_blocks = {"block-uuid-1": mock_block_class}
-
-    # Mock existing embeddings query (no embeddings exist)
-    mock_existing = []
-
-    with patch(
-        "backend.data.block.get_blocks",
-        return_value=mock_blocks,
-    ):
-        with patch(
-            "backend.api.features.store.content_handlers.query_raw_with_schema",
-            return_value=mock_existing,
-        ):
-            items = await handler.get_missing_items(batch_size=10)
-
-            assert len(items) == 1
-            assert items[0].content_id == "block-uuid-1"
-            assert items[0].content_type == ContentType.BLOCK
-            assert "Calculator Block" in items[0].searchable_text
-            assert "Performs calculations" in items[0].searchable_text
-            assert "MATH" in items[0].searchable_text
-            assert "expression: Math expression" in items[0].searchable_text
-            assert items[0].user_id is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_block_handler_get_stats(mocker):
-    """Test BlockHandler returns correct stats."""
-    handler = BlockHandler()
-
-    # Mock get_blocks
-    mock_blocks = {
-        "block-1": MagicMock(),
-        "block-2": MagicMock(),
-        "block-3": MagicMock(),
-    }
-
-    # Mock embedded count query (2 blocks have embeddings)
-    mock_embedded = [{"count": 2}]
-
-    with patch(
-        "backend.data.block.get_blocks",
-        return_value=mock_blocks,
-    ):
-        with patch(
-            "backend.api.features.store.content_handlers.query_raw_with_schema",
-            return_value=mock_embedded,
-        ):
-            stats = await handler.get_stats()
-
-            assert stats["total"] == 3
-            assert stats["with_embeddings"] == 2
-            assert stats["without_embeddings"] == 1
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_documentation_handler_get_missing_items(tmp_path, mocker):
-    """Test DocumentationHandler discovers docs without embeddings."""
-    handler = DocumentationHandler()
-
-    # Create temporary docs directory with test files
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-
-    (docs_root / "guide.md").write_text("# Getting Started\n\nThis is a guide.")
-    (docs_root / "api.mdx").write_text("# API Reference\n\nAPI documentation.")
-
-    # Mock _get_docs_root to return temp dir
-    with patch.object(handler, "_get_docs_root", return_value=docs_root):
-        # Mock existing embeddings query (no embeddings exist)
-        with patch(
-            "backend.api.features.store.content_handlers.query_raw_with_schema",
-            return_value=[],
-        ):
-            items = await handler.get_missing_items(batch_size=10)
-
-            assert len(items) == 2
-
-            # Check guide.md
-            guide_item = next(
-                (item for item in items if item.content_id == "guide.md"), None
-            )
-            assert guide_item is not None
-            assert guide_item.content_type == ContentType.DOCUMENTATION
-            assert "Getting Started" in guide_item.searchable_text
-            assert "This is a guide" in guide_item.searchable_text
-            assert guide_item.metadata["title"] == "Getting Started"
-            assert guide_item.user_id is None
-
-            # Check api.mdx
-            api_item = next(
-                (item for item in items if item.content_id == "api.mdx"), None
-            )
-            assert api_item is not None
-            assert "API Reference" in api_item.searchable_text
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_documentation_handler_get_stats(tmp_path, mocker):
-    """Test DocumentationHandler returns correct stats."""
-    handler = DocumentationHandler()
-
-    # Create temporary docs directory
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-    (docs_root / "doc1.md").write_text("# Doc 1")
-    (docs_root / "doc2.md").write_text("# Doc 2")
-    (docs_root / "doc3.mdx").write_text("# Doc 3")
-
-    # Mock embedded count query (1 doc has embedding)
-    mock_embedded = [{"count": 1}]
-
-    with patch.object(handler, "_get_docs_root", return_value=docs_root):
-        with patch(
-            "backend.api.features.store.content_handlers.query_raw_with_schema",
-            return_value=mock_embedded,
-        ):
-            stats = await handler.get_stats()
-
-            assert stats["total"] == 3
-            assert stats["with_embeddings"] == 1
-            assert stats["without_embeddings"] == 2
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_documentation_handler_title_extraction(tmp_path):
-    """Test DocumentationHandler extracts title from markdown heading."""
-    handler = DocumentationHandler()
-
-    # Test with heading
-    doc_with_heading = tmp_path / "with_heading.md"
-    doc_with_heading.write_text("# My Title\n\nContent here")
-    title, content = handler._extract_title_and_content(doc_with_heading)
-    assert title == "My Title"
-    assert "# My Title" not in content
-    assert "Content here" in content
-
-    # Test without heading
-    doc_without_heading = tmp_path / "no-heading.md"
-    doc_without_heading.write_text("Just content, no heading")
-    title, content = handler._extract_title_and_content(doc_without_heading)
-    assert title == "No Heading"  # Uses filename
-    assert "Just content" in content
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_content_handlers_registry():
-    """Test all content types are registered."""
-    assert ContentType.STORE_AGENT in CONTENT_HANDLERS
-    assert ContentType.BLOCK in CONTENT_HANDLERS
-    assert ContentType.DOCUMENTATION in CONTENT_HANDLERS
-
-    assert isinstance(CONTENT_HANDLERS[ContentType.STORE_AGENT], StoreAgentHandler)
-    assert isinstance(CONTENT_HANDLERS[ContentType.BLOCK], BlockHandler)
-    assert isinstance(CONTENT_HANDLERS[ContentType.DOCUMENTATION], DocumentationHandler)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_block_handler_handles_missing_attributes():
-    """Test BlockHandler gracefully handles blocks with missing attributes."""
-    handler = BlockHandler()
-
-    # Mock block with minimal attributes
-    mock_block_class = MagicMock()
-    mock_block_instance = MagicMock()
-    mock_block_instance.name = "Minimal Block"
-    # No description, categories, or schema
-    del mock_block_instance.description
-    del mock_block_instance.categories
-    del mock_block_instance.input_schema
-    mock_block_class.return_value = mock_block_instance
-
-    mock_blocks = {"block-minimal": mock_block_class}
-
-    with patch(
-        "backend.data.block.get_blocks",
-        return_value=mock_blocks,
-    ):
-        with patch(
-            "backend.api.features.store.content_handlers.query_raw_with_schema",
-            return_value=[],
-        ):
-            items = await handler.get_missing_items(batch_size=10)
-
-            assert len(items) == 1
-            assert items[0].searchable_text == "Minimal Block"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_block_handler_skips_failed_blocks():
-    """Test BlockHandler skips blocks that fail to instantiate."""
-    handler = BlockHandler()
-
-    # Mock one good block and one bad block
-    good_block = MagicMock()
-    good_instance = MagicMock()
-    good_instance.name = "Good Block"
-    good_instance.description = "Works fine"
-    good_instance.categories = []
-    good_block.return_value = good_instance
-
-    bad_block = MagicMock()
-    bad_block.side_effect = Exception("Instantiation failed")
-
-    mock_blocks = {"good-block": good_block, "bad-block": bad_block}
-
-    with patch(
-        "backend.data.block.get_blocks",
-        return_value=mock_blocks,
-    ):
-        with patch(
-            "backend.api.features.store.content_handlers.query_raw_with_schema",
-            return_value=[],
-        ):
-            items = await handler.get_missing_items(batch_size=10)
-
-            # Should only get the good block
-            assert len(items) == 1
-            assert items[0].content_id == "good-block"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_documentation_handler_missing_docs_directory():
-    """Test DocumentationHandler handles missing docs directory gracefully."""
-    handler = DocumentationHandler()
-
-    # Mock _get_docs_root to return non-existent path
-    fake_path = Path("/nonexistent/docs")
-    with patch.object(handler, "_get_docs_root", return_value=fake_path):
-        items = await handler.get_missing_items(batch_size=10)
-        assert items == []
-
-        stats = await handler.get_stats()
-        assert stats["total"] == 0
-        assert stats["with_embeddings"] == 0
-        assert stats["without_embeddings"] == 0

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,962 +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 tiktoken import encoding_for_model
-
-from backend.api.features.store.content_handlers import CONTENT_HANDLERS
-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"
-# Embedding dimension for the model above
-# text-embedding-3-small: 1536, text-embedding-3-large: 3072
-EMBEDDING_DIM = 1536
-# OpenAI embedding token limit (8,191 with 1 token buffer for safety)
-EMBEDDING_MAX_TOKENS = 8191
-
-
-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 token limit using tiktoken
-        # Character-based truncation is insufficient because token ratios vary by content type
-        enc = encoding_for_model(EMBEDDING_MODEL)
-        tokens = enc.encode(text)
-        if len(tokens) > EMBEDDING_MAX_TOKENS:
-            tokens = tokens[:EMBEDDING_MAX_TOKENS]
-            truncated_text = enc.decode(tokens)
-            logger.info(
-                f"Truncated text from {len(enc.encode(text))} to {len(tokens)} tokens"
-            )
-        else:
-            truncated_text = text
-
-        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(tokens)} tokens, {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
-        # WHERE clause in DO UPDATE prevents PostgreSQL 15 bug with NULLS NOT DISTINCT
-        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()
-            WHERE {schema_prefix}"UnifiedContentEmbedding"."contentType" = $1::{schema_prefix}"ContentType"
-                AND {schema_prefix}"UnifiedContentEmbedding"."contentId" = $2
-                AND ({schema_prefix}"UnifiedContentEmbedding"."userId" = $3 OR ($3 IS NULL AND {schema_prefix}"UnifiedContentEmbedding"."userId" IS NULL))
-            """,
-            content_type,
-            content_id,
-            user_id,
-            embedding_str,
-            searchable_text,
-            metadata_json,
-            client=client,
-            set_public_search_path=True,
-        )
-
-        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,
-            set_public_search_path=True,
-        )
-
-        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, user_id: str | None = None
-) -> 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.
-
-    Args:
-        content_type: The type of content (STORE_AGENT, LIBRARY_AGENT, etc.)
-        content_id: The unique identifier for the content
-        user_id: Optional user ID. For public content (STORE_AGENT, BLOCK), pass None.
-                 For user-scoped content (LIBRARY_AGENT), pass the user's ID to avoid
-                 deleting embeddings belonging to other users.
-
-    Returns:
-        True if deletion succeeded, False otherwise
-    """
-    try:
-        client = prisma.get_client()
-
-        await execute_raw_with_schema(
-            """
-            DELETE 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,
-            client=client,
-        )
-
-        user_str = f" (user: {user_id})" if user_id else ""
-        logger.info(f"Deleted embedding for {content_type}:{content_id}{user_str}")
-        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 for all content types.
-
-    Returns stats per content type and overall totals.
-    """
-    try:
-        stats_by_type = {}
-        total_items = 0
-        total_with_embeddings = 0
-        total_without_embeddings = 0
-
-        # Aggregate stats from all handlers
-        for content_type, handler in CONTENT_HANDLERS.items():
-            try:
-                stats = await handler.get_stats()
-                stats_by_type[content_type.value] = {
-                    "total": stats["total"],
-                    "with_embeddings": stats["with_embeddings"],
-                    "without_embeddings": stats["without_embeddings"],
-                    "coverage_percent": (
-                        round(stats["with_embeddings"] / stats["total"] * 100, 1)
-                        if stats["total"] > 0
-                        else 0
-                    ),
-                }
-
-                total_items += stats["total"]
-                total_with_embeddings += stats["with_embeddings"]
-                total_without_embeddings += stats["without_embeddings"]
-
-            except Exception as e:
-                logger.error(f"Failed to get stats for {content_type.value}: {e}")
-                stats_by_type[content_type.value] = {
-                    "total": 0,
-                    "with_embeddings": 0,
-                    "without_embeddings": 0,
-                    "coverage_percent": 0,
-                    "error": str(e),
-                }
-
-        return {
-            "by_type": stats_by_type,
-            "totals": {
-                "total": total_items,
-                "with_embeddings": total_with_embeddings,
-                "without_embeddings": total_without_embeddings,
-                "coverage_percent": (
-                    round(total_with_embeddings / total_items * 100, 1)
-                    if total_items > 0
-                    else 0
-                ),
-            },
-        }
-
-    except Exception as e:
-        logger.error(f"Failed to get embedding stats: {e}")
-        return {
-            "by_type": {},
-            "totals": {
-                "total": 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.
-
-    BACKWARD COMPATIBILITY: Maintained for existing usage.
-    This now delegates to backfill_all_content_types() to process all content types.
-
-    Args:
-        batch_size: Number of embeddings to generate per content type
-
-    Returns:
-        Dict with success/failure counts aggregated across all content types
-    """
-    # Delegate to the new generic backfill system
-    result = await backfill_all_content_types(batch_size)
-
-    # Return in the old format for backward compatibility
-    return result["totals"]
-
-
-async def backfill_all_content_types(batch_size: int = 10) -> dict[str, Any]:
-    """
-    Generate embeddings for all content types using registered handlers.
-
-    Processes content types in order: BLOCK → STORE_AGENT → DOCUMENTATION.
-    This ensures foundational content (blocks) are searchable first.
-
-    Args:
-        batch_size: Number of embeddings to generate per content type
-
-    Returns:
-        Dict with stats per content type and overall totals
-    """
-    results_by_type = {}
-    total_processed = 0
-    total_success = 0
-    total_failed = 0
-
-    # Process content types in explicit order
-    processing_order = [
-        ContentType.BLOCK,
-        ContentType.STORE_AGENT,
-        ContentType.DOCUMENTATION,
-    ]
-
-    for content_type in processing_order:
-        handler = CONTENT_HANDLERS.get(content_type)
-        if not handler:
-            logger.warning(f"No handler registered for {content_type.value}")
-            continue
-        try:
-            logger.info(f"Processing {content_type.value} content type...")
-
-            # Get missing items from handler
-            missing_items = await handler.get_missing_items(batch_size)
-
-            if not missing_items:
-                results_by_type[content_type.value] = {
-                    "processed": 0,
-                    "success": 0,
-                    "failed": 0,
-                    "message": "No missing embeddings",
-                }
-                continue
-
-            # Process embeddings concurrently for better performance
-            embedding_tasks = [
-                ensure_content_embedding(
-                    content_type=item.content_type,
-                    content_id=item.content_id,
-                    searchable_text=item.searchable_text,
-                    metadata=item.metadata,
-                    user_id=item.user_id,
-                )
-                for item in missing_items
-            ]
-
-            results = await asyncio.gather(*embedding_tasks, return_exceptions=True)
-
-            success = sum(1 for result in results if result is True)
-            failed = len(results) - success
-
-            results_by_type[content_type.value] = {
-                "processed": len(missing_items),
-                "success": success,
-                "failed": failed,
-                "message": f"Backfilled {success} embeddings, {failed} failed",
-            }
-
-            total_processed += len(missing_items)
-            total_success += success
-            total_failed += failed
-
-            logger.info(
-                f"{content_type.value}: processed {len(missing_items)}, "
-                f"success {success}, failed {failed}"
-            )
-
-        except Exception as e:
-            logger.error(f"Failed to process {content_type.value}: {e}")
-            results_by_type[content_type.value] = {
-                "processed": 0,
-                "success": 0,
-                "failed": 0,
-                "error": str(e),
-            }
-
-    return {
-        "by_type": results_by_type,
-        "totals": {
-            "processed": total_processed,
-            "success": total_success,
-            "failed": total_failed,
-            "message": f"Overall: {total_success} succeeded, {total_failed} failed",
-        },
-    }
-
-
-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
-
-
-async def cleanup_orphaned_embeddings() -> dict[str, Any]:
-    """
-    Clean up embeddings for content that no longer exists or is no longer valid.
-
-    Compares current content with embeddings in database and removes orphaned records:
-    - STORE_AGENT: Removes embeddings for rejected/deleted store listings
-    - BLOCK: Removes embeddings for blocks no longer registered
-    - DOCUMENTATION: Removes embeddings for deleted doc files
-
-    Returns:
-        Dict with cleanup statistics per content type
-    """
-    results_by_type = {}
-    total_deleted = 0
-
-    # Cleanup orphaned embeddings for all content types
-    cleanup_types = [
-        ContentType.STORE_AGENT,
-        ContentType.BLOCK,
-        ContentType.DOCUMENTATION,
-    ]
-
-    for content_type in cleanup_types:
-        try:
-            handler = CONTENT_HANDLERS.get(content_type)
-            if not handler:
-                logger.warning(f"No handler registered for {content_type}")
-                results_by_type[content_type.value] = {
-                    "deleted": 0,
-                    "error": "No handler registered",
-                }
-                continue
-
-            # Get all current content IDs from handler
-            if content_type == ContentType.STORE_AGENT:
-                # Get IDs of approved store listing versions from non-deleted listings
-                valid_agents = await query_raw_with_schema(
-                    """
-                    SELECT slv.id
-                    FROM {schema_prefix}"StoreListingVersion" slv
-                    JOIN {schema_prefix}"StoreListing" sl ON slv."storeListingId" = sl.id
-                    WHERE slv."submissionStatus" = 'APPROVED'
-                      AND slv."isDeleted" = false
-                      AND sl."isDeleted" = false
-                    """,
-                )
-                current_ids = {row["id"] for row in valid_agents}
-            elif content_type == ContentType.BLOCK:
-                from backend.data.block import get_blocks
-
-                current_ids = set(get_blocks().keys())
-            elif content_type == ContentType.DOCUMENTATION:
-                from pathlib import Path
-
-                # embeddings.py is at: backend/backend/api/features/store/embeddings.py
-                # Need to go up to project root then into docs/
-                this_file = Path(__file__)
-                project_root = (
-                    this_file.parent.parent.parent.parent.parent.parent.parent
-                )
-                docs_root = project_root / "docs"
-                if docs_root.exists():
-                    all_docs = list(docs_root.rglob("*.md")) + list(
-                        docs_root.rglob("*.mdx")
-                    )
-                    current_ids = {str(doc.relative_to(docs_root)) for doc in all_docs}
-                else:
-                    current_ids = set()
-            else:
-                # Skip unknown content types to avoid accidental deletion
-                logger.warning(
-                    f"Skipping cleanup for unknown content type: {content_type}"
-                )
-                results_by_type[content_type.value] = {
-                    "deleted": 0,
-                    "error": "Unknown content type - skipped for safety",
-                }
-                continue
-
-            # Get all embedding IDs from database
-            db_embeddings = await query_raw_with_schema(
-                """
-                SELECT "contentId"
-                FROM {schema_prefix}"UnifiedContentEmbedding"
-                WHERE "contentType" = $1::{schema_prefix}"ContentType"
-                """,
-                content_type,
-            )
-
-            db_ids = {row["contentId"] for row in db_embeddings}
-
-            # Find orphaned embeddings (in DB but not in current content)
-            orphaned_ids = db_ids - current_ids
-
-            if not orphaned_ids:
-                logger.info(f"{content_type.value}: No orphaned embeddings found")
-                results_by_type[content_type.value] = {
-                    "deleted": 0,
-                    "message": "No orphaned embeddings",
-                }
-                continue
-
-            # Delete orphaned embeddings in batch for better performance
-            orphaned_list = list(orphaned_ids)
-            try:
-                await execute_raw_with_schema(
-                    """
-                    DELETE FROM {schema_prefix}"UnifiedContentEmbedding"
-                    WHERE "contentType" = $1::{schema_prefix}"ContentType"
-                      AND "contentId" = ANY($2::text[])
-                    """,
-                    content_type,
-                    orphaned_list,
-                )
-                deleted = len(orphaned_list)
-            except Exception as e:
-                logger.error(f"Failed to batch delete orphaned embeddings: {e}")
-                deleted = 0
-
-            logger.info(
-                f"{content_type.value}: Deleted {deleted}/{len(orphaned_ids)} orphaned embeddings"
-            )
-            results_by_type[content_type.value] = {
-                "deleted": deleted,
-                "orphaned": len(orphaned_ids),
-                "message": f"Deleted {deleted} orphaned embeddings",
-            }
-
-            total_deleted += deleted
-
-        except Exception as e:
-            logger.error(f"Failed to cleanup {content_type.value}: {e}")
-            results_by_type[content_type.value] = {
-                "deleted": 0,
-                "error": str(e),
-            }
-
-    return {
-        "by_type": results_by_type,
-        "totals": {
-            "deleted": total_deleted,
-            "message": f"Deleted {total_deleted} orphaned embeddings",
-        },
-    }
-
-
-async def semantic_search(
-    query: str,
-    content_types: list[ContentType] | None = None,
-    user_id: str | None = None,
-    limit: int = 20,
-    min_similarity: float = 0.5,
-) -> list[dict[str, Any]]:
-    """
-    Semantic search across content types using embeddings.
-
-    Performs vector similarity search on UnifiedContentEmbedding table.
-    Used directly for blocks/docs/library agents, or as the semantic component
-    within hybrid_search for store agents.
-
-    If embedding generation fails, falls back to lexical search on searchableText.
-
-    Args:
-        query: Search query string
-        content_types: List of ContentType to search. Defaults to [BLOCK, STORE_AGENT, DOCUMENTATION]
-        user_id: Optional user ID for searching private content (library agents)
-        limit: Maximum number of results to return (default: 20)
-        min_similarity: Minimum cosine similarity threshold (0-1, default: 0.5)
-
-    Returns:
-        List of search results with the following structure:
-        [
-            {
-                "content_id": str,
-                "content_type": str,  # "BLOCK", "STORE_AGENT", "DOCUMENTATION", or "LIBRARY_AGENT"
-                "searchable_text": str,
-                "metadata": dict,
-                "similarity": float,  # Cosine similarity score (0-1)
-            },
-            ...
-        ]
-
-    Examples:
-        # Search blocks only
-        results = await semantic_search("calculate", content_types=[ContentType.BLOCK])
-
-        # Search blocks and documentation
-        results = await semantic_search(
-            "how to use API",
-            content_types=[ContentType.BLOCK, ContentType.DOCUMENTATION]
-        )
-
-        # Search all public content (default)
-        results = await semantic_search("AI agent")
-
-        # Search user's library agents
-        results = await semantic_search(
-            "my custom agent",
-            content_types=[ContentType.LIBRARY_AGENT],
-            user_id="user123"
-        )
-    """
-    # Default to searching all public content types
-    if content_types is None:
-        content_types = [
-            ContentType.BLOCK,
-            ContentType.STORE_AGENT,
-            ContentType.DOCUMENTATION,
-        ]
-
-    # Validate inputs
-    if not content_types:
-        return []  # Empty content_types would cause invalid SQL (IN ())
-
-    query = query.strip()
-    if not query:
-        return []
-
-    if limit < 1:
-        limit = 1
-    if limit > 100:
-        limit = 100
-
-    # Generate query embedding
-    query_embedding = await embed_query(query)
-
-    if query_embedding is not None:
-        # Semantic search with embeddings
-        embedding_str = embedding_to_vector_string(query_embedding)
-
-        # Build params in order: limit, then user_id (if provided), then content types
-        params: list[Any] = [limit]
-        user_filter = ""
-        if user_id is not None:
-            user_filter = 'AND "userId" = ${}'.format(len(params) + 1)
-            params.append(user_id)
-
-        # Add content type parameters and build placeholders dynamically
-        content_type_start_idx = len(params) + 1
-        content_type_placeholders = ", ".join(
-            f'${content_type_start_idx + i}::{{{{schema_prefix}}}}"ContentType"'
-            for i in range(len(content_types))
-        )
-        params.extend([ct.value for ct in content_types])
-
-        sql = f"""
-            SELECT
-                "contentId" as content_id,
-                "contentType" as content_type,
-                "searchableText" as searchable_text,
-                metadata,
-                1 - (embedding <=> '{embedding_str}'::vector) as similarity
-            FROM {{{{schema_prefix}}}}"UnifiedContentEmbedding"
-            WHERE "contentType" IN ({content_type_placeholders})
-            {user_filter}
-            AND 1 - (embedding <=> '{embedding_str}'::vector) >= ${len(params) + 1}
-            ORDER BY similarity DESC
-            LIMIT $1
-        """
-        params.append(min_similarity)
-
-        try:
-            results = await query_raw_with_schema(
-                sql, *params, set_public_search_path=True
-            )
-            return [
-                {
-                    "content_id": row["content_id"],
-                    "content_type": row["content_type"],
-                    "searchable_text": row["searchable_text"],
-                    "metadata": row["metadata"],
-                    "similarity": float(row["similarity"]),
-                }
-                for row in results
-            ]
-        except Exception as e:
-            logger.error(f"Semantic search failed: {e}")
-            # Fall through to lexical search below
-
-    # Fallback to lexical search if embeddings unavailable
-    logger.warning("Falling back to lexical search (embeddings unavailable)")
-
-    params_lexical: list[Any] = [limit]
-    user_filter = ""
-    if user_id is not None:
-        user_filter = 'AND "userId" = ${}'.format(len(params_lexical) + 1)
-        params_lexical.append(user_id)
-
-    # Add content type parameters and build placeholders dynamically
-    content_type_start_idx = len(params_lexical) + 1
-    content_type_placeholders_lexical = ", ".join(
-        f'${content_type_start_idx + i}::{{{{schema_prefix}}}}"ContentType"'
-        for i in range(len(content_types))
-    )
-    params_lexical.extend([ct.value for ct in content_types])
-
-    sql_lexical = f"""
-        SELECT
-            "contentId" as content_id,
-            "contentType" as content_type,
-            "searchableText" as searchable_text,
-            metadata,
-            0.0 as similarity
-        FROM {{{{schema_prefix}}}}"UnifiedContentEmbedding"
-        WHERE "contentType" IN ({content_type_placeholders_lexical})
-        {user_filter}
-        AND "searchableText" ILIKE ${len(params_lexical) + 1}
-        ORDER BY "updatedAt" DESC
-        LIMIT $1
-    """
-    params_lexical.append(f"%{query}%")
-
-    try:
-        results = await query_raw_with_schema(
-            sql_lexical, *params_lexical, set_public_search_path=True
-        )
-        return [
-            {
-                "content_id": row["content_id"],
-                "content_type": row["content_type"],
-                "searchable_text": row["searchable_text"],
-                "metadata": row["metadata"],
-                "similarity": 0.0,  # Lexical search doesn't provide similarity
-            }
-            for row in results
-        ]
-    except Exception as e:
-        logger.error(f"Lexical search failed: {e}")
-        return []

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

@@ -1,666 +0,0 @@
-"""
-End-to-end database tests for embeddings and hybrid search.
-
-These tests hit the actual database to verify SQL queries work correctly.
-Tests cover:
-1. Embedding storage (store_content_embedding)
-2. Embedding retrieval (get_content_embedding)
-3. Embedding deletion (delete_content_embedding)
-4. Unified hybrid search across content types
-5. Store agent hybrid search
-"""
-
-import uuid
-from typing import AsyncGenerator
-
-import pytest
-from prisma.enums import ContentType
-
-from backend.api.features.store import embeddings
-from backend.api.features.store.embeddings import EMBEDDING_DIM
-from backend.api.features.store.hybrid_search import (
-    hybrid_search,
-    unified_hybrid_search,
-)
-
-# ============================================================================
-# Test Fixtures
-# ============================================================================
-
-
-@pytest.fixture
-def test_content_id() -> str:
-    """Generate unique content ID for test isolation."""
-    return f"test-content-{uuid.uuid4()}"
-
-
-@pytest.fixture
-def test_user_id() -> str:
-    """Generate unique user ID for test isolation."""
-    return f"test-user-{uuid.uuid4()}"
-
-
-@pytest.fixture
-def mock_embedding() -> list[float]:
-    """Generate a mock embedding vector."""
-    # Create a normalized embedding vector
-    import math
-
-    raw = [float(i % 10) / 10.0 for i in range(EMBEDDING_DIM)]
-    # Normalize to unit length (required for cosine similarity)
-    magnitude = math.sqrt(sum(x * x for x in raw))
-    return [x / magnitude for x in raw]
-
-
-@pytest.fixture
-def similar_embedding() -> list[float]:
-    """Generate an embedding similar to mock_embedding."""
-    import math
-
-    # Similar but slightly different values
-    raw = [float(i % 10) / 10.0 + 0.01 for i in range(EMBEDDING_DIM)]
-    magnitude = math.sqrt(sum(x * x for x in raw))
-    return [x / magnitude for x in raw]
-
-
-@pytest.fixture
-def different_embedding() -> list[float]:
-    """Generate an embedding very different from mock_embedding."""
-    import math
-
-    # Reversed pattern to be maximally different
-    raw = [float((EMBEDDING_DIM - i) % 10) / 10.0 for i in range(EMBEDDING_DIM)]
-    magnitude = math.sqrt(sum(x * x for x in raw))
-    return [x / magnitude for x in raw]
-
-
-@pytest.fixture
-async def cleanup_embeddings(
-    server,
-) -> AsyncGenerator[list[tuple[ContentType, str, str | None]], None]:
-    """
-    Fixture that tracks created embeddings and cleans them up after tests.
-
-    Yields a list to which tests can append (content_type, content_id, user_id) tuples.
-    """
-    created_embeddings: list[tuple[ContentType, str, str | None]] = []
-    yield created_embeddings
-
-    # Cleanup all created embeddings
-    for content_type, content_id, user_id in created_embeddings:
-        try:
-            await embeddings.delete_content_embedding(content_type, content_id, user_id)
-        except Exception:
-            pass  # Ignore cleanup errors
-
-
-# ============================================================================
-# store_content_embedding Tests
-# ============================================================================
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_content_embedding_store_agent(
-    server,
-    test_content_id: str,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test storing embedding for STORE_AGENT content type."""
-    # Track for cleanup
-    cleanup_embeddings.append((ContentType.STORE_AGENT, test_content_id, None))
-
-    result = await embeddings.store_content_embedding(
-        content_type=ContentType.STORE_AGENT,
-        content_id=test_content_id,
-        embedding=mock_embedding,
-        searchable_text="AI assistant for productivity tasks",
-        metadata={"name": "Test Agent", "categories": ["productivity"]},
-        user_id=None,  # Store agents are public
-    )
-
-    assert result is True
-
-    # Verify it was stored
-    stored = await embeddings.get_content_embedding(
-        ContentType.STORE_AGENT, test_content_id, user_id=None
-    )
-    assert stored is not None
-    assert stored["contentId"] == test_content_id
-    assert stored["contentType"] == "STORE_AGENT"
-    assert stored["searchableText"] == "AI assistant for productivity tasks"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_content_embedding_block(
-    server,
-    test_content_id: str,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test storing embedding for BLOCK content type."""
-    cleanup_embeddings.append((ContentType.BLOCK, test_content_id, None))
-
-    result = await embeddings.store_content_embedding(
-        content_type=ContentType.BLOCK,
-        content_id=test_content_id,
-        embedding=mock_embedding,
-        searchable_text="HTTP request block for API calls",
-        metadata={"name": "HTTP Request Block"},
-        user_id=None,  # Blocks are public
-    )
-
-    assert result is True
-
-    stored = await embeddings.get_content_embedding(
-        ContentType.BLOCK, test_content_id, user_id=None
-    )
-    assert stored is not None
-    assert stored["contentType"] == "BLOCK"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_content_embedding_documentation(
-    server,
-    test_content_id: str,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test storing embedding for DOCUMENTATION content type."""
-    cleanup_embeddings.append((ContentType.DOCUMENTATION, test_content_id, None))
-
-    result = await embeddings.store_content_embedding(
-        content_type=ContentType.DOCUMENTATION,
-        content_id=test_content_id,
-        embedding=mock_embedding,
-        searchable_text="Getting started guide for AutoGPT platform",
-        metadata={"title": "Getting Started", "url": "/docs/getting-started"},
-        user_id=None,  # Docs are public
-    )
-
-    assert result is True
-
-    stored = await embeddings.get_content_embedding(
-        ContentType.DOCUMENTATION, test_content_id, user_id=None
-    )
-    assert stored is not None
-    assert stored["contentType"] == "DOCUMENTATION"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_store_content_embedding_upsert(
-    server,
-    test_content_id: str,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test that storing embedding twice updates instead of duplicates."""
-    cleanup_embeddings.append((ContentType.BLOCK, test_content_id, None))
-
-    # Store first time
-    result1 = await embeddings.store_content_embedding(
-        content_type=ContentType.BLOCK,
-        content_id=test_content_id,
-        embedding=mock_embedding,
-        searchable_text="Original text",
-        metadata={"version": 1},
-        user_id=None,
-    )
-    assert result1 is True
-
-    # Store again with different text (upsert)
-    result2 = await embeddings.store_content_embedding(
-        content_type=ContentType.BLOCK,
-        content_id=test_content_id,
-        embedding=mock_embedding,
-        searchable_text="Updated text",
-        metadata={"version": 2},
-        user_id=None,
-    )
-    assert result2 is True
-
-    # Verify only one record with updated text
-    stored = await embeddings.get_content_embedding(
-        ContentType.BLOCK, test_content_id, user_id=None
-    )
-    assert stored is not None
-    assert stored["searchableText"] == "Updated text"
-
-
-# ============================================================================
-# get_content_embedding Tests
-# ============================================================================
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_get_content_embedding_not_found(server):
-    """Test retrieving non-existent embedding returns None."""
-    result = await embeddings.get_content_embedding(
-        ContentType.STORE_AGENT, "non-existent-id", user_id=None
-    )
-    assert result is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_get_content_embedding_with_metadata(
-    server,
-    test_content_id: str,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test that metadata is correctly stored and retrieved."""
-    cleanup_embeddings.append((ContentType.STORE_AGENT, test_content_id, None))
-
-    metadata = {
-        "name": "Test Agent",
-        "subHeading": "A test agent",
-        "categories": ["ai", "productivity"],
-        "customField": 123,
-    }
-
-    await embeddings.store_content_embedding(
-        content_type=ContentType.STORE_AGENT,
-        content_id=test_content_id,
-        embedding=mock_embedding,
-        searchable_text="test",
-        metadata=metadata,
-        user_id=None,
-    )
-
-    stored = await embeddings.get_content_embedding(
-        ContentType.STORE_AGENT, test_content_id, user_id=None
-    )
-
-    assert stored is not None
-    assert stored["metadata"]["name"] == "Test Agent"
-    assert stored["metadata"]["categories"] == ["ai", "productivity"]
-    assert stored["metadata"]["customField"] == 123
-
-
-# ============================================================================
-# delete_content_embedding Tests
-# ============================================================================
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_delete_content_embedding(
-    server,
-    test_content_id: str,
-    mock_embedding: list[float],
-):
-    """Test deleting embedding removes it from database."""
-    # Store embedding
-    await embeddings.store_content_embedding(
-        content_type=ContentType.BLOCK,
-        content_id=test_content_id,
-        embedding=mock_embedding,
-        searchable_text="To be deleted",
-        metadata=None,
-        user_id=None,
-    )
-
-    # Verify it exists
-    stored = await embeddings.get_content_embedding(
-        ContentType.BLOCK, test_content_id, user_id=None
-    )
-    assert stored is not None
-
-    # Delete it
-    result = await embeddings.delete_content_embedding(
-        ContentType.BLOCK, test_content_id, user_id=None
-    )
-    assert result is True
-
-    # Verify it's gone
-    stored = await embeddings.get_content_embedding(
-        ContentType.BLOCK, test_content_id, user_id=None
-    )
-    assert stored is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_delete_content_embedding_not_found(server):
-    """Test deleting non-existent embedding doesn't error."""
-    result = await embeddings.delete_content_embedding(
-        ContentType.BLOCK, "non-existent-id", user_id=None
-    )
-    # Should succeed even if nothing to delete
-    assert result is True
-
-
-# ============================================================================
-# unified_hybrid_search Tests
-# ============================================================================
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_unified_hybrid_search_finds_matching_content(
-    server,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test unified search finds content matching the query."""
-    # Create unique content IDs
-    agent_id = f"test-agent-{uuid.uuid4()}"
-    block_id = f"test-block-{uuid.uuid4()}"
-    doc_id = f"test-doc-{uuid.uuid4()}"
-
-    cleanup_embeddings.append((ContentType.STORE_AGENT, agent_id, None))
-    cleanup_embeddings.append((ContentType.BLOCK, block_id, None))
-    cleanup_embeddings.append((ContentType.DOCUMENTATION, doc_id, None))
-
-    # Store embeddings for different content types
-    await embeddings.store_content_embedding(
-        content_type=ContentType.STORE_AGENT,
-        content_id=agent_id,
-        embedding=mock_embedding,
-        searchable_text="AI writing assistant for blog posts",
-        metadata={"name": "Writing Assistant"},
-        user_id=None,
-    )
-
-    await embeddings.store_content_embedding(
-        content_type=ContentType.BLOCK,
-        content_id=block_id,
-        embedding=mock_embedding,
-        searchable_text="Text generation block for creative writing",
-        metadata={"name": "Text Generator"},
-        user_id=None,
-    )
-
-    await embeddings.store_content_embedding(
-        content_type=ContentType.DOCUMENTATION,
-        content_id=doc_id,
-        embedding=mock_embedding,
-        searchable_text="How to use writing blocks in AutoGPT",
-        metadata={"title": "Writing Guide"},
-        user_id=None,
-    )
-
-    # Search for "writing" - should find all three
-    results, total = await unified_hybrid_search(
-        query="writing",
-        page=1,
-        page_size=20,
-    )
-
-    # Should find at least our test content (may find others too)
-    content_ids = [r["content_id"] for r in results]
-    assert agent_id in content_ids or total >= 1  # Lexical search should find it
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_unified_hybrid_search_filter_by_content_type(
-    server,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test unified search can filter by content type."""
-    agent_id = f"test-agent-{uuid.uuid4()}"
-    block_id = f"test-block-{uuid.uuid4()}"
-
-    cleanup_embeddings.append((ContentType.STORE_AGENT, agent_id, None))
-    cleanup_embeddings.append((ContentType.BLOCK, block_id, None))
-
-    # Store both types with same searchable text
-    await embeddings.store_content_embedding(
-        content_type=ContentType.STORE_AGENT,
-        content_id=agent_id,
-        embedding=mock_embedding,
-        searchable_text="unique_search_term_xyz123",
-        metadata={},
-        user_id=None,
-    )
-
-    await embeddings.store_content_embedding(
-        content_type=ContentType.BLOCK,
-        content_id=block_id,
-        embedding=mock_embedding,
-        searchable_text="unique_search_term_xyz123",
-        metadata={},
-        user_id=None,
-    )
-
-    # Search only for BLOCK type
-    results, total = await unified_hybrid_search(
-        query="unique_search_term_xyz123",
-        content_types=[ContentType.BLOCK],
-        page=1,
-        page_size=20,
-    )
-
-    # All results should be BLOCK type
-    for r in results:
-        assert r["content_type"] == "BLOCK"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_unified_hybrid_search_empty_query(server):
-    """Test unified search with empty query returns empty results."""
-    results, total = await unified_hybrid_search(
-        query="",
-        page=1,
-        page_size=20,
-    )
-
-    assert results == []
-    assert total == 0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_unified_hybrid_search_pagination(
-    server,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test unified search pagination works correctly."""
-    # Create multiple items
-    content_ids = []
-    for i in range(5):
-        content_id = f"test-pagination-{uuid.uuid4()}"
-        content_ids.append(content_id)
-        cleanup_embeddings.append((ContentType.BLOCK, content_id, None))
-
-        await embeddings.store_content_embedding(
-            content_type=ContentType.BLOCK,
-            content_id=content_id,
-            embedding=mock_embedding,
-            searchable_text=f"pagination test item number {i}",
-            metadata={"index": i},
-            user_id=None,
-        )
-
-    # Get first page
-    page1_results, total1 = await unified_hybrid_search(
-        query="pagination test",
-        content_types=[ContentType.BLOCK],
-        page=1,
-        page_size=2,
-    )
-
-    # Get second page
-    page2_results, total2 = await unified_hybrid_search(
-        query="pagination test",
-        content_types=[ContentType.BLOCK],
-        page=2,
-        page_size=2,
-    )
-
-    # Total should be consistent
-    assert total1 == total2
-
-    # Pages should have different content (if we have enough results)
-    if len(page1_results) > 0 and len(page2_results) > 0:
-        page1_ids = {r["content_id"] for r in page1_results}
-        page2_ids = {r["content_id"] for r in page2_results}
-        # No overlap between pages
-        assert page1_ids.isdisjoint(page2_ids)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_unified_hybrid_search_min_score_filtering(
-    server,
-    mock_embedding: list[float],
-    cleanup_embeddings: list,
-):
-    """Test unified search respects min_score threshold."""
-    content_id = f"test-minscore-{uuid.uuid4()}"
-    cleanup_embeddings.append((ContentType.BLOCK, content_id, None))
-
-    await embeddings.store_content_embedding(
-        content_type=ContentType.BLOCK,
-        content_id=content_id,
-        embedding=mock_embedding,
-        searchable_text="completely unrelated content about bananas",
-        metadata={},
-        user_id=None,
-    )
-
-    # Search with very high min_score - should filter out low relevance
-    results_high, _ = await unified_hybrid_search(
-        query="quantum computing algorithms",
-        content_types=[ContentType.BLOCK],
-        min_score=0.9,  # Very high threshold
-        page=1,
-        page_size=20,
-    )
-
-    # Search with low min_score
-    results_low, _ = await unified_hybrid_search(
-        query="quantum computing algorithms",
-        content_types=[ContentType.BLOCK],
-        min_score=0.01,  # Very low threshold
-        page=1,
-        page_size=20,
-    )
-
-    # High threshold should have fewer or equal results
-    assert len(results_high) <= len(results_low)
-
-
-# ============================================================================
-# hybrid_search (Store Agents) Tests
-# ============================================================================
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_hybrid_search_store_agents_sql_valid(server):
-    """Test that hybrid_search SQL executes without errors."""
-    # This test verifies the SQL is syntactically correct
-    # even if no results are found
-    results, total = await hybrid_search(
-        query="test agent",
-        page=1,
-        page_size=20,
-    )
-
-    # Should not raise - verifies SQL is valid
-    assert isinstance(results, list)
-    assert isinstance(total, int)
-    assert total >= 0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_hybrid_search_with_filters(server):
-    """Test hybrid_search with various filter options."""
-    # Test with all filter types
-    results, total = await hybrid_search(
-        query="productivity",
-        featured=True,
-        creators=["test-creator"],
-        category="productivity",
-        page=1,
-        page_size=10,
-    )
-
-    # Should not raise - verifies filter SQL is valid
-    assert isinstance(results, list)
-    assert isinstance(total, int)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_hybrid_search_pagination(server):
-    """Test hybrid_search pagination."""
-    # Page 1
-    results1, total1 = await hybrid_search(
-        query="agent",
-        page=1,
-        page_size=5,
-    )
-
-    # Page 2
-    results2, total2 = await hybrid_search(
-        query="agent",
-        page=2,
-        page_size=5,
-    )
-
-    # Verify SQL executes without error
-    assert isinstance(results1, list)
-    assert isinstance(results2, list)
-    assert isinstance(total1, int)
-    assert isinstance(total2, int)
-
-    # If page 1 has results, total should be > 0
-    # Note: total from page 2 may be 0 if no results on that page (COUNT(*) OVER limitation)
-    if results1:
-        assert total1 > 0
-
-
-# ============================================================================
-# SQL Validity Tests (verify queries don't break)
-# ============================================================================
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_all_content_types_searchable(server):
-    """Test that all content types can be searched without SQL errors."""
-    for content_type in [
-        ContentType.STORE_AGENT,
-        ContentType.BLOCK,
-        ContentType.DOCUMENTATION,
-    ]:
-        results, total = await unified_hybrid_search(
-            query="test",
-            content_types=[content_type],
-            page=1,
-            page_size=10,
-        )
-
-        # Should not raise
-        assert isinstance(results, list)
-        assert isinstance(total, int)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_multiple_content_types_searchable(server):
-    """Test searching multiple content types at once."""
-    results, total = await unified_hybrid_search(
-        query="test",
-        content_types=[ContentType.BLOCK, ContentType.DOCUMENTATION],
-        page=1,
-        page_size=20,
-    )
-
-    # Should not raise
-    assert isinstance(results, list)
-    assert isinstance(total, int)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_search_all_content_types_default(server):
-    """Test searching all content types (default behavior)."""
-    results, total = await unified_hybrid_search(
-        query="test",
-        content_types=None,  # Should search all
-        page=1,
-        page_size=20,
-    )
-
-    # Should not raise
-    assert isinstance(results, list)
-    assert isinstance(total, int)
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v", "-s"])

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

@@ -1,315 +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, MagicMock, patch
-
-import pytest
-from prisma.enums import ContentType
-
-from backend.api.features.store import embeddings
-from backend.api.features.store.embeddings import EMBEDDING_DIM
-
-# 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] * EMBEDDING_DIM,
-                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 via content handlers."""
-    # Mock handler to return stats
-    mock_handler = MagicMock()
-    mock_handler.get_stats = AsyncMock(
-        return_value={
-            "total": 100,
-            "with_embeddings": 80,
-            "without_embeddings": 20,
-        }
-    )
-
-    with patch(
-        "backend.api.features.store.embeddings.CONTENT_HANDLERS",
-        {ContentType.STORE_AGENT: mock_handler},
-    ):
-        result = await embeddings.get_embedding_stats()
-
-        # Verify handler was called
-        mock_handler.get_stats.assert_called_once()
-
-        # Verify new result structure
-        assert "by_type" in result
-        assert "totals" in result
-        assert result["totals"]["total"] == 100
-        assert result["totals"]["with_embeddings"] == 80
-        assert result["totals"]["without_embeddings"] == 20
-        assert result["totals"]["coverage_percent"] == 80.0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_backfill_missing_embeddings_with_schema():
-    """Test backfilling embeddings via content handlers."""
-    from backend.api.features.store.content_handlers import ContentItem
-
-    # Create mock content item
-    mock_item = ContentItem(
-        content_id="version-1",
-        content_type=ContentType.STORE_AGENT,
-        searchable_text="Test Agent Test description",
-        metadata={"name": "Test Agent"},
-    )
-
-    # Mock handler
-    mock_handler = MagicMock()
-    mock_handler.get_missing_items = AsyncMock(return_value=[mock_item])
-
-    with patch(
-        "backend.api.features.store.embeddings.CONTENT_HANDLERS",
-        {ContentType.STORE_AGENT: mock_handler},
-    ):
-        with patch(
-            "backend.api.features.store.embeddings.generate_embedding",
-            return_value=[0.1] * EMBEDDING_DIM,
-        ):
-            with patch(
-                "backend.api.features.store.embeddings.store_content_embedding",
-                return_value=True,
-            ):
-                result = await embeddings.backfill_missing_embeddings(batch_size=10)
-
-                # Verify handler was called
-                mock_handler.get_missing_items.assert_called_once_with(10)
-
-                # 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] * EMBEDDING_DIM
-
-                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] * EMBEDDING_DIM,
-            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] * EMBEDDING_DIM,
-                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,407 +0,0 @@
-from unittest.mock import AsyncMock, 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")
-async def test_generate_embedding_success():
-    """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
-
-    # Use AsyncMock for async embeddings.create method
-    mock_client.embeddings.create = AsyncMock(return_value=mock_response)
-
-    # Patch at the point of use in embeddings.py
-    with patch(
-        "backend.api.features.store.embeddings.get_openai_client"
-    ) as mock_get_client:
-        mock_get_client.return_value = mock_client
-
-        result = await embeddings.generate_embedding("test text")
-
-        assert result is not None
-        assert len(result) == embeddings.EMBEDDING_DIM
-        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")
-async def test_generate_embedding_no_api_key():
-    """Test embedding generation without API key."""
-    # Patch at the point of use in embeddings.py
-    with patch(
-        "backend.api.features.store.embeddings.get_openai_client"
-    ) as mock_get_client:
-        mock_get_client.return_value = None
-
-        result = await embeddings.generate_embedding("test text")
-
-        assert result is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_generate_embedding_api_error():
-    """Test embedding generation with API error."""
-    mock_client = MagicMock()
-    mock_client.embeddings.create = AsyncMock(side_effect=Exception("API Error"))
-
-    # Patch at the point of use in embeddings.py
-    with patch(
-        "backend.api.features.store.embeddings.get_openai_client"
-    ) as mock_get_client:
-        mock_get_client.return_value = mock_client
-
-        result = await embeddings.generate_embedding("test text")
-
-        assert result is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_generate_embedding_text_truncation():
-    """Test that long text is properly truncated using tiktoken."""
-    from tiktoken import encoding_for_model
-
-    mock_client = MagicMock()
-    mock_response = MagicMock()
-    mock_response.data = [MagicMock()]
-    mock_response.data[0].embedding = [0.1] * embeddings.EMBEDDING_DIM
-
-    # Use AsyncMock for async embeddings.create method
-    mock_client.embeddings.create = AsyncMock(return_value=mock_response)
-
-    # Patch at the point of use in embeddings.py
-    with patch(
-        "backend.api.features.store.embeddings.get_openai_client"
-    ) as mock_get_client:
-        mock_get_client.return_value = mock_client
-
-        # Create text that will exceed 8191 tokens
-        # Use varied characters to ensure token-heavy text: each word is ~1 token
-        words = [f"word{i}" for i in range(10000)]
-        long_text = " ".join(words)  # ~10000 tokens
-
-        await embeddings.generate_embedding(long_text)
-
-        # Verify text was truncated to 8191 tokens
-        call_args = mock_client.embeddings.create.call_args
-        truncated_text = call_args.kwargs["input"]
-
-        # Count actual tokens in truncated text
-        enc = encoding_for_model("text-embedding-3-small")
-        actual_tokens = len(enc.encode(truncated_text))
-
-        # Should be at or just under 8191 tokens
-        assert actual_tokens <= 8191
-        # Should be close to the limit (not over-truncated)
-        assert actual_tokens >= 8100
-
-
-@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
-    # execute_raw is called twice: once for SET search_path, once for INSERT
-    assert mock_client.execute_raw.call_count == 2
-
-    # First call: SET search_path
-    first_call_args = mock_client.execute_raw.call_args_list[0][0]
-    assert "SET search_path" in first_call_args[0]
-
-    # Second call: INSERT query with the actual data
-    second_call_args = mock_client.execute_raw.call_args_list[1][0]
-    assert "test-version-id" in second_call_args
-    assert "[0.1,0.2,0.3]" in second_call_args
-    assert None in second_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():
-    """Test successful embedding retrieval."""
-    mock_result = [
-        {
-            "contentType": "STORE_AGENT",
-            "contentId": "test-version-id",
-            "userId": None,
-            "embedding": "[0.1,0.2,0.3]",
-            "searchableText": "Test text",
-            "metadata": {},
-            "createdAt": "2024-01-01T00:00:00Z",
-            "updatedAt": "2024-01-01T00:00:00Z",
-        }
-    ]
-
-    with patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=mock_result,
-    ):
-        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():
-    """Test embedding retrieval when not found."""
-    with patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=[],
-    ):
-        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():
-    """Test embedding statistics retrieval."""
-    # Mock handler stats for each content type
-    mock_handler = MagicMock()
-    mock_handler.get_stats = AsyncMock(
-        return_value={
-            "total": 100,
-            "with_embeddings": 75,
-            "without_embeddings": 25,
-        }
-    )
-
-    # Patch the CONTENT_HANDLERS where it's used (in embeddings module)
-    with patch(
-        "backend.api.features.store.embeddings.CONTENT_HANDLERS",
-        {ContentType.STORE_AGENT: mock_handler},
-    ):
-        result = await embeddings.get_embedding_stats()
-
-        assert "by_type" in result
-        assert "totals" in result
-        assert result["totals"]["total"] == 100
-        assert result["totals"]["with_embeddings"] == 75
-        assert result["totals"]["without_embeddings"] == 25
-        assert result["totals"]["coverage_percent"] == 75.0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@patch("backend.api.features.store.embeddings.store_content_embedding")
-async def test_backfill_missing_embeddings_success(mock_store):
-    """Test backfill with successful embedding generation."""
-    # Mock ContentItem from handlers
-    from backend.api.features.store.content_handlers import ContentItem
-
-    mock_items = [
-        ContentItem(
-            content_id="version-1",
-            content_type=ContentType.STORE_AGENT,
-            searchable_text="Agent 1 Description 1",
-            metadata={"name": "Agent 1"},
-        ),
-        ContentItem(
-            content_id="version-2",
-            content_type=ContentType.STORE_AGENT,
-            searchable_text="Agent 2 Description 2",
-            metadata={"name": "Agent 2"},
-        ),
-    ]
-
-    # Mock handler to return missing items
-    mock_handler = MagicMock()
-    mock_handler.get_missing_items = AsyncMock(return_value=mock_items)
-
-    # Mock store_content_embedding to succeed for first, fail for second
-    mock_store.side_effect = [True, False]
-
-    with patch(
-        "backend.api.features.store.embeddings.CONTENT_HANDLERS",
-        {ContentType.STORE_AGENT: mock_handler},
-    ):
-        with patch(
-            "backend.api.features.store.embeddings.generate_embedding",
-            return_value=[0.1] * embeddings.EMBEDDING_DIM,
-        ):
-            result = await embeddings.backfill_missing_embeddings(batch_size=5)
-
-            assert result["processed"] == 2
-            assert result["success"] == 1
-            assert result["failed"] == 1
-            assert mock_store.call_count == 2
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_backfill_missing_embeddings_no_missing():
-    """Test backfill when no embeddings are missing."""
-    # Mock handler to return no missing items
-    mock_handler = MagicMock()
-    mock_handler.get_missing_items = AsyncMock(return_value=[])
-
-    with patch(
-        "backend.api.features.store.embeddings.CONTENT_HANDLERS",
-        {ContentType.STORE_AGENT: mock_handler},
-    ):
-        result = await embeddings.backfill_missing_embeddings(batch_size=5)
-
-        assert result["processed"] == 0
-        assert result["success"] == 0
-        assert result["failed"] == 0
-
-
-@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,625 +0,0 @@
-"""
-Unified Hybrid Search
-
-Combines semantic (embedding) search with lexical (tsvector) search
-for improved relevance across all content types (agents, blocks, docs).
-"""
-
-import logging
-from dataclasses import dataclass
-from typing import Any, Literal
-
-from prisma.enums import ContentType
-
-from backend.api.features.store.embeddings import (
-    EMBEDDING_DIM,
-    embed_query,
-    embedding_to_vector_string,
-)
-from backend.data.db import query_raw_with_schema
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class UnifiedSearchWeights:
-    """Weights for unified search (no popularity signal)."""
-
-    semantic: float = 0.40  # Embedding cosine similarity
-    lexical: float = 0.40  # tsvector ts_rank_cd score
-    category: float = 0.10  # Category match boost (for types that have categories)
-    recency: float = 0.10  # Newer content ranked higher
-
-    def __post_init__(self):
-        """Validate weights are non-negative and sum to approximately 1.0."""
-        total = self.semantic + self.lexical + self.category + self.recency
-
-        if any(
-            w < 0 for w in [self.semantic, self.lexical, self.category, self.recency]
-        ):
-            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 for unified search
-DEFAULT_UNIFIED_WEIGHTS = UnifiedSearchWeights()
-
-# Minimum relevance score thresholds
-DEFAULT_MIN_SCORE = 0.15  # For unified search (more permissive)
-DEFAULT_STORE_AGENT_MIN_SCORE = 0.20  # For store agent search (original threshold)
-
-
-async def unified_hybrid_search(
-    query: str,
-    content_types: list[ContentType] | None = None,
-    category: str | None = None,
-    page: int = 1,
-    page_size: int = 20,
-    weights: UnifiedSearchWeights | None = None,
-    min_score: float | None = None,
-    user_id: str | None = None,
-) -> tuple[list[dict[str, Any]], int]:
-    """
-    Unified hybrid search across all content types.
-
-    Searches UnifiedContentEmbedding using both semantic (vector) and lexical (tsvector) signals.
-
-    Args:
-        query: Search query string
-        content_types: List of content types to search. Defaults to all public types.
-        category: Filter by category (for content types that support it)
-        page: Page number (1-indexed)
-        page_size: Results per page
-        weights: Custom weights for search signals
-        min_score: Minimum relevance score threshold (0-1)
-        user_id: User ID for searching private content (library agents)
-
-    Returns:
-        Tuple of (results list, total count)
-    """
-    # Validate inputs
-    query = query.strip()
-    if not query:
-        return [], 0
-
-    if page < 1:
-        page = 1
-    if page_size < 1:
-        page_size = 1
-    if page_size > 100:
-        page_size = 100
-
-    if content_types is None:
-        content_types = [
-            ContentType.STORE_AGENT,
-            ContentType.BLOCK,
-            ContentType.DOCUMENTATION,
-        ]
-
-    if weights is None:
-        weights = DEFAULT_UNIFIED_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)
-
-    # Graceful degradation if embedding unavailable
-    if query_embedding is None or not query_embedding:
-        logger.warning(
-            "Failed to generate query embedding - falling back to lexical-only search. "
-            "Check that openai_internal_api_key is configured and OpenAI API is accessible."
-        )
-        query_embedding = [0.0] * EMBEDDING_DIM
-        # Redistribute semantic weight to lexical
-        total_non_semantic = weights.lexical + weights.category + weights.recency
-        if total_non_semantic > 0:
-            factor = 1.0 / total_non_semantic
-            weights = UnifiedSearchWeights(
-                semantic=0.0,
-                lexical=weights.lexical * factor,
-                category=weights.category * factor,
-                recency=weights.recency * factor,
-            )
-        else:
-            weights = UnifiedSearchWeights(
-                semantic=0.0, lexical=1.0, category=0.0, recency=0.0
-            )
-
-    # Build parameters
-    params: list[Any] = []
-    param_idx = 1
-
-    # Query for lexical search
-    params.append(query)
-    query_param = f"${param_idx}"
-    param_idx += 1
-
-    # Query lowercase for category matching
-    params.append(query.lower())
-    query_lower_param = f"${param_idx}"
-    param_idx += 1
-
-    # Embedding
-    embedding_str = embedding_to_vector_string(query_embedding)
-    params.append(embedding_str)
-    embedding_param = f"${param_idx}"
-    param_idx += 1
-
-    # Content types
-    content_type_values = [ct.value for ct in content_types]
-    params.append(content_type_values)
-    content_types_param = f"${param_idx}"
-    param_idx += 1
-
-    # User ID filter (for private content)
-    user_filter = ""
-    if user_id is not None:
-        params.append(user_id)
-        user_filter = f'AND (uce."userId" = ${param_idx} OR uce."userId" IS NULL)'
-        param_idx += 1
-    else:
-        user_filter = 'AND uce."userId" IS NULL'
-
-    # Weights
-    params.append(weights.semantic)
-    w_semantic = f"${param_idx}"
-    param_idx += 1
-
-    params.append(weights.lexical)
-    w_lexical = f"${param_idx}"
-    param_idx += 1
-
-    params.append(weights.category)
-    w_category = f"${param_idx}"
-    param_idx += 1
-
-    params.append(weights.recency)
-    w_recency = f"${param_idx}"
-    param_idx += 1
-
-    # Min score
-    params.append(min_score)
-    min_score_param = f"${param_idx}"
-    param_idx += 1
-
-    # Pagination
-    params.append(page_size)
-    limit_param = f"${param_idx}"
-    param_idx += 1
-
-    params.append(offset)
-    offset_param = f"${param_idx}"
-    param_idx += 1
-
-    # Unified search query on UnifiedContentEmbedding
-    sql_query = f"""
-        WITH candidates AS (
-            -- Lexical matches (uses GIN index on search column)
-            SELECT uce.id, uce."contentType", uce."contentId"
-            FROM {{schema_prefix}}"UnifiedContentEmbedding" uce
-            WHERE uce."contentType" = ANY({content_types_param}::{{schema_prefix}}"ContentType"[])
-            {user_filter}
-            AND uce.search @@ plainto_tsquery('english', {query_param})
-
-            UNION
-
-            -- Semantic matches (uses HNSW index on embedding)
-            (
-                SELECT uce.id, uce."contentType", uce."contentId"
-                FROM {{schema_prefix}}"UnifiedContentEmbedding" uce
-                WHERE uce."contentType" = ANY({content_types_param}::{{schema_prefix}}"ContentType"[])
-                {user_filter}
-                ORDER BY uce.embedding <=> {embedding_param}::vector
-                LIMIT 200
-            )
-        ),
-        search_scores AS (
-            SELECT
-                uce."contentType" as content_type,
-                uce."contentId" as content_id,
-                uce."searchableText" as searchable_text,
-                uce.metadata,
-                uce."updatedAt" as updated_at,
-                -- Semantic score: cosine similarity (1 - distance)
-                COALESCE(1 - (uce.embedding <=> {embedding_param}::vector), 0) as semantic_score,
-                -- Lexical score: ts_rank_cd
-                COALESCE(ts_rank_cd(uce.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
-                -- Category match from metadata
-                CASE
-                    WHEN uce.metadata ? 'categories' AND EXISTS (
-                        SELECT 1 FROM jsonb_array_elements_text(uce.metadata->'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
-                GREATEST(0, 1 - EXTRACT(EPOCH FROM (NOW() - uce."updatedAt")) / (90 * 24 * 3600)) as recency_score
-            FROM candidates c
-            INNER JOIN {{schema_prefix}}"UnifiedContentEmbedding" uce ON c.id = uce.id
-        ),
-        max_lexical AS (
-            SELECT GREATEST(MAX(lexical_raw), 0.001) as max_val FROM search_scores
-        ),
-        normalized AS (
-            SELECT
-                ss.*,
-                ss.lexical_raw / ml.max_val as lexical_score
-            FROM search_scores ss
-            CROSS JOIN max_lexical ml
-        ),
-        scored AS (
-            SELECT
-                content_type,
-                content_id,
-                searchable_text,
-                metadata,
-                updated_at,
-                semantic_score,
-                lexical_score,
-                category_score,
-                recency_score,
-                (
-                    {w_semantic} * semantic_score +
-                    {w_lexical} * lexical_score +
-                    {w_category} * category_score +
-                    {w_recency} * recency_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 {limit_param} OFFSET {offset_param}
-    """
-
-    results = await query_raw_with_schema(
-        sql_query, *params, set_public_search_path=True
-    )
-
-    total = results[0]["total_count"] if results else 0
-
-    # Clean up results
-    for result in results:
-        result.pop("total_count", None)
-
-    logger.info(f"Unified hybrid search: {len(results)} results, {total} total")
-
-    return results, total
-
-
-# ============================================================================
-# Store Agent specific search (with full metadata)
-# ============================================================================
-
-
-@dataclass
-class StoreAgentSearchWeights:
-    """Weights for store agent search including popularity."""
-
-    semantic: float = 0.30
-    lexical: float = 0.30
-    category: float = 0.20
-    recency: float = 0.10
-    popularity: float = 0.10
-
-    def __post_init__(self):
-        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_STORE_AGENT_WEIGHTS = StoreAgentSearchWeights()
-
-
-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: StoreAgentSearchWeights | None = None,
-    min_score: float | None = None,
-) -> tuple[list[dict[str, Any]], int]:
-    """
-    Hybrid search for store agents with full metadata.
-
-    Uses UnifiedContentEmbedding for search, joins to StoreAgent for metadata.
-    """
-    query = query.strip()
-    if not query:
-        return [], 0
-
-    if page < 1:
-        page = 1
-    if page_size < 1:
-        page_size = 1
-    if page_size > 100:
-        page_size = 100
-
-    if weights is None:
-        weights = DEFAULT_STORE_AGENT_WEIGHTS
-    if min_score is None:
-        min_score = (
-            DEFAULT_STORE_AGENT_MIN_SCORE  # Use original threshold for store agents
-        )
-
-    offset = (page - 1) * page_size
-
-    # Generate query embedding
-    query_embedding = await embed_query(query)
-
-    # Graceful degradation
-    if query_embedding is None or not query_embedding:
-        logger.warning(
-            "Failed to generate query embedding - falling back to lexical-only search."
-        )
-        query_embedding = [0.0] * EMBEDDING_DIM
-        total_non_semantic = (
-            weights.lexical + weights.category + weights.recency + weights.popularity
-        )
-        if total_non_semantic > 0:
-            factor = 1.0 / total_non_semantic
-            weights = StoreAgentSearchWeights(
-                semantic=0.0,
-                lexical=weights.lexical * factor,
-                category=weights.category * factor,
-                recency=weights.recency * factor,
-                popularity=weights.popularity * factor,
-            )
-        else:
-            weights = StoreAgentSearchWeights(
-                semantic=0.0, lexical=1.0, category=0.0, recency=0.0, popularity=0.0
-            )
-
-    # Build parameters
-    params: list[Any] = []
-    param_idx = 1
-
-    params.append(query)
-    query_param = f"${param_idx}"
-    param_idx += 1
-
-    params.append(query.lower())
-    query_lower_param = f"${param_idx}"
-    param_idx += 1
-
-    embedding_str = embedding_to_vector_string(query_embedding)
-    params.append(embedding_str)
-    embedding_param = f"${param_idx}"
-    param_idx += 1
-
-    # Build WHERE clause for StoreAgent filters
-    where_parts = ["sa.is_available = true"]
-
-    if featured:
-        where_parts.append("sa.featured = true")
-
-    if creators:
-        params.append(creators)
-        where_parts.append(f"sa.creator_username = ANY(${param_idx})")
-        param_idx += 1
-
-    if category:
-        params.append(category)
-        where_parts.append(f"${param_idx} = ANY(sa.categories)")
-        param_idx += 1
-
-    where_clause = " AND ".join(where_parts)
-
-    # Weights
-    params.append(weights.semantic)
-    w_semantic = f"${param_idx}"
-    param_idx += 1
-
-    params.append(weights.lexical)
-    w_lexical = f"${param_idx}"
-    param_idx += 1
-
-    params.append(weights.category)
-    w_category = f"${param_idx}"
-    param_idx += 1
-
-    params.append(weights.recency)
-    w_recency = f"${param_idx}"
-    param_idx += 1
-
-    params.append(weights.popularity)
-    w_popularity = f"${param_idx}"
-    param_idx += 1
-
-    params.append(min_score)
-    min_score_param = f"${param_idx}"
-    param_idx += 1
-
-    params.append(page_size)
-    limit_param = f"${param_idx}"
-    param_idx += 1
-
-    params.append(offset)
-    offset_param = f"${param_idx}"
-    param_idx += 1
-
-    # Query using UnifiedContentEmbedding for search, StoreAgent for metadata
-    sql_query = f"""
-        WITH candidates AS (
-            -- Lexical matches via UnifiedContentEmbedding.search
-            SELECT uce."contentId" as "storeListingVersionId"
-            FROM {{schema_prefix}}"UnifiedContentEmbedding" uce
-            INNER JOIN {{schema_prefix}}"StoreAgent" sa
-                ON uce."contentId" = sa."storeListingVersionId"
-            WHERE uce."contentType" = 'STORE_AGENT'::{{schema_prefix}}"ContentType"
-            AND uce."userId" IS NULL
-            AND uce.search @@ plainto_tsquery('english', {query_param})
-            AND {where_clause}
-
-            UNION
-
-            -- Semantic matches via UnifiedContentEmbedding.embedding
-            SELECT uce."contentId" as "storeListingVersionId"
-            FROM (
-                SELECT uce."contentId", uce.embedding
-                FROM {{schema_prefix}}"UnifiedContentEmbedding" uce
-                INNER JOIN {{schema_prefix}}"StoreAgent" sa
-                    ON uce."contentId" = sa."storeListingVersionId"
-                WHERE uce."contentType" = 'STORE_AGENT'::{{schema_prefix}}"ContentType"
-                AND uce."userId" IS NULL
-                AND {where_clause}
-                ORDER BY uce.embedding <=> {embedding_param}::vector
-                LIMIT 200
-            ) uce
-        ),
-        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
-                COALESCE(1 - (uce.embedding <=> {embedding_param}::vector), 0) as semantic_score,
-                -- Lexical score (raw, will normalize)
-                COALESCE(ts_rank_cd(uce.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
-                -- Category match
-                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
-                GREATEST(0, 1 - EXTRACT(EPOCH FROM (NOW() - sa.updated_at)) / (90 * 24 * 3600)) as recency_score,
-                -- Popularity (raw)
-                sa.runs as popularity_raw
-            FROM candidates c
-            INNER JOIN {{schema_prefix}}"StoreAgent" sa
-                ON c."storeListingVersionId" = sa."storeListingVersionId"
-            INNER JOIN {{schema_prefix}}"UnifiedContentEmbedding" uce
-                ON sa."storeListingVersionId" = uce."contentId"
-                AND uce."contentType" = 'STORE_AGENT'::{{schema_prefix}}"ContentType"
-        ),
-        max_vals AS (
-            SELECT
-                GREATEST(MAX(lexical_raw), 0.001) as max_lexical,
-                GREATEST(MAX(popularity_raw), 1) as max_popularity
-            FROM search_scores
-        ),
-        normalized AS (
-            SELECT
-                ss.*,
-                ss.lexical_raw / mv.max_lexical as lexical_score,
-                CASE
-                    WHEN ss.popularity_raw > 0
-                    THEN LN(1 + ss.popularity_raw) / LN(1 + mv.max_popularity)
-                    ELSE 0
-                END as popularity_score
-            FROM search_scores ss
-            CROSS JOIN max_vals mv
-        ),
-        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,
-                (
-                    {w_semantic} * semantic_score +
-                    {w_lexical} * lexical_score +
-                    {w_category} * category_score +
-                    {w_recency} * recency_score +
-                    {w_popularity} * 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 {limit_param} OFFSET {offset_param}
-    """
-
-    results = await query_raw_with_schema(
-        sql_query, *params, set_public_search_path=True
-    )
-
-    total = results[0]["total_count"] if results else 0
-
-    for result in results:
-        result.pop("total_count", None)
-
-    logger.info(f"Hybrid search (store agents): {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 store agents."""
-    return await hybrid_search(query=query, page=page, page_size=page_size)
-
-
-# Backward compatibility alias - HybridSearchWeights maps to StoreAgentSearchWeights
-# for existing code that expects the popularity parameter
-HybridSearchWeights = StoreAgentSearchWeights

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

@@ -1,667 +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 prisma.enums import ContentType
-
-from backend.api.features.store import embeddings
-from backend.api.features.store.hybrid_search import (
-    HybridSearchWeights,
-    UnifiedSearchWeights,
-    hybrid_search,
-    unified_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] * embeddings.EMBEDDING_DIM  # 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] * embeddings.EMBEDDING_DIM
-
-                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] * embeddings.EMBEDDING_DIM
-
-                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 gracefully degrades when embeddings are unavailable."""
-    # Mock database to return some results
-    mock_results = [
-        {
-            "slug": "test-agent",
-            "agent_name": "Test Agent",
-            "agent_image": "test.png",
-            "creator_username": "creator",
-            "creator_avatar": "avatar.png",
-            "sub_heading": "Test heading",
-            "description": "Test description",
-            "runs": 100,
-            "rating": 4.5,
-            "categories": ["AI"],
-            "featured": False,
-            "is_available": True,
-            "updated_at": "2025-01-01T00:00:00Z",
-            "semantic_score": 0.0,  # Zero because no embedding
-            "lexical_score": 0.5,
-            "category_score": 0.0,
-            "recency_score": 0.1,
-            "popularity_score": 0.2,
-            "combined_score": 0.3,
-            "total_count": 1,
-        }
-    ]
-
-    with patch("backend.api.features.store.hybrid_search.embed_query") as mock_embed:
-        with patch(
-            "backend.api.features.store.hybrid_search.query_raw_with_schema"
-        ) as mock_query:
-            # Simulate embedding failure
-            mock_embed.return_value = None
-            mock_query.return_value = mock_results
-
-            # Should NOT raise - graceful degradation
-            results, total = await hybrid_search(
-                query="test",
-                page=1,
-                page_size=20,
-            )
-
-            # Verify it returns results even without embeddings
-            assert len(results) == 1
-            assert results[0]["slug"] == "test-agent"
-            assert total == 1
-
-
-@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] * embeddings.EMBEDDING_DIM
-
-            # 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] * embeddings.EMBEDDING_DIM
-
-            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] * embeddings.EMBEDDING_DIM
-
-            # 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] * embeddings.EMBEDDING_DIM
-
-            # 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] * embeddings.EMBEDDING_DIM
-
-            # 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)
-
-
-# =============================================================================
-# Unified Hybrid Search Tests
-# =============================================================================
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_basic():
-    """Test basic unified hybrid search across all content types."""
-    mock_results = [
-        {
-            "content_type": "STORE_AGENT",
-            "content_id": "agent-1",
-            "searchable_text": "Test Agent Description",
-            "metadata": {"name": "Test Agent"},
-            "updated_at": "2025-01-01T00:00:00Z",
-            "semantic_score": 0.7,
-            "lexical_score": 0.8,
-            "category_score": 0.5,
-            "recency_score": 0.3,
-            "combined_score": 0.6,
-            "total_count": 2,
-        },
-        {
-            "content_type": "BLOCK",
-            "content_id": "block-1",
-            "searchable_text": "Test Block Description",
-            "metadata": {"name": "Test Block"},
-            "updated_at": "2025-01-01T00:00:00Z",
-            "semantic_score": 0.6,
-            "lexical_score": 0.7,
-            "category_score": 0.4,
-            "recency_score": 0.2,
-            "combined_score": 0.5,
-            "total_count": 2,
-        },
-    ]
-
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_query.return_value = mock_results
-            mock_embed.return_value = [0.1] * embeddings.EMBEDDING_DIM
-
-            results, total = await unified_hybrid_search(
-                query="test",
-                page=1,
-                page_size=20,
-            )
-
-            assert len(results) == 2
-            assert total == 2
-            assert results[0]["content_type"] == "STORE_AGENT"
-            assert results[1]["content_type"] == "BLOCK"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_filter_by_content_type():
-    """Test unified search filtering by specific content types."""
-    mock_results = [
-        {
-            "content_type": "BLOCK",
-            "content_id": "block-1",
-            "searchable_text": "Test Block",
-            "metadata": {},
-            "updated_at": "2025-01-01T00:00:00Z",
-            "semantic_score": 0.7,
-            "lexical_score": 0.8,
-            "category_score": 0.0,
-            "recency_score": 0.3,
-            "combined_score": 0.5,
-            "total_count": 1,
-        },
-    ]
-
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_query.return_value = mock_results
-            mock_embed.return_value = [0.1] * embeddings.EMBEDDING_DIM
-
-            results, total = await unified_hybrid_search(
-                query="test",
-                content_types=[ContentType.BLOCK],
-                page=1,
-                page_size=20,
-            )
-
-            # Verify content_types parameter was passed correctly
-            call_args = mock_query.call_args
-            params = call_args[0][1:]
-            # The content types should be in the params as a list
-            assert ["BLOCK"] in params
-
-            assert len(results) == 1
-            assert total == 1
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_with_user_id():
-    """Test unified search with user_id for private content."""
-    mock_results = [
-        {
-            "content_type": "STORE_AGENT",
-            "content_id": "agent-1",
-            "searchable_text": "My Private Agent",
-            "metadata": {},
-            "updated_at": "2025-01-01T00:00:00Z",
-            "semantic_score": 0.7,
-            "lexical_score": 0.8,
-            "category_score": 0.0,
-            "recency_score": 0.3,
-            "combined_score": 0.6,
-            "total_count": 1,
-        },
-    ]
-
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_query.return_value = mock_results
-            mock_embed.return_value = [0.1] * embeddings.EMBEDDING_DIM
-
-            results, total = await unified_hybrid_search(
-                query="test",
-                user_id="user-123",
-                page=1,
-                page_size=20,
-            )
-
-            # Verify SQL contains user_id filter
-            call_args = mock_query.call_args
-            sql_template = call_args[0][0]
-            params = call_args[0][1:]
-
-            assert 'uce."userId"' in sql_template
-            assert "user-123" in params
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_custom_weights():
-    """Test unified search with custom weights."""
-    custom_weights = UnifiedSearchWeights(
-        semantic=0.6,
-        lexical=0.2,
-        category=0.1,
-        recency=0.1,
-    )
-
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_query.return_value = []
-            mock_embed.return_value = [0.1] * embeddings.EMBEDDING_DIM
-
-            results, total = await unified_hybrid_search(
-                query="test",
-                weights=custom_weights,
-                page=1,
-                page_size=20,
-            )
-
-            # Verify custom weights are in parameters
-            call_args = mock_query.call_args
-            params = call_args[0][1:]
-
-            assert 0.6 in params  # semantic weight
-            assert 0.2 in params  # lexical weight
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_graceful_degradation():
-    """Test unified search gracefully degrades when embeddings unavailable."""
-    mock_results = [
-        {
-            "content_type": "DOCUMENTATION",
-            "content_id": "doc-1",
-            "searchable_text": "API Documentation",
-            "metadata": {},
-            "updated_at": "2025-01-01T00:00:00Z",
-            "semantic_score": 0.0,  # Zero because no embedding
-            "lexical_score": 0.8,
-            "category_score": 0.0,
-            "recency_score": 0.2,
-            "combined_score": 0.5,
-            "total_count": 1,
-        },
-    ]
-
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_query.return_value = mock_results
-            mock_embed.return_value = None  # Embedding failure
-
-            # Should NOT raise - graceful degradation
-            results, total = await unified_hybrid_search(
-                query="test",
-                page=1,
-                page_size=20,
-            )
-
-            assert len(results) == 1
-            assert total == 1
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_empty_query():
-    """Test unified search with empty query returns empty results."""
-    results, total = await unified_hybrid_search(
-        query="",
-        page=1,
-        page_size=20,
-    )
-
-    assert results == []
-    assert total == 0
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_pagination():
-    """Test unified search pagination."""
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_query.return_value = []
-            mock_embed.return_value = [0.1] * embeddings.EMBEDDING_DIM
-
-            results, total = await unified_hybrid_search(
-                query="test",
-                page=3,
-                page_size=15,
-            )
-
-            # Verify pagination parameters (last two params are LIMIT and OFFSET)
-            call_args = mock_query.call_args
-            params = call_args[0]
-
-            limit = params[-2]
-            offset = params[-1]
-
-            assert limit == 15  # page_size
-            assert offset == 30  # (page - 1) * page_size = (3 - 1) * 15
-
-
-@pytest.mark.asyncio(loop_scope="session")
-@pytest.mark.integration
-async def test_unified_hybrid_search_schema_prefix():
-    """Test unified search uses schema_prefix placeholder."""
-    with patch(
-        "backend.api.features.store.hybrid_search.query_raw_with_schema"
-    ) as mock_query:
-        with patch(
-            "backend.api.features.store.hybrid_search.embed_query"
-        ) as mock_embed:
-            mock_query.return_value = []
-            mock_embed.return_value = [0.1] * embeddings.EMBEDDING_DIM
-
-            await unified_hybrid_search(
-                query="test",
-                page=1,
-                page_size=20,
-            )
-
-            call_args = mock_query.call_args
-            sql_template = call_args[0][0]
-
-            # Verify schema_prefix placeholder is used for table references
-            assert "{schema_prefix}" in sql_template
-            assert '"UnifiedContentEmbedding"' in sql_template
-
-
-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
@@ -221,23 +216,3 @@ class ReviewSubmissionRequest(pydantic.BaseModel):
     is_approved: bool
     comments: str  # External comments visible to creator
     internal_comments: str | None = None  # Private admin notes
-
-
-class UnifiedSearchResult(pydantic.BaseModel):
-    """A single result from unified hybrid search across all content types."""
-
-    content_type: str  # STORE_AGENT, BLOCK, DOCUMENTATION
-    content_id: str
-    searchable_text: str
-    metadata: dict | None = None
-    updated_at: datetime.datetime | None = None
-    combined_score: float | None = None
-    semantic_score: float | None = None
-    lexical_score: float | None = None
-
-
-class UnifiedSearchResponse(pydantic.BaseModel):
-    """Response model for unified search across all content types."""
-
-    results: list[UnifiedSearchResult]
-    pagination: Pagination

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.py

@@ -7,15 +7,12 @@ from typing import Literal
 import autogpt_libs.auth
 import fastapi
 import fastapi.responses
-import prisma.enums
 
 import backend.data.graph
 import backend.util.json
-from backend.util.models import Pagination
 
 from . import cache as store_cache
 from . import db as store_db
-from . import hybrid_search as store_hybrid_search
 from . import image_gen as store_image_gen
 from . import media as store_media
 from . import model as store_model
@@ -149,102 +146,6 @@ async def get_agents(
     return agents
 
 
-##############################################
-############### Search Endpoints #############
-##############################################
-
-
-@router.get(
-    "/search",
-    summary="Unified search across all content types",
-    tags=["store", "public"],
-    response_model=store_model.UnifiedSearchResponse,
-)
-async def unified_search(
-    query: str,
-    content_types: list[str] | None = fastapi.Query(
-        default=None,
-        description="Content types to search: STORE_AGENT, BLOCK, DOCUMENTATION. If not specified, searches all.",
-    ),
-    page: int = 1,
-    page_size: int = 20,
-    user_id: str | None = fastapi.Security(
-        autogpt_libs.auth.get_optional_user_id, use_cache=False
-    ),
-):
-    """
-    Search across all content types (store agents, blocks, documentation) using hybrid search.
-
-    Combines semantic (embedding-based) and lexical (text-based) search for best results.
-
-    Args:
-        query: The search query string
-        content_types: Optional list of content types to filter by (STORE_AGENT, BLOCK, DOCUMENTATION)
-        page: Page number for pagination (default 1)
-        page_size: Number of results per page (default 20)
-        user_id: Optional authenticated user ID (for user-scoped content in future)
-
-    Returns:
-        UnifiedSearchResponse: Paginated list of search results with relevance scores
-    """
-    if page < 1:
-        raise fastapi.HTTPException(
-            status_code=422, detail="Page must be greater than 0"
-        )
-
-    if page_size < 1:
-        raise fastapi.HTTPException(
-            status_code=422, detail="Page size must be greater than 0"
-        )
-
-    # Convert string content types to enum
-    content_type_enums: list[prisma.enums.ContentType] | None = None
-    if content_types:
-        try:
-            content_type_enums = [prisma.enums.ContentType(ct) for ct in content_types]
-        except ValueError as e:
-            raise fastapi.HTTPException(
-                status_code=422,
-                detail=f"Invalid content type. Valid values: STORE_AGENT, BLOCK, DOCUMENTATION. Error: {e}",
-            )
-
-    # Perform unified hybrid search
-    results, total = await store_hybrid_search.unified_hybrid_search(
-        query=query,
-        content_types=content_type_enums,
-        user_id=user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    # Convert results to response model
-    search_results = [
-        store_model.UnifiedSearchResult(
-            content_type=r["content_type"],
-            content_id=r["content_id"],
-            searchable_text=r.get("searchable_text", ""),
-            metadata=r.get("metadata"),
-            updated_at=r.get("updated_at"),
-            combined_score=r.get("combined_score"),
-            semantic_score=r.get("semantic_score"),
-            lexical_score=r.get("lexical_score"),
-        )
-        for r in results
-    ]
-
-    total_pages = (total + page_size - 1) // page_size if total > 0 else 0
-
-    return store_model.UnifiedSearchResponse(
-        results=search_results,
-        pagination=Pagination(
-            total_items=total,
-            total_pages=total_pages,
-            current_page=page,
-            page_size=page_size,
-        ),
-    )
-
-
 @router.get(
     "/agents/{username}/{agent_name}",
     summary="Get specific agent",

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/api/features/store/semantic_search_test.py

@@ -1,272 +0,0 @@
-"""Tests for the semantic_search function."""
-
-import pytest
-from prisma.enums import ContentType
-
-from backend.api.features.store.embeddings import EMBEDDING_DIM, semantic_search
-
-
-@pytest.mark.asyncio
-async def test_search_blocks_only(mocker):
-    """Test searching only BLOCK content type."""
-    # Mock embed_query to return a test embedding
-    mock_embedding = [0.1] * EMBEDDING_DIM
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=mock_embedding,
-    )
-
-    # Mock query_raw_with_schema to return test results
-    mock_results = [
-        {
-            "content_id": "block-123",
-            "content_type": "BLOCK",
-            "searchable_text": "Calculator Block - Performs arithmetic operations",
-            "metadata": {"name": "Calculator", "categories": ["Math"]},
-            "similarity": 0.85,
-        }
-    ]
-    mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=mock_results,
-    )
-
-    results = await semantic_search(
-        query="calculate numbers",
-        content_types=[ContentType.BLOCK],
-    )
-
-    assert len(results) == 1
-    assert results[0]["content_type"] == "BLOCK"
-    assert results[0]["content_id"] == "block-123"
-    assert results[0]["similarity"] == 0.85
-
-
-@pytest.mark.asyncio
-async def test_search_multiple_content_types(mocker):
-    """Test searching multiple content types simultaneously."""
-    mock_embedding = [0.1] * EMBEDDING_DIM
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=mock_embedding,
-    )
-
-    mock_results = [
-        {
-            "content_id": "block-123",
-            "content_type": "BLOCK",
-            "searchable_text": "Calculator Block",
-            "metadata": {},
-            "similarity": 0.85,
-        },
-        {
-            "content_id": "doc-456",
-            "content_type": "DOCUMENTATION",
-            "searchable_text": "How to use Calculator",
-            "metadata": {},
-            "similarity": 0.75,
-        },
-    ]
-    mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=mock_results,
-    )
-
-    results = await semantic_search(
-        query="calculator",
-        content_types=[ContentType.BLOCK, ContentType.DOCUMENTATION],
-    )
-
-    assert len(results) == 2
-    assert results[0]["content_type"] == "BLOCK"
-    assert results[1]["content_type"] == "DOCUMENTATION"
-
-
-@pytest.mark.asyncio
-async def test_search_with_min_similarity_threshold(mocker):
-    """Test that results below min_similarity are filtered out."""
-    mock_embedding = [0.1] * EMBEDDING_DIM
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=mock_embedding,
-    )
-
-    # Only return results above 0.7 similarity
-    mock_results = [
-        {
-            "content_id": "block-123",
-            "content_type": "BLOCK",
-            "searchable_text": "Calculator Block",
-            "metadata": {},
-            "similarity": 0.85,
-        }
-    ]
-    mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=mock_results,
-    )
-
-    results = await semantic_search(
-        query="calculate",
-        content_types=[ContentType.BLOCK],
-        min_similarity=0.7,
-    )
-
-    assert len(results) == 1
-    assert results[0]["similarity"] >= 0.7
-
-
-@pytest.mark.asyncio
-async def test_search_fallback_to_lexical(mocker):
-    """Test fallback to lexical search when embeddings fail."""
-    # Mock embed_query to return None (embeddings unavailable)
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=None,
-    )
-
-    mock_lexical_results = [
-        {
-            "content_id": "block-123",
-            "content_type": "BLOCK",
-            "searchable_text": "Calculator Block performs calculations",
-            "metadata": {},
-            "similarity": 0.0,
-        }
-    ]
-    mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=mock_lexical_results,
-    )
-
-    results = await semantic_search(
-        query="calculator",
-        content_types=[ContentType.BLOCK],
-    )
-
-    assert len(results) == 1
-    assert results[0]["similarity"] == 0.0  # Lexical search returns 0 similarity
-
-
-@pytest.mark.asyncio
-async def test_search_empty_query():
-    """Test that empty query returns no results."""
-    results = await semantic_search(query="")
-    assert results == []
-
-    results = await semantic_search(query="   ")
-    assert results == []
-
-
-@pytest.mark.asyncio
-async def test_search_with_user_id_filter(mocker):
-    """Test searching with user_id filter for private content."""
-    mock_embedding = [0.1] * EMBEDDING_DIM
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=mock_embedding,
-    )
-
-    mock_results = [
-        {
-            "content_id": "agent-789",
-            "content_type": "LIBRARY_AGENT",
-            "searchable_text": "My Custom Agent",
-            "metadata": {},
-            "similarity": 0.9,
-        }
-    ]
-    mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=mock_results,
-    )
-
-    results = await semantic_search(
-        query="custom agent",
-        content_types=[ContentType.LIBRARY_AGENT],
-        user_id="user-123",
-    )
-
-    assert len(results) == 1
-    assert results[0]["content_type"] == "LIBRARY_AGENT"
-
-
-@pytest.mark.asyncio
-async def test_search_limit_parameter(mocker):
-    """Test that limit parameter correctly limits results."""
-    mock_embedding = [0.1] * EMBEDDING_DIM
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=mock_embedding,
-    )
-
-    # Return 5 results
-    mock_results = [
-        {
-            "content_id": f"block-{i}",
-            "content_type": "BLOCK",
-            "searchable_text": f"Block {i}",
-            "metadata": {},
-            "similarity": 0.8,
-        }
-        for i in range(5)
-    ]
-    mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=mock_results,
-    )
-
-    results = await semantic_search(
-        query="block",
-        content_types=[ContentType.BLOCK],
-        limit=5,
-    )
-
-    assert len(results) == 5
-
-
-@pytest.mark.asyncio
-async def test_search_default_content_types(mocker):
-    """Test that default content_types includes BLOCK, STORE_AGENT, and DOCUMENTATION."""
-    mock_embedding = [0.1] * EMBEDDING_DIM
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=mock_embedding,
-    )
-
-    mock_query_raw = mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        return_value=[],
-    )
-
-    await semantic_search(query="test")
-
-    # Check that the SQL query includes all three default content types
-    call_args = mock_query_raw.call_args
-    assert "BLOCK" in str(call_args)
-    assert "STORE_AGENT" in str(call_args)
-    assert "DOCUMENTATION" in str(call_args)
-
-
-@pytest.mark.asyncio
-async def test_search_handles_database_error(mocker):
-    """Test that database errors are handled gracefully."""
-    mock_embedding = [0.1] * EMBEDDING_DIM
-    mocker.patch(
-        "backend.api.features.store.embeddings.embed_query",
-        return_value=mock_embedding,
-    )
-
-    # Simulate database error
-    mocker.patch(
-        "backend.api.features.store.embeddings.query_raw_with_schema",
-        side_effect=Exception("Database connection failed"),
-    )
-
-    results = await semantic_search(
-        query="test",
-        content_types=[ContentType.BLOCK],
-    )
-
-    # Should return empty list on error
-    assert results == []

autogpt_platform/backend/backend/api/features/v1.py

@@ -64,6 +64,7 @@ from backend.data.onboarding import (
     complete_re_run_agent,
     get_recommended_agents,
     get_user_onboarding,
+    increment_runs,
     onboarding_enabled,
     reset_user_onboarding,
     update_user_onboarding,
@@ -693,13 +694,13 @@ class DeleteGraphResponse(TypedDict):
 async def list_graphs(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> Sequence[graph_db.GraphMeta]:
-    graphs, _ = await graph_db.list_graphs_paginated(
+    paginated_result = await graph_db.list_graphs_paginated(
         user_id=user_id,
         page=1,
         page_size=250,
         filter_by="active",
     )
-    return graphs
+    return paginated_result.graphs
 
 
 @v1_router.get(
@@ -974,6 +975,7 @@ async def execute_graph(
         # Record successful graph execution
         record_graph_execution(graph_id=graph_id, status="success", user_id=user_id)
         record_graph_operation(operation="execute", status="success")
+        await increment_runs(user_id)
         await complete_re_run_agent(user_id, graph_id)
         if source == "library":
             await complete_onboarding_step(

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,24 +489,14 @@ 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,
         }
 
         properties = {}
-        field_mapping = {}
 
         for link in links:
-            field_name = link.sink_name
-
-            clean_field_name = SmartDecisionMakerBlock.cleanup(field_name)
-            field_mapping[clean_field_name] = field_name
-
             sink_block_input_schema = sink_node.input_default["input_schema"]
             sink_block_properties = sink_block_input_schema.get("properties", {}).get(
                 link.sink_name, {}
@@ -520,7 +506,7 @@ class SmartDecisionMakerBlock(Block):
                 if "description" in sink_block_properties
                 else f"The {link.sink_name} of the tool"
             )
-            properties[clean_field_name] = {
+            properties[link.sink_name] = {
                 "type": "string",
                 "description": description,
                 "default": json.dumps(sink_block_properties.get("default", None)),
@@ -533,7 +519,7 @@ class SmartDecisionMakerBlock(Block):
             "strict": True,
         }
 
-        tool_function["_field_mapping"] = field_mapping
+        # Store node info for later use in output processing
         tool_function["_sink_node_id"] = sink_node.id
 
         return {"type": "function", "function": tool_function}
@@ -989,28 +975,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 []
@@ -1161,9 +1129,8 @@ class SmartDecisionMakerBlock(Block):
                 original_field_name = field_mapping.get(clean_arg_name, clean_arg_name)
                 arg_value = tool_args.get(clean_arg_name)
 
-                # Use original_field_name directly (not sanitized) to match link sink_name
-                # The field_mapping already translates from LLM's cleaned names to original names
-                emit_key = f"tools_^_{sink_node_id}_~_{original_field_name}"
+                sanitized_arg_name = self.cleanup(original_field_name)
+                emit_key = f"tools_^_{sink_node_id}_~_{sanitized_arg_name}"
 
                 logger.debug(
                     "[SmartDecisionMakerBlock|geid:%s|neid:%s] emit %s",

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/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

@@ -38,20 +38,6 @@ POOL_TIMEOUT = os.getenv("DB_POOL_TIMEOUT")
 if POOL_TIMEOUT:
     DATABASE_URL = add_param(DATABASE_URL, "pool_timeout", POOL_TIMEOUT)
 
-# Add public schema to search_path for pgvector type access
-# The vector extension is in public schema, but search_path is determined by schema parameter
-# Extract the schema from DATABASE_URL or default to 'public' (matching get_database_schema())
-parsed_url = urlparse(DATABASE_URL)
-url_params = dict(parse_qsl(parsed_url.query))
-db_schema = url_params.get("schema", "public")
-# Build search_path, avoiding duplicates if db_schema is already 'public'
-search_path_schemas = list(
-    dict.fromkeys([db_schema, "public"])
-)  # Preserves order, removes duplicates
-search_path = ",".join(search_path_schemas)
-# This allows using ::vector without schema qualification
-DATABASE_URL = add_param(DATABASE_URL, "options", f"-c search_path={search_path}")
-
 HTTP_TIMEOUT = int(POOL_TIMEOUT) if POOL_TIMEOUT else None
 
 prisma = Prisma(
@@ -122,102 +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,
-    set_public_search_path: bool = False,
-) -> 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).
-        set_public_search_path: If True, sets search_path to include public schema.
-                                Needed for pgvector types and other public schema objects.
-
-    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()
-
-    # Set search_path to include public schema if requested
-    # Prisma doesn't support the 'options' connection parameter, so we set it per-session
-    # This is idempotent and safe to call multiple times
-    if set_public_search_path:
-        await db_client.execute_raw(f"SET search_path = {schema}, public")  # type: ignore
-
-    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, set_public_search_path: bool = False
-) -> list[dict]:
-    """Execute raw SQL SELECT query with proper schema handling.
-
-    Args:
-        query_template: SQL query with {schema_prefix} placeholder
-        *args: Query parameters
-        set_public_search_path: If True, sets search_path to include public schema.
-                                Needed for pgvector types and other public schema objects.
-
-    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, set_public_search_path=set_public_search_path)  # type: ignore
-
-
-async def execute_raw_with_schema(
-    query_template: str,
-    *args,
-    client: Prisma | None = None,
-    set_public_search_path: bool = False,
-) -> 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
-        set_public_search_path: If True, sets search_path to include public schema.
-                                Needed for pgvector types and other public schema objects.
-
-    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, set_public_search_path=set_public_search_path)  # type: ignore
-
-
 class BaseDbModel(BaseModel):
     id: str = Field(default_factory=lambda: str(uuid4()))
 

autogpt_platform/backend/backend/data/execution.py

@@ -383,7 +383,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 +390,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,
         )
 
@@ -1147,8 +1145,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]:
@@ -804,7 +764,9 @@ class GraphModel(Graph):
         )
 
 
-class GraphMeta(GraphModel):
+class GraphMeta(Graph):
+    user_id: str
+
     # Easy work-around to prevent exposing nodes and links in the API response
     nodes: list[NodeModel] = Field(default=[], exclude=True)  # type: ignore
     links: list[Link] = Field(default=[], exclude=True)
@@ -814,6 +776,13 @@ class GraphMeta(GraphModel):
         return GraphMeta(**graph.model_dump())
 
 
+class GraphsPaginated(BaseModel):
+    """Response schema for paginated graphs."""
+
+    graphs: list[GraphMeta]
+    pagination: Pagination
+
+
 # --------------------- CRUD functions --------------------- #
 
 
@@ -847,7 +816,7 @@ async def list_graphs_paginated(
     page: int = 1,
     page_size: int = 25,
     filter_by: Literal["active"] | None = "active",
-) -> tuple[list[GraphMeta], Pagination]:
+) -> GraphsPaginated:
     """
     Retrieves paginated graph metadata objects.
 
@@ -858,8 +827,7 @@ async def list_graphs_paginated(
         filter_by: An optional filter to either select graphs.
 
     Returns:
-        list[GraphMeta]: List of graph info objects.
-        Pagination: Pagination information.
+        GraphsPaginated: Paginated list of graph metadata.
     """
     where_clause: AgentGraphWhereInput = {"userId": user_id}
 
@@ -892,11 +860,14 @@ async def list_graphs_paginated(
             logger.error(f"Error processing graph {graph.id}: {e}")
             continue
 
-    return graph_models, Pagination(
-        total_items=total_count,
-        total_pages=total_pages,
-        current_page=page,
-        page_size=page_size,
+    return GraphsPaginated(
+        graphs=graph_models,
+        pagination=Pagination(
+            total_items=total_count,
+            total_pages=total_pages,
+            current_page=page,
+            page_size=page_size,
+        ),
     )
 
 

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/data/onboarding.py

@@ -334,7 +334,7 @@ async def _get_user_timezone(user_id: str) -> str:
     return get_user_timezone_or_utc(user.timezone if user else None)
 
 
-async def increment_onboarding_runs(user_id: str):
+async def increment_runs(user_id: str):
     """
     Increment a user's run counters and trigger any onboarding milestones.
     """

autogpt_platform/backend/backend/data/understanding.py

@@ -5,7 +5,11 @@ from datetime import datetime
 from typing import Any, Optional, cast
 
 import pydantic
-from prisma.models import CoPilotUnderstanding
+from prisma.models import UserBusinessUnderstanding
+from prisma.types import (
+    UserBusinessUnderstandingCreateInput,
+    UserBusinessUnderstandingUpdateInput,
+)
 
 from backend.data.redis_client import get_redis_async
 from backend.util.json import SafeJson
@@ -123,32 +127,28 @@ class BusinessUnderstanding(pydantic.BaseModel):
     additional_notes: Optional[str] = None
 
     @classmethod
-    def from_db(cls, db_record: CoPilotUnderstanding) -> "BusinessUnderstanding":
+    def from_db(cls, db_record: UserBusinessUnderstanding) -> "BusinessUnderstanding":
         """Convert database record to Pydantic model."""
-        data = db_record.data if isinstance(db_record.data, dict) else {}
-        business = (
-            data.get("business", {}) if isinstance(data.get("business"), dict) else {}
-        )
         return cls(
             id=db_record.id,
             user_id=db_record.userId,
             created_at=db_record.createdAt,
             updated_at=db_record.updatedAt,
-            user_name=data.get("name"),
-            job_title=business.get("job_title"),
-            business_name=business.get("business_name"),
-            industry=business.get("industry"),
-            business_size=business.get("business_size"),
-            user_role=business.get("user_role"),
-            key_workflows=_json_to_list(business.get("key_workflows")),
-            daily_activities=_json_to_list(business.get("daily_activities")),
-            pain_points=_json_to_list(business.get("pain_points")),
-            bottlenecks=_json_to_list(business.get("bottlenecks")),
-            manual_tasks=_json_to_list(business.get("manual_tasks")),
-            automation_goals=_json_to_list(business.get("automation_goals")),
-            current_software=_json_to_list(business.get("current_software")),
-            existing_automation=_json_to_list(business.get("existing_automation")),
-            additional_notes=business.get("additional_notes"),
+            user_name=db_record.userName,
+            job_title=db_record.jobTitle,
+            business_name=db_record.businessName,
+            industry=db_record.industry,
+            business_size=db_record.businessSize,
+            user_role=db_record.userRole,
+            key_workflows=_json_to_list(db_record.keyWorkflows),
+            daily_activities=_json_to_list(db_record.dailyActivities),
+            pain_points=_json_to_list(db_record.painPoints),
+            bottlenecks=_json_to_list(db_record.bottlenecks),
+            manual_tasks=_json_to_list(db_record.manualTasks),
+            automation_goals=_json_to_list(db_record.automationGoals),
+            current_software=_json_to_list(db_record.currentSoftware),
+            existing_automation=_json_to_list(db_record.existingAutomation),
+            additional_notes=db_record.additionalNotes,
         )
 
 
@@ -216,7 +216,9 @@ async def get_business_understanding(
 
     # Cache miss - load from database
     logger.debug(f"Business understanding cache miss for user {user_id}")
-    record = await CoPilotUnderstanding.prisma().find_unique(where={"userId": user_id})
+    record = await UserBusinessUnderstanding.prisma().find_unique(
+        where={"userId": user_id}
+    )
     if record is None:
         return None
 
@@ -230,78 +232,101 @@ async def get_business_understanding(
 
 async def upsert_business_understanding(
     user_id: str,
-    input_data: BusinessUnderstandingInput,
+    data: BusinessUnderstandingInput,
 ) -> BusinessUnderstanding:
     """
     Create or update business understanding with incremental merge strategy.
 
     - String fields: new value overwrites if provided (not None)
     - List fields: new items are appended to existing (deduplicated)
-
-    Data is stored as: {name: ..., business: {version: 1, ...}}
     """
     # Get existing record for merge
-    existing = await CoPilotUnderstanding.prisma().find_unique(
+    existing = await UserBusinessUnderstanding.prisma().find_unique(
         where={"userId": user_id}
     )
 
-    # Get existing data structure or start fresh
-    existing_data: dict[str, Any] = {}
-    if existing and isinstance(existing.data, dict):
-        existing_data = dict(existing.data)
+    # Build update data with merge strategy
+    update_data: UserBusinessUnderstandingUpdateInput = {}
+    create_data: dict[str, Any] = {"userId": user_id}
 
-    existing_business: dict[str, Any] = {}
-    if isinstance(existing_data.get("business"), dict):
-        existing_business = dict(existing_data["business"])
+    # String fields - overwrite if provided
+    if data.user_name is not None:
+        update_data["userName"] = data.user_name
+        create_data["userName"] = data.user_name
+    if data.job_title is not None:
+        update_data["jobTitle"] = data.job_title
+        create_data["jobTitle"] = data.job_title
+    if data.business_name is not None:
+        update_data["businessName"] = data.business_name
+        create_data["businessName"] = data.business_name
+    if data.industry is not None:
+        update_data["industry"] = data.industry
+        create_data["industry"] = data.industry
+    if data.business_size is not None:
+        update_data["businessSize"] = data.business_size
+        create_data["businessSize"] = data.business_size
+    if data.user_role is not None:
+        update_data["userRole"] = data.user_role
+        create_data["userRole"] = data.user_role
+    if data.additional_notes is not None:
+        update_data["additionalNotes"] = data.additional_notes
+        create_data["additionalNotes"] = data.additional_notes
 
-    # Business fields (stored inside business object)
-    business_string_fields = [
-        "job_title",
-        "business_name",
-        "industry",
-        "business_size",
-        "user_role",
-        "additional_notes",
-    ]
-    business_list_fields = [
-        "key_workflows",
-        "daily_activities",
-        "pain_points",
-        "bottlenecks",
-        "manual_tasks",
-        "automation_goals",
-        "current_software",
-        "existing_automation",
-    ]
+    # List fields - merge with existing
+    if data.key_workflows is not None:
+        existing_list = _json_to_list(existing.keyWorkflows) if existing else None
+        merged = _merge_lists(existing_list, data.key_workflows)
+        update_data["keyWorkflows"] = SafeJson(merged)
+        create_data["keyWorkflows"] = SafeJson(merged)
 
-    # Handle top-level name field
-    if input_data.user_name is not None:
-        existing_data["name"] = input_data.user_name
+    if data.daily_activities is not None:
+        existing_list = _json_to_list(existing.dailyActivities) if existing else None
+        merged = _merge_lists(existing_list, data.daily_activities)
+        update_data["dailyActivities"] = SafeJson(merged)
+        create_data["dailyActivities"] = SafeJson(merged)
 
-    # Business string fields - overwrite if provided
-    for field in business_string_fields:
-        value = getattr(input_data, field)
-        if value is not None:
-            existing_business[field] = value
+    if data.pain_points is not None:
+        existing_list = _json_to_list(existing.painPoints) if existing else None
+        merged = _merge_lists(existing_list, data.pain_points)
+        update_data["painPoints"] = SafeJson(merged)
+        create_data["painPoints"] = SafeJson(merged)
 
-    # Business list fields - merge with existing
-    for field in business_list_fields:
-        value = getattr(input_data, field)
-        if value is not None:
-            existing_list = _json_to_list(existing_business.get(field))
-            merged = _merge_lists(existing_list, value)
-            existing_business[field] = merged
+    if data.bottlenecks is not None:
+        existing_list = _json_to_list(existing.bottlenecks) if existing else None
+        merged = _merge_lists(existing_list, data.bottlenecks)
+        update_data["bottlenecks"] = SafeJson(merged)
+        create_data["bottlenecks"] = SafeJson(merged)
 
-    # Set version and nest business data
-    existing_business["version"] = 1
-    existing_data["business"] = existing_business
+    if data.manual_tasks is not None:
+        existing_list = _json_to_list(existing.manualTasks) if existing else None
+        merged = _merge_lists(existing_list, data.manual_tasks)
+        update_data["manualTasks"] = SafeJson(merged)
+        create_data["manualTasks"] = SafeJson(merged)
 
-    # Upsert with the merged data
-    record = await CoPilotUnderstanding.prisma().upsert(
+    if data.automation_goals is not None:
+        existing_list = _json_to_list(existing.automationGoals) if existing else None
+        merged = _merge_lists(existing_list, data.automation_goals)
+        update_data["automationGoals"] = SafeJson(merged)
+        create_data["automationGoals"] = SafeJson(merged)
+
+    if data.current_software is not None:
+        existing_list = _json_to_list(existing.currentSoftware) if existing else None
+        merged = _merge_lists(existing_list, data.current_software)
+        update_data["currentSoftware"] = SafeJson(merged)
+        create_data["currentSoftware"] = SafeJson(merged)
+
+    if data.existing_automation is not None:
+        existing_list = _json_to_list(existing.existingAutomation) if existing else None
+        merged = _merge_lists(existing_list, data.existing_automation)
+        update_data["existingAutomation"] = SafeJson(merged)
+        create_data["existingAutomation"] = SafeJson(merged)
+
+    # Upsert
+    record = await UserBusinessUnderstanding.prisma().upsert(
         where={"userId": user_id},
         data={
-            "create": {"userId": user_id, "data": SafeJson(existing_data)},
-            "update": {"data": SafeJson(existing_data)},
+            "create": UserBusinessUnderstandingCreateInput(**create_data),
+            "update": update_data,
         },
     )
 
@@ -319,7 +344,7 @@ async def clear_business_understanding(user_id: str) -> bool:
     await _delete_cache(user_id)
 
     try:
-        await CoPilotUnderstanding.prisma().delete(where={"userId": user_id})
+        await UserBusinessUnderstanding.prisma().delete(where={"userId": user_id})
         return True
     except Exception:
         # Record might not exist

autogpt_platform/backend/backend/executor/database.py

@@ -7,11 +7,6 @@ from backend.api.features.library.db import (
     list_library_agents,
 )
 from backend.api.features.store.db import get_store_agent_details, get_store_agents
-from backend.api.features.store.embeddings import (
-    backfill_missing_embeddings,
-    cleanup_orphaned_embeddings,
-    get_embedding_stats,
-)
 from backend.data import db
 from backend.data.analytics import (
     get_accuracy_trends_and_alerts,
@@ -25,7 +20,6 @@ from backend.data.execution import (
     get_execution_kv_data,
     get_execution_outputs_by_node_exec_id,
     get_frequently_executed_graphs,
-    get_graph_execution,
     get_graph_execution_meta,
     get_graph_executions,
     get_graph_executions_count,
@@ -63,7 +57,6 @@ from backend.data.notifications import (
     get_user_notification_oldest_message_in_batch,
     remove_notifications_from_batch,
 )
-from backend.data.onboarding import increment_onboarding_runs
 from backend.data.user import (
     get_active_user_ids_in_timerange,
     get_user_by_id,
@@ -147,7 +140,6 @@ class DatabaseManager(AppService):
     get_child_graph_executions = _(get_child_graph_executions)
     get_graph_executions = _(get_graph_executions)
     get_graph_executions_count = _(get_graph_executions_count)
-    get_graph_execution = _(get_graph_execution)
     get_graph_execution_meta = _(get_graph_execution_meta)
     create_graph_execution = _(create_graph_execution)
     get_node_execution = _(get_node_execution)
@@ -212,18 +204,10 @@ class DatabaseManager(AppService):
     add_store_agent_to_library = _(add_store_agent_to_library)
     validate_graph_execution_permissions = _(validate_graph_execution_permissions)
 
-    # Onboarding
-    increment_onboarding_runs = _(increment_onboarding_runs)
-
     # Store
     get_store_agents = _(get_store_agents)
     get_store_agent_details = _(get_store_agent_details)
 
-    # Store Embeddings
-    get_embedding_stats = _(get_embedding_stats)
-    backfill_missing_embeddings = _(backfill_missing_embeddings)
-    cleanup_orphaned_embeddings = _(cleanup_orphaned_embeddings)
-
     # Summary data - async
     get_user_execution_summary_data = _(get_user_execution_summary_data)
 
@@ -275,11 +259,6 @@ class DatabaseManagerClient(AppServiceClient):
     get_store_agents = _(d.get_store_agents)
     get_store_agent_details = _(d.get_store_agent_details)
 
-    # Store Embeddings
-    get_embedding_stats = _(d.get_embedding_stats)
-    backfill_missing_embeddings = _(d.backfill_missing_embeddings)
-    cleanup_orphaned_embeddings = _(d.cleanup_orphaned_embeddings)
-
 
 class DatabaseManagerAsyncClient(AppServiceClient):
     d = DatabaseManager
@@ -295,7 +274,6 @@ class DatabaseManagerAsyncClient(AppServiceClient):
     get_graph = d.get_graph
     get_graph_metadata = d.get_graph_metadata
     get_graph_settings = d.get_graph_settings
-    get_graph_execution = d.get_graph_execution
     get_graph_execution_meta = d.get_graph_execution_meta
     get_node = d.get_node
     get_node_execution = d.get_node_execution
@@ -340,9 +318,6 @@ class DatabaseManagerAsyncClient(AppServiceClient):
     add_store_agent_to_library = d.add_store_agent_to_library
     validate_graph_execution_permissions = d.validate_graph_execution_permissions
 
-    # Onboarding
-    increment_onboarding_runs = d.increment_onboarding_runs
-
     # Store
     get_store_agents = d.get_store_agents
     get_store_agent_details = d.get_store_agent_details

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

@@ -2,7 +2,6 @@ import asyncio
 import logging
 import os
 import threading
-import time
 import uuid
 from enum import Enum
 from typing import Optional
@@ -28,7 +27,7 @@ from backend.data.auth.oauth import cleanup_expired_oauth_tokens
 from backend.data.block import BlockInput
 from backend.data.execution import GraphExecutionWithNodes
 from backend.data.model import CredentialsMetaInput
-from backend.data.onboarding import increment_onboarding_runs
+from backend.data.onboarding import increment_runs
 from backend.executor import utils as execution_utils
 from backend.monitoring import (
     NotificationJobArgs,
@@ -38,7 +37,7 @@ from backend.monitoring import (
     report_execution_accuracy_alerts,
     report_late_executions,
 )
-from backend.util.clients import get_database_manager_client, get_scheduler_client
+from backend.util.clients import get_scheduler_client
 from backend.util.cloud_storage import cleanup_expired_files_async
 from backend.util.exceptions import (
     GraphNotFoundError,
@@ -157,7 +156,7 @@ async def _execute_graph(**kwargs):
             inputs=args.input_data,
             graph_credentials_inputs=args.input_credentials,
         )
-        await increment_onboarding_runs(args.user_id)
+        await increment_runs(args.user_id)
         elapsed = asyncio.get_event_loop().time() - start_time
         logger.info(
             f"Graph execution started with ID {graph_exec.id} for graph {args.graph_id} "
@@ -255,114 +254,6 @@ def execution_accuracy_alerts():
     return report_execution_accuracy_alerts()
 
 
-def ensure_embeddings_coverage():
-    """
-    Ensure all content types (store agents, blocks, docs) have embeddings for search.
-
-    Processes ALL missing embeddings in batches of 10 per content type until 100% coverage.
-    Missing embeddings = content invisible in hybrid search.
-
-    Schedule: Runs every 6 hours (balanced between coverage and API costs).
-    - Catches new content added between scheduled runs
-    - Batch size 10 per content type: gradual processing to avoid rate limits
-    - Manual trigger available via execute_ensure_embeddings_coverage endpoint
-    """
-    db_client = get_database_manager_client()
-    stats = db_client.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 {
-            "backfill": {"processed": 0, "success": 0, "failed": 0},
-            "cleanup": {"deleted": 0},
-            "error": stats["error"],
-        }
-
-    # Extract totals from new stats structure
-    totals = stats.get("totals", {})
-    without_embeddings = totals.get("without_embeddings", 0)
-    coverage_percent = totals.get("coverage_percent", 0)
-
-    total_processed = 0
-    total_success = 0
-    total_failed = 0
-
-    if without_embeddings == 0:
-        logger.info("All content has embeddings, skipping backfill")
-    else:
-        # Log per-content-type stats for visibility
-        by_type = stats.get("by_type", {})
-        for content_type, type_stats in by_type.items():
-            if type_stats.get("without_embeddings", 0) > 0:
-                logger.info(
-                    f"{content_type}: {type_stats['without_embeddings']} items without embeddings "
-                    f"({type_stats['coverage_percent']}% coverage)"
-                )
-
-        logger.info(
-            f"Total: {without_embeddings} items without embeddings "
-            f"({coverage_percent}% coverage) - processing all"
-        )
-
-        # Process in batches until no more missing embeddings
-        while True:
-            result = db_client.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
-
-            if result["success"] == 0 and result["processed"] > 0:
-                # All attempts in this batch failed - stop to avoid infinite loop
-                logger.error(
-                    f"All {result['processed']} embedding attempts failed - stopping backfill"
-                )
-                break
-
-            # Small delay between batches to avoid rate limits
-            time.sleep(1)
-
-        logger.info(
-            f"Embedding backfill completed: {total_success}/{total_processed} succeeded, "
-            f"{total_failed} failed"
-        )
-
-    # Clean up orphaned embeddings for blocks and docs
-    logger.info("Running cleanup for orphaned embeddings (blocks/docs)...")
-    cleanup_result = db_client.cleanup_orphaned_embeddings()
-    cleanup_totals = cleanup_result.get("totals", {})
-    cleanup_deleted = cleanup_totals.get("deleted", 0)
-
-    if cleanup_deleted > 0:
-        logger.info(f"Cleanup completed: deleted {cleanup_deleted} orphaned embeddings")
-        by_type = cleanup_result.get("by_type", {})
-        for content_type, type_result in by_type.items():
-            if type_result.get("deleted", 0) > 0:
-                logger.info(
-                    f"{content_type}: deleted {type_result['deleted']} orphaned embeddings"
-                )
-    else:
-        logger.info("Cleanup completed: no orphaned embeddings found")
-
-    return {
-        "backfill": {
-            "processed": total_processed,
-            "success": total_success,
-            "failed": total_failed,
-        },
-        "cleanup": {
-            "deleted": cleanup_deleted,
-        },
-    }
-
-
 # Monitoring functions are now imported from monitoring module
 
 
@@ -584,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)
@@ -754,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

@@ -10,7 +10,6 @@ from pydantic import BaseModel, JsonValue, ValidationError
 
 from backend.data import execution as execution_db
 from backend.data import graph as graph_db
-from backend.data import onboarding as onboarding_db
 from backend.data import user as user_db
 from backend.data.block import (
     Block,
@@ -32,6 +31,7 @@ from backend.data.execution import (
     GraphExecutionStats,
     GraphExecutionWithNodes,
     NodesInputMasks,
+    get_graph_execution,
 )
 from backend.data.graph import GraphModel, Node
 from backend.data.model import USER_TIMEZONE_NOT_SET, CredentialsMetaInput
@@ -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(
@@ -809,14 +762,13 @@ async def add_graph_execution(
         edb = execution_db
         udb = user_db
         gdb = graph_db
-        odb = onboarding_db
     else:
-        edb = udb = gdb = odb = get_database_manager_async_client()
+        edb = udb = gdb = get_database_manager_async_client()
 
     # Get or create the graph execution
     if graph_exec_id:
         # Resume existing execution
-        graph_exec = await edb.get_graph_execution(
+        graph_exec = await get_graph_execution(
             user_id=user_id,
             execution_id=graph_exec_id,
             include_node_executions=True,
@@ -827,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:
@@ -838,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,
@@ -887,12 +836,10 @@ 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")
 
-        # Publish to execution queue for executor to pick up
         exec_queue = await get_async_execution_queue()
         await exec_queue.publish_message(
             routing_key=GRAPH_EXECUTION_ROUTING_KEY,
@@ -901,12 +848,14 @@ async def add_graph_execution(
         )
         logger.info(f"Published execution {graph_exec.id} to RabbitMQ queue")
 
-        # Update execution status to QUEUED
         graph_exec.status = ExecutionStatus.QUEUED
         await edb.update_graph_execution_stats(
             graph_exec_id=graph_exec.id,
             status=graph_exec.status,
         )
+        await get_async_execution_event_bus().publish(graph_exec)
+
+        return graph_exec
     except BaseException as e:
         err = str(e) or type(e).__name__
         if not graph_exec:
@@ -927,24 +876,6 @@ async def add_graph_execution(
         )
         raise
 
-    try:
-        await get_async_execution_event_bus().publish(graph_exec)
-        logger.info(f"Published update for execution #{graph_exec.id} to event bus")
-    except Exception as e:
-        logger.error(
-            f"Failed to publish execution event for graph exec #{graph_exec.id}: {e}"
-        )
-
-    try:
-        await odb.increment_onboarding_runs(user_id)
-        logger.info(
-            f"Incremented user #{user_id} onboarding runs for exec #{graph_exec.id}"
-        )
-    except Exception as e:
-        logger.error(f"Failed to increment onboarding runs for user #{user_id}: {e}")
-
-    return graph_exec
-
 
 # ============ Execution Output Helpers ============ #
 

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/credentials_store.py

@@ -245,21 +245,6 @@ DEFAULT_CREDENTIALS = [
     webshare_proxy_credentials,
 ]
 
-SYSTEM_CREDENTIAL_IDS = {cred.id for cred in DEFAULT_CREDENTIALS}
-
-# Set of providers that have system credentials available
-SYSTEM_PROVIDERS = {cred.provider for cred in DEFAULT_CREDENTIALS}
-
-
-def is_system_credential(credential_id: str) -> bool:
-    """Check if a credential ID belongs to a system-managed credential."""
-    return credential_id in SYSTEM_CREDENTIAL_IDS
-
-
-def is_system_provider(provider: str) -> bool:
-    """Check if a provider has system-managed credentials available."""
-    return provider in SYSTEM_PROVIDERS
-
 
 class IntegrationCredentialsStore:
     def __init__(self):

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/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",
     )
 
@@ -658,14 +658,6 @@ class Secrets(UpdateTrackingModel["Secrets"], BaseSettings):
 
     ayrshare_api_key: str = Field(default="", description="Ayrshare API Key")
     ayrshare_jwt_key: str = Field(default="", description="Ayrshare private Key")
-
-    # Langfuse prompt management
-    langfuse_public_key: str = Field(default="", description="Langfuse public key")
-    langfuse_secret_key: str = Field(default="", description="Langfuse secret key")
-    langfuse_host: str = Field(
-        default="https://cloud.langfuse.com", description="Langfuse host URL"
-    )
-
     # Add more secret fields as needed
     model_config = SettingsConfigDict(
         env_file=".env",

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()