chore: wip

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

@@ -176,7 +176,7 @@ jobs:
           }
 
       - name: Run Database Migrations
-        run: poetry run prisma migrate deploy
+        run: poetry run prisma migrate dev --name updates
         env:
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
           DIRECT_URL: ${{ steps.supabase.outputs.DB_URL }}

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

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

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

@@ -108,6 +108,9 @@ class CredentialsMetaResponse(BaseModel):
     host: str | None = Field(
         default=None, description="Host pattern for host-scoped credentials"
     )
+    is_system: bool = Field(
+        default=False, description="Whether this is a system-managed credential"
+    )
 
 
 @router.post("/{provider}/callback", summary="Exchange OAuth code for tokens")
@@ -175,6 +178,8 @@ async def callback(
         f"Successfully processed OAuth callback for user {user_id} "
         f"and provider {provider.value}"
     )
+    from backend.integrations.credentials_store import is_system_credential
+
     return CredentialsMetaResponse(
         id=credentials.id,
         provider=credentials.provider,
@@ -185,6 +190,7 @@ async def callback(
         host=(
             credentials.host if isinstance(credentials, HostScopedCredentials) else None
         ),
+        is_system=is_system_credential(credentials.id),
     )
 
 
@@ -192,6 +198,8 @@ async def callback(
 async def list_credentials(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
+    from backend.integrations.credentials_store import is_system_credential
+
     credentials = await creds_manager.store.get_all_creds(user_id)
     return [
         CredentialsMetaResponse(
@@ -202,6 +210,7 @@ async def list_credentials(
             scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
             username=cred.username if isinstance(cred, OAuth2Credentials) else None,
             host=cred.host if isinstance(cred, HostScopedCredentials) else None,
+            is_system=is_system_credential(cred.id),
         )
         for cred in credentials
     ]
@@ -214,6 +223,8 @@ async def list_credentials_by_provider(
     ],
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
+    from backend.integrations.credentials_store import is_system_credential
+
     credentials = await creds_manager.store.get_creds_by_provider(user_id, provider)
     return [
         CredentialsMetaResponse(
@@ -224,6 +235,7 @@ async def list_credentials_by_provider(
             scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
             username=cred.username if isinstance(cred, OAuth2Credentials) else None,
             host=cred.host if isinstance(cred, HostScopedCredentials) else None,
+            is_system=is_system_credential(cred.id),
         )
         for cred in credentials
     ]

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

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

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

@@ -1,7 +1,8 @@
 import asyncio
 import logging
+import typing
 from datetime import datetime, timezone
-from typing import Any, Literal
+from typing import Literal
 
 import fastapi
 import prisma.enums
@@ -9,7 +10,7 @@ import prisma.errors
 import prisma.models
 import prisma.types
 
-from backend.data.db import transaction
+from backend.data.db import query_raw_with_schema, transaction
 from backend.data.graph import (
     GraphMeta,
     GraphModel,
@@ -29,8 +30,6 @@ from backend.util.settings import Settings
 
 from . import exceptions as store_exceptions
 from . import model as store_model
-from .embeddings import ensure_embedding
-from .hybrid_search import hybrid_search
 
 logger = logging.getLogger(__name__)
 settings = Settings()
@@ -51,77 +50,128 @@ async def get_store_agents(
     page_size: int = 20,
 ) -> store_model.StoreAgentsResponse:
     """
-    Get PUBLIC store agents from the StoreAgent view.
-
-    Search behavior:
-    - With search_query: Uses hybrid search (semantic + lexical)
-    - Fallback: If embeddings unavailable, gracefully degrades to lexical-only
-    - Rationale: User-facing endpoint prioritizes availability over accuracy
-
-    Note: Admin operations (approval) use fail-fast to prevent inconsistent state.
+    Get PUBLIC store agents from the StoreAgent view
     """
     logger.debug(
         f"Getting store agents. featured={featured}, creators={creators}, sorted_by={sorted_by}, search={search_query}, category={category}, page={page}"
     )
 
-    search_used_hybrid = False
-    store_agents: list[store_model.StoreAgent] = []
-    agents: list[dict[str, Any]] = []
-    total = 0
-    total_pages = 0
-
     try:
-        # If search_query is provided, use hybrid search (embeddings + tsvector)
+        # If search_query is provided, use full-text search
         if search_query:
-            # Try hybrid search combining semantic and lexical signals
-            # Falls back to lexical-only if OpenAI unavailable (user-facing, high SLA)
-            try:
-                agents, total = await hybrid_search(
-                    query=search_query,
-                    featured=featured,
-                    creators=creators,
-                    category=category,
-                    sorted_by="relevance",  # Use hybrid scoring for relevance
-                    page=page,
-                    page_size=page_size,
-                )
-                search_used_hybrid = True
-            except Exception as e:
-                # Log error but fall back to lexical search for better UX
-                logger.error(
-                    f"Hybrid search failed (likely OpenAI unavailable), "
-                    f"falling back to lexical search: {e}"
-                )
-                # search_used_hybrid remains False, will use fallback path below
+            offset = (page - 1) * page_size
 
-            # Convert hybrid search results (dict format) if hybrid succeeded
-            if search_used_hybrid:
-                total_pages = (total + page_size - 1) // page_size
-                store_agents: list[store_model.StoreAgent] = []
-                for agent in agents:
-                    try:
-                        store_agent = store_model.StoreAgent(
-                            slug=agent["slug"],
-                            agent_name=agent["agent_name"],
-                            agent_image=(
-                                agent["agent_image"][0] if agent["agent_image"] else ""
-                            ),
-                            creator=agent["creator_username"] or "Needs Profile",
-                            creator_avatar=agent["creator_avatar"] or "",
-                            sub_heading=agent["sub_heading"],
-                            description=agent["description"],
-                            runs=agent["runs"],
-                            rating=agent["rating"],
-                        )
-                        store_agents.append(store_agent)
-                    except Exception as e:
-                        logger.error(
-                            f"Error parsing Store agent from hybrid search results: {e}"
-                        )
-                        continue
+            # Whitelist allowed order_by columns
+            ALLOWED_ORDER_BY = {
+                "rating": "rating DESC, rank DESC",
+                "runs": "runs DESC, rank DESC",
+                "name": "agent_name ASC, rank ASC",
+                "updated_at": "updated_at DESC, rank DESC",
+            }
 
-        if not search_used_hybrid:
-            # Fallback path - use basic search or no search
+            # Validate and get order clause
+            if sorted_by and sorted_by in ALLOWED_ORDER_BY:
+                order_by_clause = ALLOWED_ORDER_BY[sorted_by]
+            else:
+                order_by_clause = "updated_at DESC, rank DESC"
+
+            # Build WHERE conditions and parameters list
+            where_parts: list[str] = []
+            params: list[typing.Any] = [search_query]  # $1 - search term
+            param_index = 2  # Start at $2 for next parameter
+
+            # Always filter for available agents
+            where_parts.append("is_available = true")
+
+            if featured:
+                where_parts.append("featured = true")
+
+            if creators and creators:
+                # Use ANY with array parameter
+                where_parts.append(f"creator_username = ANY(${param_index})")
+                params.append(creators)
+                param_index += 1
+
+            if category and category:
+                where_parts.append(f"${param_index} = ANY(categories)")
+                params.append(category)
+                param_index += 1
+
+            sql_where_clause: str = " AND ".join(where_parts) if where_parts else "1=1"
+
+            # Add pagination params
+            params.extend([page_size, offset])
+            limit_param = f"${param_index}"
+            offset_param = f"${param_index + 1}"
+
+            # Execute full-text search query with parameterized values
+            sql_query = f"""
+                SELECT
+                    slug,
+                    agent_name,
+                    agent_image,
+                    creator_username,
+                    creator_avatar,
+                    sub_heading,
+                    description,
+                    runs,
+                    rating,
+                    categories,
+                    featured,
+                    is_available,
+                    updated_at,
+                    ts_rank_cd(search, query) AS rank
+                FROM {{schema_prefix}}"StoreAgent",
+                    plainto_tsquery('english', $1) AS query
+                WHERE {sql_where_clause}
+                    AND search @@ query
+                ORDER BY {order_by_clause}
+                LIMIT {limit_param} OFFSET {offset_param}
+            """
+
+            # Count query for pagination - only uses search term parameter
+            count_query = f"""
+                SELECT COUNT(*) as count
+                FROM {{schema_prefix}}"StoreAgent",
+                    plainto_tsquery('english', $1) AS query
+                WHERE {sql_where_clause}
+                    AND search @@ query
+            """
+
+            # Execute both queries with parameters
+            agents = await query_raw_with_schema(sql_query, *params)
+
+            # For count, use params without pagination (last 2 params)
+            count_params = params[:-2]
+            count_result = await query_raw_with_schema(count_query, *count_params)
+
+            total = count_result[0]["count"] if count_result else 0
+            total_pages = (total + page_size - 1) // page_size
+
+            # Convert raw results to StoreAgent models
+            store_agents: list[store_model.StoreAgent] = []
+            for agent in agents:
+                try:
+                    store_agent = store_model.StoreAgent(
+                        slug=agent["slug"],
+                        agent_name=agent["agent_name"],
+                        agent_image=(
+                            agent["agent_image"][0] if agent["agent_image"] else ""
+                        ),
+                        creator=agent["creator_username"] or "Needs Profile",
+                        creator_avatar=agent["creator_avatar"] or "",
+                        sub_heading=agent["sub_heading"],
+                        description=agent["description"],
+                        runs=agent["runs"],
+                        rating=agent["rating"],
+                    )
+                    store_agents.append(store_agent)
+                except Exception as e:
+                    logger.error(f"Error parsing Store agent from search results: {e}")
+                    continue
+
+        else:
+            # Non-search query path (original logic)
             where_clause: prisma.types.StoreAgentWhereInput = {"is_available": True}
             if featured:
                 where_clause["featured"] = featured
@@ -130,14 +180,6 @@ async def get_store_agents(
             if category:
                 where_clause["categories"] = {"has": category}
 
-            # Add basic text search if search_query provided but hybrid failed
-            if search_query:
-                where_clause["OR"] = [
-                    {"agent_name": {"contains": search_query, "mode": "insensitive"}},
-                    {"sub_heading": {"contains": search_query, "mode": "insensitive"}},
-                    {"description": {"contains": search_query, "mode": "insensitive"}},
-                ]
-
             order_by = []
             if sorted_by == "rating":
                 order_by.append({"rating": "desc"})
@@ -146,7 +188,7 @@ async def get_store_agents(
             elif sorted_by == "name":
                 order_by.append({"agent_name": "asc"})
 
-            db_agents = await prisma.models.StoreAgent.prisma().find_many(
+            agents = await prisma.models.StoreAgent.prisma().find_many(
                 where=where_clause,
                 order=order_by,
                 skip=(page - 1) * page_size,
@@ -157,7 +199,7 @@ async def get_store_agents(
             total_pages = (total + page_size - 1) // page_size
 
             store_agents: list[store_model.StoreAgent] = []
-            for agent in db_agents:
+            for agent in agents:
                 try:
                     # Create the StoreAgent object safely
                     store_agent = store_model.StoreAgent(
@@ -1535,7 +1577,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 +1592,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={

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

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

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

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

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

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

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

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

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

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

autogpt_platform/backend/backend/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/data/db.py

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

autogpt_platform/backend/backend/data/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):
     """

autogpt_platform/backend/backend/executor/manager_test.py

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

autogpt_platform/backend/backend/executor/scheduler.py

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

autogpt_platform/backend/backend/integrations/credentials_store.py

@@ -245,6 +245,13 @@ DEFAULT_CREDENTIALS = [
     webshare_proxy_credentials,
 ]
 
+SYSTEM_CREDENTIAL_IDS = {cred.id 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
+
 
 class IntegrationCredentialsStore:
     def __init__(self):

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/migrations/20260109181714_add_docs_embedding/migration.sql

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

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

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

autogpt_platform/backend/schema.prisma

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

autogpt_platform/frontend/next.config.mjs

@@ -3,6 +3,13 @@ import { withSentryConfig } from "@sentry/nextjs";
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   productionBrowserSourceMaps: true,
+  // Externalize OpenTelemetry packages to fix Turbopack HMR issues
+  serverExternalPackages: [
+    "@opentelemetry/instrumentation",
+    "@opentelemetry/sdk-node",
+    "import-in-the-middle",
+    "require-in-the-middle",
+  ],
   experimental: {
     serverActions: {
       bodySizeLimit: "256mb",

autogpt_platform/frontend/package.json

@@ -117,6 +117,7 @@
   },
   "devDependencies": {
     "@chromatic-com/storybook": "4.1.2",
+    "@opentelemetry/instrumentation": "0.209.0",
     "@playwright/test": "1.56.1",
     "@storybook/addon-a11y": "9.1.5",
     "@storybook/addon-docs": "9.1.5",
@@ -140,6 +141,7 @@
     "eslint": "8.57.1",
     "eslint-config-next": "15.5.7",
     "eslint-plugin-storybook": "9.1.5",
+    "import-in-the-middle": "2.0.2",
     "msw": "2.11.6",
     "msw-storybook-addon": "2.0.6",
     "orval": "7.13.0",
@@ -147,7 +149,7 @@
     "postcss": "8.5.6",
     "prettier": "3.6.2",
     "prettier-plugin-tailwindcss": "0.7.1",
-    "require-in-the-middle": "7.5.2",
+    "require-in-the-middle": "8.0.1",
     "storybook": "9.1.5",
     "tailwindcss": "3.4.17",
     "typescript": "5.9.3"

autogpt_platform/frontend/pnpm-lock.yaml

@@ -270,6 +270,9 @@ importers:
       '@chromatic-com/storybook':
         specifier: 4.1.2
         version: 4.1.2(storybook@9.1.5(@testing-library/dom@10.4.1)(msw@2.11.6(@types/node@24.10.0)(typescript@5.9.3))(prettier@3.6.2))
+      '@opentelemetry/instrumentation':
+        specifier: 0.209.0
+        version: 0.209.0(@opentelemetry/api@1.9.0)
       '@playwright/test':
         specifier: 1.56.1
         version: 1.56.1
@@ -339,6 +342,9 @@ importers:
       eslint-plugin-storybook:
         specifier: 9.1.5
         version: 9.1.5(eslint@8.57.1)(storybook@9.1.5(@testing-library/dom@10.4.1)(msw@2.11.6(@types/node@24.10.0)(typescript@5.9.3))(prettier@3.6.2))(typescript@5.9.3)
+      import-in-the-middle:
+        specifier: 2.0.2
+        version: 2.0.2
       msw:
         specifier: 2.11.6
         version: 2.11.6(@types/node@24.10.0)(typescript@5.9.3)
@@ -361,8 +367,8 @@ importers:
         specifier: 0.7.1
         version: 0.7.1(prettier@3.6.2)
       require-in-the-middle:
-        specifier: 7.5.2
-        version: 7.5.2
+        specifier: 8.0.1
+        version: 8.0.1
       storybook:
         specifier: 9.1.5
         version: 9.1.5(@testing-library/dom@10.4.1)(msw@2.11.6(@types/node@24.10.0)(typescript@5.9.3))(prettier@3.6.2)
@@ -1547,6 +1553,10 @@ packages:
     resolution: {integrity: sha512-CjruKY9V6NMssL/T1kAFgzosF1v9o6oeN+aX5JB/C/xPNtmgIJqcXHG7fA82Ou1zCpWGl4lROQUKwUNE1pMCyg==}
     engines: {node: '>=8.0.0'}
 
+  '@opentelemetry/api-logs@0.209.0':
+    resolution: {integrity: sha512-xomnUNi7TiAGtOgs0tb54LyrjRZLu9shJGGwkcN7NgtiPYOpNnKLkRJtzZvTjD/w6knSZH9sFZcUSUovYOPg6A==}
+    engines: {node: '>=8.0.0'}
+
   '@opentelemetry/api@1.9.0':
     resolution: {integrity: sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==}
     engines: {node: '>=8.0.0'}
@@ -1701,6 +1711,12 @@ packages:
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
 
+  '@opentelemetry/instrumentation@0.209.0':
+    resolution: {integrity: sha512-Cwe863ojTCnFlxVuuhG7s6ODkAOzKsAEthKAcI4MDRYz1OmGWYnmSl4X2pbyS+hBxVTdvfZePfoEA01IjqcEyw==}
+    engines: {node: ^18.19.0 || >=20.6.0}
+    peerDependencies:
+      '@opentelemetry/api': ^1.3.0
+
   '@opentelemetry/redis-common@0.38.2':
     resolution: {integrity: sha512-1BCcU93iwSRZvDAgwUxC/DV4T/406SkMfxGqu5ojc3AvNI+I9GhV7v0J1HljsczuuhcnFLYqD5VmwVXfCGHzxA==}
     engines: {node: ^18.19.0 || >=20.6.0}
@@ -4957,8 +4973,8 @@ packages:
     resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
     engines: {node: '>=6'}
 
-  import-in-the-middle@2.0.1:
-    resolution: {integrity: sha512-bruMpJ7xz+9jwGzrwEhWgvRrlKRYCRDBrfU+ur3FcasYXLJDxTruJ//8g2Noj+QFyRBeqbpj8Bhn4Fbw6HjvhA==}
+  import-in-the-middle@2.0.2:
+    resolution: {integrity: sha512-qet/hkGt3EbNGVtbDfPu0BM+tCqBS8wT1SYrstPaDKoWtshsC6licOemz7DVtpBEyvDNzo8UTBf9/GwWuSDZ9w==}
 
   imurmurhash@0.1.4:
     resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
@@ -6502,10 +6518,6 @@ packages:
     resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
     engines: {node: '>=0.10.0'}
 
-  require-in-the-middle@7.5.2:
-    resolution: {integrity: sha512-gAZ+kLqBdHarXB64XpAe2VCjB7rIRv+mU8tfRWziHRJ5umKsIHN2tLLv6EtMw7WCdP19S0ERVMldNvxYCHnhSQ==}
-    engines: {node: '>=8.6.0'}
-
   require-in-the-middle@8.0.1:
     resolution: {integrity: sha512-QT7FVMXfWOYFbeRBF6nu+I6tr2Tf3u0q8RIEjNob/heKY/nh7drD/k7eeMFmSQgnTtCzLDcCu/XEnpW2wk4xCQ==}
     engines: {node: '>=9.3.0 || >=8.10.0 <9.0.0'}
@@ -8720,6 +8732,10 @@ snapshots:
     dependencies:
       '@opentelemetry/api': 1.9.0
 
+  '@opentelemetry/api-logs@0.209.0':
+    dependencies:
+      '@opentelemetry/api': 1.9.0
+
   '@opentelemetry/api@1.9.0': {}
 
   '@opentelemetry/context-async-hooks@2.2.0(@opentelemetry/api@1.9.0)':
@@ -8920,7 +8936,16 @@ snapshots:
     dependencies:
       '@opentelemetry/api': 1.9.0
       '@opentelemetry/api-logs': 0.208.0
-      import-in-the-middle: 2.0.1
+      import-in-the-middle: 2.0.2
+      require-in-the-middle: 8.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@opentelemetry/instrumentation@0.209.0(@opentelemetry/api@1.9.0)':
+    dependencies:
+      '@opentelemetry/api': 1.9.0
+      '@opentelemetry/api-logs': 0.209.0
+      import-in-the-middle: 2.0.2
       require-in-the-middle: 8.0.1
     transitivePeerDependencies:
       - supports-color
@@ -9100,7 +9125,7 @@ snapshots:
   '@prisma/instrumentation@6.19.0(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      '@opentelemetry/instrumentation': 0.208.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/instrumentation': 0.209.0(@opentelemetry/api@1.9.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -9944,7 +9969,7 @@ snapshots:
       '@opentelemetry/semantic-conventions': 1.38.0
       '@sentry/core': 10.27.0
       '@sentry/opentelemetry': 10.27.0(@opentelemetry/api@1.9.0)(@opentelemetry/context-async-hooks@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/core@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/semantic-conventions@1.38.0)
-      import-in-the-middle: 2.0.1
+      import-in-the-middle: 2.0.2
     transitivePeerDependencies:
       - supports-color
 
@@ -9983,7 +10008,7 @@ snapshots:
       '@sentry/core': 10.27.0
       '@sentry/node-core': 10.27.0(@opentelemetry/api@1.9.0)(@opentelemetry/context-async-hooks@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/core@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/instrumentation@0.208.0(@opentelemetry/api@1.9.0))(@opentelemetry/resources@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/semantic-conventions@1.38.0)
       '@sentry/opentelemetry': 10.27.0(@opentelemetry/api@1.9.0)(@opentelemetry/context-async-hooks@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/core@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/semantic-conventions@1.38.0)
-      import-in-the-middle: 2.0.1
+      import-in-the-middle: 2.0.2
       minimatch: 9.0.5
     transitivePeerDependencies:
       - supports-color
@@ -12792,7 +12817,7 @@ snapshots:
       parent-module: 1.0.1
       resolve-from: 4.0.0
 
-  import-in-the-middle@2.0.1:
+  import-in-the-middle@2.0.2:
     dependencies:
       acorn: 8.15.0
       acorn-import-attributes: 1.9.5(acorn@8.15.0)
@@ -14631,14 +14656,6 @@ snapshots:
 
   require-from-string@2.0.2: {}
 
-  require-in-the-middle@7.5.2:
-    dependencies:
-      debug: 4.4.3
-      module-details-from-path: 1.0.4
-      resolve: 1.22.11
-    transitivePeerDependencies:
-      - supports-color
-
   require-in-the-middle@8.0.1:
     dependencies:
       debug: 4.4.3

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

@@ -1,32 +1,38 @@
 "use client";
 
 import { Button } from "@/components/atoms/Button/Button";
+import { Text } from "@/components/atoms/Text/Text";
+import { PublishAgentModal } from "@/components/contextual/PublishAgentModal/PublishAgentModal";
+import {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+} from "@/components/molecules/Alert/Alert";
 import { Breadcrumbs } from "@/components/molecules/Breadcrumbs/Breadcrumbs";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
 import { cn } from "@/lib/utils";
 import { PlusIcon } from "@phosphor-icons/react";
 import { useEffect, useState } from "react";
-import { RunAgentModal } from "./components/modals/RunAgentModal/RunAgentModal";
-import { useMarketplaceUpdate } from "./hooks/useMarketplaceUpdate";
 import { AgentVersionChangelog } from "./components/AgentVersionChangelog";
-import { MarketplaceBanners } from "@/components/contextual/MarketplaceBanners/MarketplaceBanners";
-import { PublishAgentModal } from "@/components/contextual/PublishAgentModal/PublishAgentModal";
-import { AgentSettingsButton } from "./components/other/AgentSettingsButton";
+import { AgentSettingsModal } from "./components/modals/AgentSettingsModal/AgentSettingsModal";
+import { RunAgentModal } from "./components/modals/RunAgentModal/RunAgentModal";
 import { AgentRunsLoading } from "./components/other/AgentRunsLoading";
 import { EmptySchedules } from "./components/other/EmptySchedules";
 import { EmptyTasks } from "./components/other/EmptyTasks";
 import { EmptyTemplates } from "./components/other/EmptyTemplates";
 import { EmptyTriggers } from "./components/other/EmptyTriggers";
+import { MarketplaceBanners } from "./components/other/MarketplaceBanners";
 import { SectionWrap } from "./components/other/SectionWrap";
 import { LoadingSelectedContent } from "./components/selected-views/LoadingSelectedContent";
 import { SelectedRunView } from "./components/selected-views/SelectedRunView/SelectedRunView";
 import { SelectedScheduleView } from "./components/selected-views/SelectedScheduleView/SelectedScheduleView";
-import { SelectedSettingsView } from "./components/selected-views/SelectedSettingsView/SelectedSettingsView";
 import { SelectedTemplateView } from "./components/selected-views/SelectedTemplateView/SelectedTemplateView";
 import { SelectedTriggerView } from "./components/selected-views/SelectedTriggerView/SelectedTriggerView";
 import { SelectedViewLayout } from "./components/selected-views/SelectedViewLayout";
 import { SidebarRunsList } from "./components/sidebar/SidebarRunsList/SidebarRunsList";
 import { AGENT_LIBRARY_SECTION_PADDING_X } from "./helpers";
+import { useAgentMissingCredentials } from "./hooks/useAgentMissingCredentials";
+import { useMarketplaceUpdate } from "./hooks/useMarketplaceUpdate";
 import { useNewAgentLibraryView } from "./useNewAgentLibraryView";
 
 export function NewAgentLibraryView() {
@@ -45,7 +51,6 @@ export function NewAgentLibraryView() {
     handleSelectRun,
     handleCountsChange,
     handleClearSelectedRun,
-    handleSelectSettings,
     onRunInitiated,
     onTriggerSetup,
     onScheduleCreated,
@@ -63,6 +68,10 @@ export function NewAgentLibraryView() {
   } = useMarketplaceUpdate({ agent });
 
   const [changelogOpen, setChangelogOpen] = useState(false);
+  const [settingsModalOpen, setSettingsModalOpen] = useState(false);
+
+  const { hasMissingCredentials, isLoading: isLoadingCredentials } =
+    useAgentMissingCredentials(agent);
 
   useEffect(() => {
     if (agent) {
@@ -137,13 +146,33 @@ export function NewAgentLibraryView() {
     return (
       <>
         <div className="flex h-full flex-col">
-          <div className="mx-6 pt-4">
-            <Breadcrumbs
-              items={[
-                { name: "My Library", link: "/library" },
-                { name: agent.name, link: `/library/agents/${agentId}` },
-              ]}
-            />
+          <div className="mx-6 flex flex-col gap-4 pt-4">
+            <div className="flex items-center justify-between">
+              <Breadcrumbs
+                items={[
+                  { name: "My Library", link: "/library" },
+                  { name: agent.name, link: `/library/agents/${agentId}` },
+                ]}
+              />
+              <AgentSettingsModal agent={agent} />
+            </div>
+            {hasMissingCredentials && !isLoadingCredentials && (
+              <Alert variant="warning">
+                <AlertTitle>Missing credentials</AlertTitle>
+                <AlertDescription>
+                  <Text variant="small" className="text-zinc-800">
+                    This agent requires credentials that are not configured.{" "}
+                    <button
+                      onClick={() => setSettingsModalOpen(true)}
+                      className="font-medium underline hover:no-underline"
+                    >
+                      Configure credentials
+                    </button>{" "}
+                    to run tasks.
+                  </Text>
+                </AlertDescription>
+              </Alert>
+            )}
           </div>
           <div className="flex min-h-0 flex-1">
             <EmptyTasks
@@ -154,6 +183,13 @@ export function NewAgentLibraryView() {
             />
           </div>
         </div>
+        {agent && (
+          <AgentSettingsModal
+            agent={agent}
+            controlledOpen={settingsModalOpen}
+            onOpenChange={setSettingsModalOpen}
+          />
+        )}
         {renderPublishAgentModal()}
         {renderVersionChangelog()}
       </>
@@ -164,37 +200,49 @@ export function NewAgentLibraryView() {
     <>
       <div className="mx-4 grid h-full grid-cols-1 gap-0 pt-3 md:ml-4 md:mr-0 md:gap-4 lg:grid-cols-[25%_70%]">
         <SectionWrap className="mb-3 block">
+          {hasMissingCredentials && !isLoadingCredentials && (
+            <div className={cn("mb-4", AGENT_LIBRARY_SECTION_PADDING_X)}>
+              <Alert variant="warning">
+                <AlertTitle>Missing credentials</AlertTitle>
+                <AlertDescription>
+                  <Text variant="small" className="text-zinc-800">
+                    This agent requires credentials that are not configured.{" "}
+                    <button
+                      onClick={() => setSettingsModalOpen(true)}
+                      className="font-medium underline hover:no-underline"
+                    >
+                      Configure credentials
+                    </button>{" "}
+                    to run tasks.
+                  </Text>
+                </AlertDescription>
+              </Alert>
+            </div>
+          )}
           <div
             className={cn(
               "border-b border-zinc-100 pb-5",
               AGENT_LIBRARY_SECTION_PADDING_X,
             )}
           >
-            <div className="flex items-center gap-2">
-              <RunAgentModal
-                triggerSlot={
-                  <Button
-                    variant="primary"
-                    size="large"
-                    className="flex-1"
-                    disabled={isTemplateLoading && activeTab === "templates"}
-                  >
-                    <PlusIcon size={20} /> New task
-                  </Button>
-                }
-                agent={agent}
-                onRunCreated={onRunInitiated}
-                onScheduleCreated={onScheduleCreated}
-                onTriggerSetup={onTriggerSetup}
-                initialInputValues={activeTemplate?.inputs}
-                initialInputCredentials={activeTemplate?.credentials}
-              />
-              <AgentSettingsButton
-                agent={agent}
-                onSelectSettings={handleSelectSettings}
-                selected={activeItem === "settings"}
-              />
-            </div>
+            <RunAgentModal
+              triggerSlot={
+                <Button
+                  variant="primary"
+                  size="large"
+                  className="w-full"
+                  disabled={isTemplateLoading && activeTab === "templates"}
+                >
+                  <PlusIcon size={20} /> New task
+                </Button>
+              }
+              agent={agent}
+              onRunCreated={onRunInitiated}
+              onScheduleCreated={onScheduleCreated}
+              onTriggerSetup={onTriggerSetup}
+              initialInputValues={activeTemplate?.inputs}
+              initialInputCredentials={activeTemplate?.credentials}
+            />
           </div>
 
           <SidebarRunsList
@@ -208,12 +256,7 @@ export function NewAgentLibraryView() {
         </SectionWrap>
 
         {activeItem ? (
-          activeItem === "settings" ? (
-            <SelectedSettingsView
-              agent={agent}
-              onClearSelectedRun={handleClearSelectedRun}
-            />
-          ) : activeTab === "scheduled" ? (
+          activeTab === "scheduled" ? (
             <SelectedScheduleView
               agent={agent}
               scheduleId={activeItem}
@@ -246,8 +289,6 @@ export function NewAgentLibraryView() {
               onSelectRun={handleSelectRun}
               onClearSelectedRun={handleClearSelectedRun}
               banner={renderMarketplaceUpdateBanner()}
-              onSelectSettings={handleSelectSettings}
-              selectedSettings={activeItem === "settings"}
             />
           )
         ) : sidebarLoading ? (
@@ -287,6 +328,13 @@ export function NewAgentLibraryView() {
           </SelectedViewLayout>
         )}
       </div>
+      {agent && (
+        <AgentSettingsModal
+          agent={agent}
+          controlledOpen={settingsModalOpen}
+          onOpenChange={setSettingsModalOpen}
+        />
+      )}
       {renderPublishAgentModal()}
       {renderVersionChangelog()}
     </>

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

@@ -4,6 +4,7 @@ import type { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { Text } from "@/components/atoms/Text/Text";
 import type { CredentialsMetaInput } from "@/lib/autogpt-server-api/types";
 import { CredentialsInput } from "../CredentialsInputs/CredentialsInputs";
+import { isSystemCredential } from "../CredentialsInputs/helpers";
 import { RunAgentInputs } from "../RunAgentInputs/RunAgentInputs";
 import { getAgentCredentialsFields, getAgentInputFields } from "./helpers";
 
@@ -71,6 +72,7 @@ export function AgentInputsReadOnly({
           {credentialFieldEntries.map(([key, inputSubSchema]) => {
             const credential = credentialInputs![key];
             if (!credential) return null;
+            if (isSystemCredential(credential)) return null;
 
             return (
               <CredentialsInput

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

@@ -0,0 +1,131 @@
+"use client";
+
+import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import { Button } from "@/components/atoms/Button/Button";
+import { Switch } from "@/components/atoms/Switch/Switch";
+import { Text } from "@/components/atoms/Text/Text";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { useAgentSafeMode } from "@/hooks/useAgentSafeMode";
+import { GearIcon } from "@phosphor-icons/react";
+import { useMemo, useState } from "react";
+import { useAgentSystemCredentials } from "../../../hooks/useAgentSystemCredentials";
+import { SystemCredentialRow } from "../../selected-views/SelectedSettingsView/components/SystemCredentialRow";
+
+interface Props {
+  agent: LibraryAgent;
+  controlledOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+}
+
+export function AgentSettingsModal({
+  agent,
+  controlledOpen,
+  onOpenChange,
+}: Props) {
+  const [internalIsOpen, setInternalIsOpen] = useState(false);
+  const isOpen = controlledOpen !== undefined ? controlledOpen : internalIsOpen;
+
+  function setIsOpen(open: boolean) {
+    if (onOpenChange) {
+      onOpenChange(open);
+    } else {
+      setInternalIsOpen(open);
+    }
+  }
+
+  const { currentSafeMode, isPending, hasHITLBlocks, handleToggle } =
+    useAgentSafeMode(agent);
+
+  const { hasSystemCredentials, systemCredentials } =
+    useAgentSystemCredentials(agent);
+
+  // Only show credential fields that have system credentials
+  const credentialFieldsWithSystemCreds = useMemo(() => {
+    return systemCredentials.map((item) => ({
+      fieldKey: item.key,
+      schema: item.schema,
+      systemCredential: item.credential,
+    }));
+  }, [systemCredentials]);
+
+  const hasAnySettings = hasHITLBlocks || hasSystemCredentials;
+
+  return (
+    <Dialog
+      controlled={{ isOpen, set: setIsOpen }}
+      styling={{ maxWidth: "600px", maxHeight: "90vh" }}
+      title="Agent Settings"
+    >
+      {controlledOpen === undefined && (
+        <Dialog.Trigger>
+          <Button
+            variant="ghost"
+            size="small"
+            className="m-0 min-w-0 rounded-full p-0 px-1"
+            aria-label="Agent Settings"
+          >
+            <GearIcon size={18} className="text-zinc-600" />
+            <Text variant="small">Agent Settings</Text>
+          </Button>
+        </Dialog.Trigger>
+      )}
+      <Dialog.Content>
+        <div className="space-y-6">
+          {hasHITLBlocks && (
+            <div className="flex w-full flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
+              <div className="flex w-full items-start justify-between gap-4">
+                <div className="flex-1">
+                  <Text variant="large-semibold">Require human approval</Text>
+                  <Text variant="large" className="mt-1 text-zinc-900">
+                    The agent will pause and wait for your review before
+                    continuing
+                  </Text>
+                </div>
+                <Switch
+                  checked={currentSafeMode || false}
+                  onCheckedChange={handleToggle}
+                  disabled={isPending}
+                  className="mt-1"
+                />
+              </div>
+            </div>
+          )}
+
+          {hasSystemCredentials && (
+            <div className="flex w-full max-w-2xl flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
+              <div>
+                <Text variant="large-semibold">System Credentials</Text>
+                <Text variant="body" className="mt-1 text-muted-foreground">
+                  These credentials are managed by AutoGPT and used by the agent
+                  to access various services. You can switch to your own
+                  credentials if preferred.
+                </Text>
+              </div>
+              <div className="w-full space-y-4">
+                {credentialFieldsWithSystemCreds.map(
+                  ({ fieldKey, schema, systemCredential }) => (
+                    <SystemCredentialRow
+                      key={fieldKey}
+                      credentialKey={fieldKey}
+                      agentId={agent.id.toString()}
+                      schema={schema}
+                      systemCredential={systemCredential}
+                    />
+                  ),
+                )}
+              </div>
+            </div>
+          )}
+
+          {!hasAnySettings && (
+            <div className="py-6">
+              <Text variant="body" className="text-muted-foreground">
+                This agent doesn&apos;t have any configurable settings.
+              </Text>
+            </div>
+          )}
+        </div>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

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

@@ -10,11 +10,10 @@ import { toDisplayName } from "@/providers/agent-credentials/helper";
 import { APIKeyCredentialsModal } from "./components/APIKeyCredentialsModal/APIKeyCredentialsModal";
 import { CredentialRow } from "./components/CredentialRow/CredentialRow";
 import { CredentialsSelect } from "./components/CredentialsSelect/CredentialsSelect";
-import { DeleteConfirmationModal } from "./components/DeleteConfirmationModal/DeleteConfirmationModal";
 import { HostScopedCredentialsModal } from "./components/HotScopedCredentialsModal/HotScopedCredentialsModal";
 import { OAuthFlowWaitingModal } from "./components/OAuthWaitingModal/OAuthWaitingModal";
 import { PasswordCredentialsModal } from "./components/PasswordCredentialsModal/PasswordCredentialsModal";
-import { getCredentialDisplayName } from "./helpers";
+import { isSystemCredential } from "./helpers";
 import {
   CredentialsInputState,
   useCredentialsInput,
@@ -37,6 +36,7 @@ type Props = {
   isOptional?: boolean;
   showTitle?: boolean;
   variant?: "default" | "node";
+  allowSystemCredentials?: boolean; // Allow system credentials (for settings only)
 };
 
 export function CredentialsInput({
@@ -50,6 +50,7 @@ export function CredentialsInput({
   isOptional = false,
   showTitle = true,
   variant = "default",
+  allowSystemCredentials = false,
 }: Props) {
   const hookData = useCredentialsInput({
     schema,
@@ -59,6 +60,7 @@ export function CredentialsInput({
     onLoaded,
     readOnly,
     isOptional,
+    allowSystemCredentials,
   });
 
   if (!isLoaded(hookData)) {
@@ -79,21 +81,22 @@ export function CredentialsInput({
     isHostScopedCredentialsModalOpen,
     isOAuth2FlowInProgress,
     oAuthPopupController,
-    credentialToDelete,
-    deleteCredentialsMutation,
     actionButtonText,
     setAPICredentialsModalOpen,
     setUserPasswordCredentialsModalOpen,
     setHostScopedCredentialsModalOpen,
-    setCredentialToDelete,
     handleActionButtonClick,
     handleCredentialSelect,
-    handleDeleteCredential,
-    handleDeleteConfirm,
   } = hookData;
 
   const displayName = toDisplayName(provider);
   const hasCredentialsToShow = credentialsToShow.length > 0;
+  const selectedCredentialIsSystem =
+    selectedCredential && isSystemCredential(selectedCredential);
+
+  if (readOnly && selectedCredentialIsSystem) {
+    return null;
+  }
 
   return (
     <div className={cn("mb-6", className)}>
@@ -137,15 +140,6 @@ export function CredentialsInput({
                     provider={provider}
                     displayName={displayName}
                     onSelect={() => handleCredentialSelect(credential.id)}
-                    onDelete={() =>
-                      handleDeleteCredential({
-                        id: credential.id,
-                        title: getCredentialDisplayName(
-                          credential,
-                          displayName,
-                        ),
-                      })
-                    }
                     readOnly={readOnly}
                   />
                 );
@@ -229,13 +223,6 @@ export function CredentialsInput({
               Error: {oAuthError}
             </Text>
           ) : null}
-
-          <DeleteConfirmationModal
-            credentialToDelete={credentialToDelete}
-            isDeleting={deleteCredentialsMutation.isPending}
-            onClose={() => setCredentialToDelete(null)}
-            onConfirm={handleDeleteConfirm}
-          />
         </>
       )}
     </div>

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

@@ -1,11 +1,11 @@
-import { Input } from "@/components/atoms/Input/Input";
-import { Button } from "@/components/atoms/Button/Button";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import {
   Form,
   FormDescription,
   FormField,
 } from "@/components/__legacy__/ui/form";
+import { Button } from "@/components/atoms/Button/Button";
+import { Input } from "@/components/atoms/Input/Input";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import {
   BlockIOCredentialsSubSchema,
   CredentialsMetaInput,
@@ -60,7 +60,10 @@ export function APIKeyCredentialsModal({
         )}
 
         <Form {...form}>
-          <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-2">
+          <form
+            onSubmit={form.handleSubmit(onSubmit)}
+            className="space-y-2 px-2"
+          >
             <FormField
               control={form.control}
               name="apiKey"
@@ -70,8 +73,7 @@ export function APIKeyCredentialsModal({
                     id="apiKey"
                     label="API Key"
                     type="password"
-                    placeholder="Enter API key..."
-                    size="small"
+                    placeholder="Enter API Key..."
                     hint={
                       schema.credentials_scopes ? (
                         <FormDescription>
@@ -98,8 +100,7 @@ export function APIKeyCredentialsModal({
                   id="title"
                   label="Name"
                   type="text"
-                  placeholder="Enter a name for this API key..."
-                  size="small"
+                  placeholder="Enter a name for this API Key..."
                   {...field}
                 />
               )}
@@ -113,13 +114,12 @@ export function APIKeyCredentialsModal({
                   label="Expiration Date"
                   type="datetime-local"
                   placeholder="Select expiration date..."
-                  size="small"
                   {...field}
                 />
               )}
             />
-            <Button type="submit" size="small" className="min-w-68">
-              Save & use this API key
+            <Button type="submit" className="min-w-68">
+              Add API Key
             </Button>
           </form>
         </Form>

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

@@ -26,7 +26,7 @@ type CredentialRowProps = {
   provider: string;
   displayName: string;
   onSelect: () => void;
-  onDelete: () => void;
+  onDelete?: () => void;
   readOnly?: boolean;
   showCaret?: boolean;
   asSelectTrigger?: boolean;
@@ -100,7 +100,7 @@ export function CredentialRow({
       {showCaret && !asSelectTrigger && (
         <CaretDown className="h-4 w-4 shrink-0 text-gray-400" />
       )}
-      {!readOnly && !showCaret && !asSelectTrigger && (
+      {!readOnly && !showCaret && !asSelectTrigger && onDelete && (
         <DropdownMenu>
           <DropdownMenuTrigger asChild>
             <button

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

@@ -65,7 +65,7 @@ export function CredentialsSelect({
       >
         <SelectTrigger
           className={cn(
-            "h-auto min-h-12 w-full rounded-medium border-zinc-200 p-0 pr-4 shadow-none",
+            "h-auto min-h-12 w-full rounded-medium p-0 pr-4 shadow-none",
             variant === "node" && "overflow-hidden",
           )}
         >
@@ -87,6 +87,39 @@ export function CredentialsSelect({
                 variant={variant}
               />
             </SelectValue>
+          ) : allowNone ? (
+            <SelectValue key="__none__" asChild>
+              <div
+                className={cn(
+                  "flex items-center gap-3 rounded-medium border border-zinc-200 bg-white p-3 transition-colors",
+                  variant === "node"
+                    ? "min-w-0 flex-1 overflow-hidden border-0 bg-transparent"
+                    : "border-0 bg-transparent",
+                )}
+              >
+                <div className="flex h-6 w-6 shrink-0 items-center justify-center rounded-full bg-zinc-200">
+                  <Text
+                    variant="body"
+                    className="text-xs font-medium text-zinc-500"
+                  >
+                    —
+                  </Text>
+                </div>
+                <div
+                  className={cn(
+                    "flex min-w-0 flex-1 flex-nowrap items-center gap-4",
+                    variant === "node" && "overflow-hidden",
+                  )}
+                >
+                  <Text
+                    variant="body"
+                    className={cn("tracking-tight text-zinc-500")}
+                  >
+                    None (skip this credential)
+                  </Text>
+                </div>
+              </div>
+            </SelectValue>
           ) : (
             <SelectValue key="placeholder" placeholder="Select credential" />
           )}

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

@@ -100,3 +100,29 @@ export function getCredentialDisplayName(
 
 export const OAUTH_TIMEOUT_MS = 5 * 60 * 1000;
 export const MASKED_KEY_LENGTH = 30;
+
+export function isSystemCredential(credential: {
+  title?: string | null;
+  is_system?: boolean;
+}): boolean {
+  if (credential.is_system === true) return true;
+  if (!credential.title) return false;
+  const titleLower = credential.title.toLowerCase();
+  return (
+    titleLower.includes("system") ||
+    titleLower.startsWith("use credits for") ||
+    titleLower.includes("use credits")
+  );
+}
+
+export function filterSystemCredentials<
+  T extends { title?: string; is_system?: boolean },
+>(credentials: T[]): T[] {
+  return credentials.filter((cred) => !isSystemCredential(cred));
+}
+
+export function getSystemCredentials<
+  T extends { title?: string; is_system?: boolean },
+>(credentials: T[]): T[] {
+  return credentials.filter((cred) => isSystemCredential(cred));
+}

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

@@ -6,9 +6,11 @@ import {
   CredentialsMetaInput,
 } from "@/lib/autogpt-server-api/types";
 import { useQueryClient } from "@tanstack/react-query";
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import {
+  filterSystemCredentials,
   getActionButtonText,
+  getSystemCredentials,
   OAUTH_TIMEOUT_MS,
   OAuthPopupResultMessage,
 } from "./helpers";
@@ -23,6 +25,7 @@ type Params = {
   onLoaded?: (loaded: boolean) => void;
   readOnly?: boolean;
   isOptional?: boolean;
+  allowSystemCredentials?: boolean; // Allow system credentials (for settings only)
 };
 
 export function useCredentialsInput({
@@ -33,6 +36,7 @@ export function useCredentialsInput({
   onLoaded,
   readOnly = false,
   isOptional = false,
+  allowSystemCredentials = false,
 }: Params) {
   const [isAPICredentialsModalOpen, setAPICredentialsModalOpen] =
     useState(false);
@@ -54,6 +58,7 @@ export function useCredentialsInput({
   const api = useBackendAPI();
   const queryClient = useQueryClient();
   const credentials = useCredentials(schema, siblingInputs);
+  const hasAttemptedAutoSelect = useRef(false);
 
   const deleteCredentialsMutation = useDeleteV1DeleteCredentials({
     mutation: {
@@ -82,13 +87,22 @@ export function useCredentialsInput({
   useEffect(() => {
     if (readOnly) return;
     if (!credentials || !("savedCredentials" in credentials)) return;
+    const availableCreds = allowSystemCredentials
+      ? credentials.savedCredentials
+      : filterSystemCredentials(credentials.savedCredentials);
     if (
       selectedCredential &&
-      !credentials.savedCredentials.some((c) => c.id === selectedCredential.id)
+      !availableCreds.some((c) => c.id === selectedCredential.id)
     ) {
       onSelectCredential(undefined);
     }
-  }, [credentials, selectedCredential, onSelectCredential, readOnly]);
+  }, [
+    credentials,
+    selectedCredential,
+    onSelectCredential,
+    readOnly,
+    allowSystemCredentials,
+  ]);
 
   // The available credential, if there is only one
   const singleCredential = useMemo(() => {
@@ -96,24 +110,111 @@ export function useCredentialsInput({
       return null;
     }
 
-    return credentials.savedCredentials.length === 1
-      ? credentials.savedCredentials[0]
-      : null;
-  }, [credentials]);
+    const credsToUse = allowSystemCredentials
+      ? credentials.savedCredentials
+      : filterSystemCredentials(credentials.savedCredentials);
+    return credsToUse.length === 1 ? credsToUse[0] : null;
+  }, [credentials, allowSystemCredentials]);
 
-  // Auto-select the one available credential (only if not optional)
+  // Auto-select the one available credential
+  // Prioritize system credentials if available
+  // For system credentials, always auto-select even if optional (they should be used by default)
   useEffect(() => {
     if (readOnly) return;
-    if (isOptional) return; // Don't auto-select when credential is optional
-    if (singleCredential && !selectedCredential) {
+    if (!credentials || !("savedCredentials" in credentials)) return;
+
+    // Early return if already selected to prevent infinite loops
+    const currentSelectedId = selectedCredential?.id;
+    if (currentSelectedId) {
+      hasAttemptedAutoSelect.current = true;
+      return;
+    }
+
+    // If selectedCredential is explicitly undefined and isOptional is true,
+    // don't auto-select - this could mean "None" was explicitly selected
+    // The parent component should handle setting the initial value
+    if (selectedCredential === undefined && isOptional) {
+      // Mark as attempted to prevent auto-selection when "None" is a valid choice
+      hasAttemptedAutoSelect.current = true;
+      return;
+    }
+
+    // Only attempt auto-selection once per credential load
+    if (hasAttemptedAutoSelect.current) return;
+
+    const supportedTypes = schema.credentials_types || [];
+    const requiredScopes = schema.credentials_scopes;
+    const savedCreds = credentials.savedCredentials;
+    const systemCreds = getSystemCredentials(savedCreds);
+
+    // Filter system credentials by type and scopes (same logic as useCredentials)
+    const matchingSystemCreds = systemCreds.filter((cred) => {
+      // Check type match
+      if (!supportedTypes.includes(cred.type)) {
+        return false;
+      }
+
+      // For OAuth2 credentials, check scopes
+      if (
+        cred.type === "oauth2" &&
+        requiredScopes &&
+        requiredScopes.length > 0
+      ) {
+        const grantedScopes = new Set(cred.scopes || []);
+        const hasAllRequiredScopes = new Set(requiredScopes).isSubsetOf(
+          grantedScopes,
+        );
+        if (!hasAllRequiredScopes) {
+          return false;
+        }
+      }
+
+      return true;
+    });
+
+    // First, try to auto-select system credential if available
+    if (matchingSystemCreds.length === 1) {
+      const systemCred = matchingSystemCreds[0];
+      const credProvider = credentials.provider;
+      hasAttemptedAutoSelect.current = true;
+      onSelectCredential({
+        id: systemCred.id,
+        type: systemCred.type,
+        provider: credProvider,
+        title: (systemCred as any).title,
+      });
+      return;
+    }
+
+    // Otherwise, auto-select single credential if there's only one (and not optional)
+    if (!isOptional && singleCredential) {
+      hasAttemptedAutoSelect.current = true;
       onSelectCredential(singleCredential);
     }
   }, [
-    singleCredential,
-    selectedCredential,
-    onSelectCredential,
+    singleCredential?.id, // Only depend on the ID, not the whole object
+    selectedCredential?.id, // Only depend on the ID, not the whole object
     readOnly,
     isOptional,
+    credentials,
+    schema.credentials_types,
+    schema.credentials_scopes,
+    // Note: onSelectCredential removed from deps to prevent infinite loops
+    // It should be stable, but if it's not, the ref will prevent multiple calls
+  ]);
+
+  // Reset the ref when credentials change significantly
+  useEffect(() => {
+    if (credentials && "savedCredentials" in credentials) {
+      hasAttemptedAutoSelect.current = false;
+    }
+  }, [
+    credentials && "savedCredentials" in credentials
+      ? credentials.savedCredentials.length
+      : 0,
+    credentials && "savedCredentials" in credentials
+      ? credentials.provider
+      : null,
   ]);
 
   if (
@@ -137,6 +238,11 @@ export function useCredentialsInput({
     oAuthCallback,
   } = credentials;
 
+  // Filter system credentials unless explicitly allowed (for settings)
+  const filteredCredentials = allowSystemCredentials
+    ? savedCredentials
+    : filterSystemCredentials(savedCredentials);
+
   async function handleOAuthLogin() {
     setOAuthError(null);
     const { login_url, state_token } = await api.oAuthLogin(
@@ -291,7 +397,7 @@ export function useCredentialsInput({
     supportsOAuth2,
     supportsUserPassword,
     supportsHostScoped,
-    credentialsToShow: savedCredentials,
+    credentialsToShow: filteredCredentials,
     selectedCredential,
     oAuthError,
     isAPICredentialsModalOpen,
@@ -306,7 +412,7 @@ export function useCredentialsInput({
       supportsApiKey,
       supportsUserPassword,
       supportsHostScoped,
-      savedCredentials.length > 0,
+      filteredCredentials.length > 0,
     ),
     setAPICredentialsModalOpen,
     setUserPasswordCredentialsModalOpen,

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

@@ -12,7 +12,7 @@ import {
   TooltipTrigger,
 } from "@/components/atoms/Tooltip/BaseTooltip";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { ScheduleAgentModal } from "../ScheduleAgentModal/ScheduleAgentModal";
 import { ModalHeader } from "./components/ModalHeader/ModalHeader";
 import { ModalRunSection } from "./components/ModalRunSection/ModalRunSection";
@@ -82,6 +82,8 @@ export function RunAgentModal({
   });
 
   const [isScheduleModalOpen, setIsScheduleModalOpen] = useState(false);
+  const [hasOverflow, setHasOverflow] = useState(false);
+  const contentRef = useRef<HTMLDivElement>(null);
 
   const hasAnySetupFields =
     Object.keys(agentInputFields || {}).length > 0 ||
@@ -89,6 +91,43 @@ export function RunAgentModal({
 
   const isTriggerRunType = defaultRunType.includes("trigger");
 
+  useEffect(() => {
+    if (!isOpen) return;
+
+    function checkOverflow() {
+      if (!contentRef.current) return;
+      const scrollableParent = contentRef.current
+        .closest("[data-dialog-content]")
+        ?.querySelector('[class*="overflow-y-auto"]');
+      if (scrollableParent) {
+        setHasOverflow(
+          scrollableParent.scrollHeight > scrollableParent.clientHeight,
+        );
+      }
+    }
+
+    const timeoutId = setTimeout(checkOverflow, 100);
+    const resizeObserver = new ResizeObserver(checkOverflow);
+    if (contentRef.current) {
+      const scrollableParent = contentRef.current
+        .closest("[data-dialog-content]")
+        ?.querySelector('[class*="overflow-y-auto"]');
+      if (scrollableParent) {
+        resizeObserver.observe(scrollableParent);
+      }
+    }
+
+    return () => {
+      clearTimeout(timeoutId);
+      resizeObserver.disconnect();
+    };
+  }, [
+    isOpen,
+    hasAnySetupFields,
+    agentInputFields,
+    agentCredentialsInputFields,
+  ]);
+
   function handleInputChange(key: string, value: string) {
     setInputValues((prev) => ({
       ...prev,
@@ -134,91 +173,97 @@ export function RunAgentModal({
       >
         <Dialog.Trigger>{triggerSlot}</Dialog.Trigger>
         <Dialog.Content>
-          {/* Header */}
-          <ModalHeader agent={agent} />
+          <div ref={contentRef} className="flex min-h-full flex-col">
+            <div className="flex-1">
+              {/* Header */}
+              <ModalHeader agent={agent} />
 
-          {/* Content */}
-          {hasAnySetupFields ? (
-            <div className="mt-10">
-              <RunAgentModalContextProvider
-                value={{
-                  agent,
-                  defaultRunType,
-                  presetName,
-                  setPresetName,
-                  presetDescription,
-                  setPresetDescription,
-                  inputValues,
-                  setInputValue: handleInputChange,
-                  agentInputFields,
-                  inputCredentials,
-                  setInputCredentialsValue: handleCredentialsChange,
-                  agentCredentialsInputFields,
-                }}
-              >
-                <ModalRunSection />
-              </RunAgentModalContextProvider>
+              {/* Content */}
+              {hasAnySetupFields ? (
+                <div className="mt-10 pb-32">
+                  <RunAgentModalContextProvider
+                    value={{
+                      agent,
+                      defaultRunType,
+                      presetName,
+                      setPresetName,
+                      presetDescription,
+                      setPresetDescription,
+                      inputValues,
+                      setInputValue: handleInputChange,
+                      agentInputFields,
+                      inputCredentials,
+                      setInputCredentialsValue: handleCredentialsChange,
+                      agentCredentialsInputFields,
+                    }}
+                  >
+                    <ModalRunSection />
+                  </RunAgentModalContextProvider>
+                </div>
+              ) : null}
             </div>
-          ) : null}
 
-          <Dialog.Footer className="mt-6 bg-white pt-4">
-            <div className="flex items-center justify-end gap-3">
-              {isTriggerRunType ? null : !allRequiredInputsAreSet ? (
-                <TooltipProvider>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <span>
-                        <Button
-                          variant="secondary"
-                          onClick={handleOpenScheduleModal}
-                          disabled={
-                            isExecuting ||
-                            isSettingUpTrigger ||
-                            !allRequiredInputsAreSet
-                          }
-                        >
-                          Schedule Task
-                        </Button>
-                      </span>
-                    </TooltipTrigger>
-                    <TooltipContent>
-                      <p>
-                        Please set up all required inputs and credentials before
-                        scheduling
-                      </p>
-                    </TooltipContent>
-                  </Tooltip>
-                </TooltipProvider>
-              ) : (
-                <Button
-                  variant="secondary"
-                  onClick={handleOpenScheduleModal}
-                  disabled={
-                    isExecuting ||
-                    isSettingUpTrigger ||
-                    !allRequiredInputsAreSet
-                  }
-                >
-                  Schedule Task
-                </Button>
-              )}
-              <RunActions
-                defaultRunType={defaultRunType}
-                onRun={handleRun}
-                isExecuting={isExecuting}
-                isSettingUpTrigger={isSettingUpTrigger}
-                isRunReady={allRequiredInputsAreSet}
+            <Dialog.Footer
+              className={`sticky bottom-0 z-10 bg-white pt-4 ${
+                hasOverflow
+                  ? "border-t border-neutral-100 shadow-[0_-2px_8px_rgba(0,0,0,0.04)]"
+                  : ""
+              }`}
+            >
+              <div className="flex items-center justify-end gap-3">
+                {isTriggerRunType ? null : !allRequiredInputsAreSet ? (
+                  <TooltipProvider>
+                    <Tooltip>
+                      <TooltipTrigger asChild>
+                        <span>
+                          <Button
+                            variant="secondary"
+                            onClick={handleOpenScheduleModal}
+                            disabled={
+                              isExecuting ||
+                              isSettingUpTrigger ||
+                              !allRequiredInputsAreSet
+                            }
+                          >
+                            Schedule Task
+                          </Button>
+                        </span>
+                      </TooltipTrigger>
+                      <TooltipContent>
+                        <p>
+                          Please set up all required inputs and credentials
+                          before scheduling
+                        </p>
+                      </TooltipContent>
+                    </Tooltip>
+                  </TooltipProvider>
+                ) : (
+                  <Button
+                    variant="secondary"
+                    onClick={handleOpenScheduleModal}
+                    disabled={isExecuting || isSettingUpTrigger}
+                  >
+                    Schedule Task
+                  </Button>
+                )}
+                <RunActions
+                  defaultRunType={defaultRunType}
+                  onRun={handleRun}
+                  isExecuting={isExecuting}
+                  isSettingUpTrigger={isSettingUpTrigger}
+                  isRunReady={allRequiredInputsAreSet}
+                />
+              </div>
+              <ScheduleAgentModal
+                isOpen={isScheduleModalOpen}
+                onClose={handleCloseScheduleModal}
+                agent={agent}
+                inputValues={inputValues}
+                inputCredentials={inputCredentials}
+                onScheduleCreated={handleScheduleCreated}
               />
-            </div>
-            <ScheduleAgentModal
-              isOpen={isScheduleModalOpen}
-              onClose={handleCloseScheduleModal}
-              agent={agent}
-              inputValues={inputValues}
-              inputCredentials={inputCredentials}
-              onScheduleCreated={handleScheduleCreated}
-            />
-          </Dialog.Footer>
+            </Dialog.Footer>
+          </div>
         </Dialog.Content>
       </Dialog>
     </>

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

@@ -1,6 +1,16 @@
 import { CredentialsInput } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs";
 import { Input } from "@/components/atoms/Input/Input";
 import { InformationTooltip } from "@/components/molecules/InformationTooltip/InformationTooltip";
+import { CredentialsProvidersContext } from "@/providers/agent-credentials/credentials-provider";
+import { useContext, useMemo } from "react";
+import {
+  NONE_CREDENTIAL_MARKER,
+  useAgentCredentialPreferencesStore,
+} from "../../../../../stores/agentCredentialPreferencesStore";
+import {
+  filterSystemCredentials,
+  isSystemCredential,
+} from "../../../CredentialsInputs/helpers";
 import { RunAgentInputs } from "../../../RunAgentInputs/RunAgentInputs";
 import { useRunAgentModalContext } from "../../context";
 import { ModalSection } from "../ModalSection/ModalSection";
@@ -22,8 +32,44 @@ export function ModalRunSection() {
     agentCredentialsInputFields,
   } = useRunAgentModalContext();
 
+  const allProviders = useContext(CredentialsProvidersContext);
+  const store = useAgentCredentialPreferencesStore();
+
   const inputFields = Object.entries(agentInputFields || {});
-  const credentialFields = Object.entries(agentCredentialsInputFields || {});
+
+  // Only show credential fields that have user credentials (NOT system credentials)
+  // System credentials should only be shown in settings, not in run modal
+  const credentialFields = useMemo(() => {
+    if (!allProviders || !agentCredentialsInputFields) return [];
+
+    return Object.entries(agentCredentialsInputFields).filter(
+      ([_key, schema]) => {
+        const providerNames = schema.credentials_provider || [];
+        const supportedTypes = schema.credentials_types || [];
+
+        // Check if any provider has user credentials (NOT system credentials)
+        for (const providerName of providerNames) {
+          const providerData = allProviders[providerName];
+          if (!providerData) continue;
+
+          const userCreds = filterSystemCredentials(
+            providerData.savedCredentials,
+          );
+          const matchingUserCreds = userCreds.filter((cred: { type: string }) =>
+            supportedTypes.includes(cred.type),
+          );
+
+          // If there are user credentials available, show this field
+          if (matchingUserCreds.length > 0) {
+            return true;
+          }
+        }
+
+        // Hide the field if only system credentials exist (or no credentials at all)
+        return false;
+      },
+    );
+  }, [agentCredentialsInputFields, allProviders]);
 
   // Get the list of required credentials from the schema
   const requiredCredentials = new Set(
@@ -98,22 +144,113 @@ export function ModalRunSection() {
           subtitle="These are the credentials the agent will use to perform this task"
         >
           <div className="space-y-6">
-            {Object.entries(agentCredentialsInputFields || {}).map(
-              ([key, inputSubSchema]) => (
-                <CredentialsInput
-                  key={key}
-                  schema={
-                    { ...inputSubSchema, discriminator: undefined } as any
+            {credentialFields
+              .map(([key, inputSubSchema]) => {
+                const selectedCred = inputCredentials?.[key];
+
+                // Check if the selected credential is a system credential
+                // First check the credential object itself, then look it up in providers
+                let isSystemCredSelected = false;
+                if (selectedCred) {
+                  // Check if credential object has is_system or title indicates system credential
+                  isSystemCredSelected = isSystemCredential(
+                    selectedCred as { title?: string; is_system?: boolean },
+                  );
+
+                  // If not detected by title/is_system, check by looking up in providers
+                  if (
+                    !isSystemCredSelected &&
+                    selectedCred.id &&
+                    allProviders
+                  ) {
+                    const providerNames =
+                      inputSubSchema.credentials_provider || [];
+                    for (const providerName of providerNames) {
+                      const providerData = allProviders[providerName];
+                      if (!providerData) continue;
+                      const systemCreds = providerData.savedCredentials.filter(
+                        (cred: any) => cred.is_system === true,
+                      );
+                      if (
+                        systemCreds.some(
+                          (cred: any) => cred.id === selectedCred.id,
+                        )
+                      ) {
+                        isSystemCredSelected = true;
+                        break;
+                      }
+                    }
                   }
-                  selectedCredentials={inputCredentials?.[key]}
-                  onSelectCredentials={(value) =>
-                    setInputCredentialsValue(key, value)
+                }
+
+                // If a system credential is selected, check if there are user credentials available
+                // If not, hide this field entirely (it will still be used for execution)
+                if (isSystemCredSelected) {
+                  const providerNames =
+                    inputSubSchema.credentials_provider || [];
+                  const supportedTypes = inputSubSchema.credentials_types || [];
+                  const hasUserCreds = providerNames.some(
+                    (providerName: string) => {
+                      const providerData = allProviders?.[providerName];
+                      if (!providerData) return false;
+                      const userCreds = filterSystemCredentials(
+                        providerData.savedCredentials,
+                      );
+                      return userCreds.some((cred: { type: string }) =>
+                        supportedTypes.includes(cred.type),
+                      );
+                    },
+                  );
+
+                  // If no user credentials available, hide the field completely
+                  if (!hasUserCreds) {
+                    return null;
                   }
-                  siblingInputs={inputValues}
-                  isOptional={!requiredCredentials.has(key)}
-                />
-              ),
-            )}
+                }
+
+                // If a system credential is selected but user creds exist, don't show it in the UI
+                // (it will still be used for execution, but user can select a user credential instead)
+                const credToDisplay = isSystemCredSelected
+                  ? undefined
+                  : selectedCred;
+
+                return (
+                  <CredentialsInput
+                    key={key}
+                    schema={
+                      { ...inputSubSchema, discriminator: undefined } as any
+                    }
+                    selectedCredentials={credToDisplay}
+                    onSelectCredentials={(value) => {
+                      // When user selects a credential, update the state and save to preferences
+                      setInputCredentialsValue(key, value);
+                      // Save to preferences store
+                      if (value === undefined) {
+                        store.setCredentialPreference(
+                          agent.id.toString(),
+                          key,
+                          NONE_CREDENTIAL_MARKER,
+                        );
+                      } else if (value === null) {
+                        store.setCredentialPreference(
+                          agent.id.toString(),
+                          key,
+                          null,
+                        );
+                      } else {
+                        store.setCredentialPreference(
+                          agent.id.toString(),
+                          key,
+                          value,
+                        );
+                      }
+                    }}
+                    siblingInputs={inputValues}
+                    isOptional={!requiredCredentials.has(key)}
+                  />
+                );
+              })
+              .filter(Boolean)}
           </div>
         </ModalSection>
       ) : null}

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

@@ -11,9 +11,25 @@ import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { LibraryAgentPreset } from "@/app/api/__generated__/models/libraryAgentPreset";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { isEmpty } from "@/lib/utils";
+import { CredentialsProvidersContext } from "@/providers/agent-credentials/credentials-provider";
 import { analytics } from "@/services/analytics";
 import { useQueryClient } from "@tanstack/react-query";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import {
+  NONE_CREDENTIAL_MARKER,
+  useAgentCredentialPreferencesStore,
+} from "../../../stores/agentCredentialPreferencesStore";
+import {
+  filterSystemCredentials,
+  getSystemCredentials,
+} from "../CredentialsInputs/helpers";
 import { showExecutionErrorToast } from "./errorHelpers";
 
 export type RunVariant =
@@ -42,8 +58,10 @@ export function useAgentRunModal(
   const [inputCredentials, setInputCredentials] = useState<Record<string, any>>(
     callbacks?.initialInputCredentials || {},
   );
+
   const [presetName, setPresetName] = useState<string>("");
   const [presetDescription, setPresetDescription] = useState<string>("");
+  const hasInitializedSystemCreds = useRef(false);
 
   // Determine the default run type based on agent capabilities
   const defaultRunType: RunVariant = agent.trigger_setup_info
@@ -58,6 +76,198 @@ export function useAgentRunModal(
     setInputCredentials(callbacks?.initialInputCredentials || {});
   }, [callbacks?.initialInputValues, callbacks?.initialInputCredentials]);
 
+  const allProviders = useContext(CredentialsProvidersContext);
+  const store = useAgentCredentialPreferencesStore();
+
+  // Initialize credentials from saved preferences or default system credentials
+  // This ensures credentials are used even when the field is not displayed
+  useEffect(() => {
+    if (!allProviders || !agent.credentials_input_schema?.properties) return;
+    if (callbacks?.initialInputCredentials) {
+      hasInitializedSystemCreds.current = true;
+      return; // Don't override if initial credentials provided
+    }
+    if (hasInitializedSystemCreds.current) return; // Already initialized
+
+    const properties = agent.credentials_input_schema.properties as Record<
+      string,
+      any
+    >;
+
+    // Use functional update to get current state and avoid stale closures
+    setInputCredentials((currentCreds) => {
+      const credsToAdd: Record<string, any> = {};
+
+      for (const [key, schema] of Object.entries(properties)) {
+        // Skip if already set
+        if (currentCreds[key]) continue;
+
+        // First, check if user has a saved preference
+        const savedPreference = store.getCredentialPreference(
+          agent.id.toString(),
+          key,
+        );
+        // Check if "None" was explicitly selected (special marker)
+        if (savedPreference === NONE_CREDENTIAL_MARKER) {
+          // User explicitly selected "None" - don't add any credential
+          continue;
+        }
+        if (savedPreference) {
+          credsToAdd[key] = savedPreference;
+          continue;
+        }
+
+        // Otherwise, find default system credentials for this field
+        const providerNames = schema.credentials_provider || [];
+        const supportedTypes = schema.credentials_types || [];
+        const requiredScopes = schema.credentials_scopes;
+
+        for (const providerName of providerNames) {
+          const providerData = allProviders[providerName];
+          if (!providerData) continue;
+
+          const systemCreds = getSystemCredentials(
+            providerData.savedCredentials,
+          );
+          const matchingSystemCreds = systemCreds.filter((cred) => {
+            if (!supportedTypes.includes(cred.type)) return false;
+
+            // For OAuth2 credentials, check scopes
+            if (
+              cred.type === "oauth2" &&
+              requiredScopes &&
+              requiredScopes.length > 0
+            ) {
+              const grantedScopes = new Set(cred.scopes || []);
+              const hasAllRequiredScopes = new Set(requiredScopes).isSubsetOf(
+                grantedScopes,
+              );
+              if (!hasAllRequiredScopes) return false;
+            }
+
+            return true;
+          });
+
+          // If there's exactly one system credential, use it as default
+          if (matchingSystemCreds.length === 1) {
+            const systemCred = matchingSystemCreds[0];
+            credsToAdd[key] = {
+              id: systemCred.id,
+              type: systemCred.type,
+              provider: providerName,
+              title: systemCred.title,
+            };
+            break; // Use first matching provider
+          }
+        }
+      }
+
+      // Only update if we found credentials to add
+      if (Object.keys(credsToAdd).length > 0) {
+        hasInitializedSystemCreds.current = true;
+        return {
+          ...currentCreds,
+          ...credsToAdd,
+        };
+      }
+
+      return currentCreds; // No changes
+    });
+  }, [
+    allProviders,
+    agent.credentials_input_schema,
+    agent.id,
+    store,
+    callbacks?.initialInputCredentials,
+  ]);
+
+  // Sync credentials with preferences store when modal opens
+  useEffect(() => {
+    if (!isOpen || !allProviders || !agent.credentials_input_schema?.properties)
+      return;
+    if (callbacks?.initialInputCredentials) return; // Don't override if initial credentials provided
+
+    const properties = agent.credentials_input_schema.properties as Record<
+      string,
+      any
+    >;
+
+    setInputCredentials((currentCreds) => {
+      const updatedCreds: Record<string, any> = { ...currentCreds };
+
+      for (const [key, schema] of Object.entries(properties)) {
+        const savedPreference = store.getCredentialPreference(
+          agent.id.toString(),
+          key,
+        );
+
+        if (savedPreference === NONE_CREDENTIAL_MARKER) {
+          // User explicitly selected "None" - remove from credentials
+          delete updatedCreds[key];
+        } else if (savedPreference) {
+          // User has a saved preference - use it
+          updatedCreds[key] = savedPreference;
+        } else if (!updatedCreds[key]) {
+          // No preference and no current credential - try to find default system credential
+          const providerNames = schema.credentials_provider || [];
+          const supportedTypes = schema.credentials_types || [];
+          const requiredScopes = schema.credentials_scopes;
+
+          for (const providerName of providerNames) {
+            const providerData = allProviders[providerName];
+            if (!providerData) continue;
+
+            const systemCreds = getSystemCredentials(
+              providerData.savedCredentials,
+            );
+            const matchingSystemCreds = systemCreds.filter((cred) => {
+              if (!supportedTypes.includes(cred.type)) return false;
+
+              if (
+                cred.type === "oauth2" &&
+                requiredScopes &&
+                requiredScopes.length > 0
+              ) {
+                const grantedScopes = new Set(cred.scopes || []);
+                const hasAllRequiredScopes = new Set(requiredScopes).isSubsetOf(
+                  grantedScopes,
+                );
+                if (!hasAllRequiredScopes) return false;
+              }
+
+              return true;
+            });
+
+            if (matchingSystemCreds.length === 1) {
+              const systemCred = matchingSystemCreds[0];
+              updatedCreds[key] = {
+                id: systemCred.id,
+                type: systemCred.type,
+                provider: providerName,
+                title: systemCred.title,
+              };
+              break;
+            }
+          }
+        }
+      }
+
+      return updatedCreds;
+    });
+  }, [
+    isOpen,
+    agent.id,
+    agent.credentials_input_schema,
+    allProviders,
+    store,
+    callbacks?.initialInputCredentials,
+  ]);
+
+  // Reset initialization flag when modal closes/opens or agent changes
+  useEffect(() => {
+    hasInitializedSystemCreds.current = false;
+  }, [isOpen, agent.graph_id]);
+
   // API mutations
   const executeGraphMutation = usePostV1ExecuteGraphAgent({
     mutation: {
@@ -169,15 +379,70 @@ export function useAgentRunModal(
       (agent.credentials_input_schema?.required as string[]) || [],
     );
 
+    // Filter out credential fields that only have system credentials available
+    // System credentials should not be required in the run modal
+    // Also check if user has a saved preference (including NONE_MARKER)
+    const requiredCredentialsToCheck = [...requiredCredentials].filter(
+      (key) => {
+        // Check if user has a saved preference first
+        const savedPreference = store.getCredentialPreference(
+          agent.id.toString(),
+          key,
+        );
+        // If "None" was explicitly selected, don't require it
+        if (savedPreference === NONE_CREDENTIAL_MARKER) {
+          return false;
+        }
+        // If user has a saved preference, it should be checked
+        if (savedPreference) {
+          return true;
+        }
+
+        const schema = agentCredentialsInputFields[key];
+        if (!schema || !allProviders) return true; // If we can't check, include it
+
+        const providerNames = schema.credentials_provider || [];
+        const supportedTypes = schema.credentials_types || [];
+
+        // Check if any provider has non-system credentials available
+        for (const providerName of providerNames) {
+          const providerData = allProviders[providerName];
+          if (!providerData) continue;
+
+          const userCreds = filterSystemCredentials(
+            providerData.savedCredentials,
+          );
+          const matchingUserCreds = userCreds.filter((cred) =>
+            supportedTypes.includes(cred.type),
+          );
+
+          // If there are user credentials available, this field should be checked
+          if (matchingUserCreds.length > 0) {
+            return true;
+          }
+        }
+
+        // If only system credentials are available, exclude from required check
+        return false;
+      },
+    );
+
     // Check if required credentials have valid id (not just key existence)
     // A credential is valid only if it has an id field set
-    const missing = [...requiredCredentials].filter((key) => {
+    const missing = requiredCredentialsToCheck.filter((key) => {
       const cred = inputCredentials[key];
       return !cred || !cred.id;
     });
 
     return [missing.length === 0, missing];
-  }, [agent.credentials_input_schema, inputCredentials]);
+  }, [
+    agent.credentials_input_schema,
+    agentCredentialsInputFields,
+    inputCredentials,
+    allProviders,
+    agent.id,
+    store,
+  ]);
 
   const credentialsRequired = useMemo(
     () => Object.keys(agentCredentialsInputFields || {}).length > 0,

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

@@ -1,37 +1,17 @@
 import { Button } from "@/components/atoms/Button/Button";
+import { Text } from "@/components/atoms/Text/Text";
 import { GearIcon } from "@phosphor-icons/react";
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { useAgentSafeMode } from "@/hooks/useAgentSafeMode";
-
-interface Props {
-  agent: LibraryAgent;
-  onSelectSettings: () => void;
-  selected?: boolean;
-}
-
-export function AgentSettingsButton({
-  agent,
-  onSelectSettings,
-  selected,
-}: Props) {
-  const { hasHITLBlocks } = useAgentSafeMode(agent);
-
-  if (!hasHITLBlocks) {
-    return null;
-  }
 
+export function AgentSettingsButton() {
   return (
     <Button
-      variant={selected ? "secondary" : "ghost"}
+      variant="ghost"
       size="small"
       className="m-0 min-w-0 rounded-full p-0 px-1"
-      onClick={onSelectSettings}
       aria-label="Agent Settings"
     >
-      <GearIcon
-        size={18}
-        className={selected ? "text-zinc-900" : "text-zinc-600"}
-      />
+      <GearIcon size={18} className="text-zinc-600" />
+      <Text variant="small">Agent Settings</Text>
     </Button>
   );
 }

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

@@ -1,3 +1,5 @@
+"use client";
+
 import { Text } from "@/components/atoms/Text/Text";
 
 export function EmptySchedules() {

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

@@ -20,6 +20,7 @@ import { useQueryClient } from "@tanstack/react-query";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
 import { useState } from "react";
+import { useAgentMissingCredentials } from "../../hooks/useAgentMissingCredentials";
 import { RunAgentModal } from "../modals/RunAgentModal/RunAgentModal";
 import { RunDetailCard } from "../selected-views/RunDetailCard/RunDetailCard";
 import { EmptyTasksIllustration } from "./EmptyTasksIllustration";
@@ -44,6 +45,7 @@ export function EmptyTasks({
   const [isDeletingAgent, setIsDeletingAgent] = useState(false);
 
   const { mutateAsync: deleteAgent } = useDeleteV2DeleteLibraryAgent();
+  const { hasMissingCredentials } = useAgentMissingCredentials(agent);
 
   async function handleDeleteAgent() {
     if (!agent.id) return;
@@ -124,6 +126,7 @@ export function EmptyTasks({
                   variant="primary"
                   size="large"
                   className="inline-flex w-[19.75rem]"
+                  disabled={hasMissingCredentials}
                 >
                   Setup your task
                 </Button>

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

@@ -1,3 +1,5 @@
+"use client";
+
 import { Text } from "@/components/atoms/Text/Text";
 
 export function EmptyTemplates() {

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

@@ -1,3 +1,5 @@
+"use client";
+
 import { Text } from "@/components/atoms/Text/Text";
 
 export function EmptyTriggers() {

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

@@ -3,7 +3,7 @@
 import { Button } from "@/components/atoms/Button/Button";
 import { Text } from "@/components/atoms/Text/Text";
 
-interface MarketplaceBannersProps {
+interface Props {
   hasUpdate?: boolean;
   latestVersion?: number;
   hasUnpublishedChanges?: boolean;
@@ -21,7 +21,7 @@ export function MarketplaceBanners({
   isUpdating,
   onUpdate,
   onPublish,
-}: MarketplaceBannersProps) {
+}: Props) {
   const renderUpdateBanner = () => {
     if (hasUpdate && latestVersion) {
       return (

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

@@ -1,3 +1,5 @@
+"use client";
+
 import { cn } from "@/lib/utils";
 
 type Props = {

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

@@ -1,22 +1,16 @@
+import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { Skeleton } from "@/components/__legacy__/ui/skeleton";
 import { cn } from "@/lib/utils";
-import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { AGENT_LIBRARY_SECTION_PADDING_X } from "../../helpers";
 import { SelectedViewLayout } from "./SelectedViewLayout";
 
 interface Props {
   agent: LibraryAgent;
-  onSelectSettings?: () => void;
-  selectedSettings?: boolean;
 }
 
 export function LoadingSelectedContent(props: Props) {
   return (
-    <SelectedViewLayout
-      agent={props.agent}
-      onSelectSettings={props.onSelectSettings}
-      selectedSettings={props.selectedSettings}
-    >
+    <SelectedViewLayout agent={props.agent}>
       <div
         className={cn("flex flex-col gap-4", AGENT_LIBRARY_SECTION_PADDING_X)}
       >

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

@@ -33,8 +33,6 @@ interface Props {
   onSelectRun?: (id: string) => void;
   onClearSelectedRun?: () => void;
   banner?: React.ReactNode;
-  onSelectSettings?: () => void;
-  selectedSettings?: boolean;
 }
 
 export function SelectedRunView({
@@ -43,8 +41,6 @@ export function SelectedRunView({
   onSelectRun,
   onClearSelectedRun,
   banner,
-  onSelectSettings,
-  selectedSettings,
 }: Props) {
   const { run, preset, isLoading, responseError, httpError } =
     useSelectedRunView(agent.graph_id, runId);
@@ -84,12 +80,7 @@ export function SelectedRunView({
   return (
     <div className="flex h-full w-full gap-4">
       <div className="flex min-h-0 min-w-0 flex-1 flex-col">
-        <SelectedViewLayout
-          agent={agent}
-          banner={banner}
-          onSelectSettings={onSelectSettings}
-          selectedSettings={selectedSettings}
-        >
+        <SelectedViewLayout agent={agent} banner={banner}>
           <div className="flex flex-col gap-4">
             <RunDetailHeader agent={agent} run={run} />
 

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

@@ -21,8 +21,6 @@ interface Props {
   scheduleId: string;
   onClearSelectedRun?: () => void;
   banner?: React.ReactNode;
-  onSelectSettings?: () => void;
-  selectedSettings?: boolean;
 }
 
 export function SelectedScheduleView({
@@ -30,8 +28,6 @@ export function SelectedScheduleView({
   scheduleId,
   onClearSelectedRun,
   banner,
-  onSelectSettings,
-  selectedSettings,
 }: Props) {
   const { schedule, isLoading, error } = useSelectedScheduleView(
     agent.graph_id,
@@ -76,12 +72,7 @@ export function SelectedScheduleView({
   return (
     <div className="flex h-full w-full gap-4">
       <div className="flex min-h-0 min-w-0 flex-1 flex-col">
-        <SelectedViewLayout
-          agent={agent}
-          banner={banner}
-          onSelectSettings={onSelectSettings}
-          selectedSettings={selectedSettings}
-        >
+        <SelectedViewLayout agent={agent} banner={banner}>
           <div className="flex flex-col gap-4">
             <div className="flex w-full flex-col gap-0">
               <RunDetailHeader

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

@@ -1,11 +1,12 @@
 import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { Text } from "@/components/atoms/Text/Text";
-import { Switch } from "@/components/atoms/Switch/Switch";
 import { Button } from "@/components/atoms/Button/Button";
-import { ArrowLeftIcon } from "@phosphor-icons/react";
+import { Switch } from "@/components/atoms/Switch/Switch";
+import { Text } from "@/components/atoms/Text/Text";
 import { useAgentSafeMode } from "@/hooks/useAgentSafeMode";
-import { SelectedViewLayout } from "../SelectedViewLayout";
+import { ArrowLeftIcon } from "@phosphor-icons/react";
 import { AGENT_LIBRARY_SECTION_PADDING_X } from "../../../helpers";
+import { SelectedViewLayout } from "../SelectedViewLayout";
+import { SystemCredentialsSection } from "./components/SystemCredentialsSection";
 
 interface Props {
   agent: LibraryAgent;
@@ -16,8 +17,12 @@ export function SelectedSettingsView({ agent, onClearSelectedRun }: Props) {
   const { currentSafeMode, isPending, hasHITLBlocks, handleToggle } =
     useAgentSafeMode(agent);
 
+  const hasCredentialsSchema =
+    agent.credentials_input_schema &&
+    Object.keys(agent.credentials_input_schema.properties || {}).length > 0;
+
   return (
-    <SelectedViewLayout agent={agent} onSelectSettings={() => {}}>
+    <SelectedViewLayout agent={agent}>
       <div className="flex flex-col gap-4">
         <div
           className={`${AGENT_LIBRARY_SECTION_PADDING_X} mb-8 flex items-center gap-3`}
@@ -33,15 +38,8 @@ export function SelectedSettingsView({ agent, onClearSelectedRun }: Props) {
           <Text variant="h2">Agent Settings</Text>
         </div>
 
-        <div className={AGENT_LIBRARY_SECTION_PADDING_X}>
-          {!hasHITLBlocks ? (
-            <div className="rounded-xl border border-zinc-100 bg-white p-6">
-              <Text variant="body" className="text-muted-foreground">
-                This agent doesn&apos;t have any human-in-the-loop blocks, so
-                there are no settings to configure.
-              </Text>
-            </div>
-          ) : (
+        <div className={`${AGENT_LIBRARY_SECTION_PADDING_X} space-y-6`}>
+          {hasHITLBlocks && (
             <div className="flex w-full max-w-2xl flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
               <div className="flex w-full items-start justify-between gap-4">
                 <div className="flex-1">
@@ -60,6 +58,16 @@ export function SelectedSettingsView({ agent, onClearSelectedRun }: Props) {
               </div>
             </div>
           )}
+
+          {hasCredentialsSchema && <SystemCredentialsSection agent={agent} />}
+
+          {!hasHITLBlocks && !hasCredentialsSchema && (
+            <div className="rounded-xl border border-zinc-100 bg-white p-6">
+              <Text variant="body" className="text-muted-foreground">
+                This agent doesn&apos;t have any configurable settings.
+              </Text>
+            </div>
+          )}
         </div>
       </div>
     </SelectedViewLayout>

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

@@ -0,0 +1,99 @@
+"use client";
+
+import { Text } from "@/components/atoms/Text/Text";
+import { CredentialsMetaResponse } from "@/lib/autogpt-server-api/types";
+import { toDisplayName } from "@/providers/agent-credentials/helper";
+import { useEffect, useState } from "react";
+import { CredentialsInput } from "../../../../components/modals/CredentialsInputs/CredentialsInputs";
+import {
+  NONE_CREDENTIAL_MARKER,
+  useAgentCredentialPreferencesStore,
+} from "../../../../stores/agentCredentialPreferencesStore";
+
+interface Props {
+  credentialKey: string;
+  agentId: string;
+  schema: any;
+  systemCredential: CredentialsMetaResponse;
+}
+
+export function SystemCredentialRow({
+  credentialKey,
+  agentId,
+  schema,
+  systemCredential,
+}: Props) {
+  const store = useAgentCredentialPreferencesStore();
+
+  // Initialize with saved preference or default to system credential
+  const savedPreference = store.getCredentialPreference(agentId, credentialKey);
+  const defaultCredential = {
+    id: systemCredential.id,
+    type: systemCredential.type,
+    provider: systemCredential.provider,
+    title: systemCredential.title,
+  };
+
+  // If saved preference is the NONE marker, use undefined (which CredentialsInput interprets as "None")
+  // Otherwise use saved preference or default
+  const [selectedCredential, setSelectedCredential] = useState<any>(
+    savedPreference === NONE_CREDENTIAL_MARKER
+      ? undefined
+      : savedPreference || defaultCredential,
+  );
+
+  // Update when preference changes externally
+  useEffect(() => {
+    const preference = store.getCredentialPreference(agentId, credentialKey);
+    if (preference === NONE_CREDENTIAL_MARKER) {
+      setSelectedCredential(undefined);
+    } else if (preference) {
+      setSelectedCredential(preference);
+    } else {
+      setSelectedCredential(defaultCredential);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [credentialKey, agentId]);
+
+  const providerName = schema.credentials_provider?.[0] || "";
+  const displayName = toDisplayName(providerName);
+
+  function handleSelectCredentials(value: any) {
+    setSelectedCredential(value);
+    // Save preference:
+    // - undefined = explicitly selected "None" (save NONE_CREDENTIAL_MARKER)
+    // - null = use default system credential (fallback behavior, save null)
+    // - credential object = use this specific credential
+    if (value === undefined) {
+      // User explicitly selected "None" - save special marker
+      store.setCredentialPreference(
+        agentId,
+        credentialKey,
+        NONE_CREDENTIAL_MARKER,
+      );
+    } else if (value === null) {
+      // User cleared selection - use default system credential
+      store.setCredentialPreference(agentId, credentialKey, null);
+    } else {
+      // User selected a credential
+      store.setCredentialPreference(agentId, credentialKey, value);
+    }
+  }
+
+  return (
+    <div className="rounded-lg border border-zinc-100 bg-zinc-50/50 px-4 pb-2 pt-4">
+      <Text variant="body-medium" className="mb-2 ml-2">
+        {displayName}
+      </Text>
+
+      <CredentialsInput
+        schema={{ ...schema, discriminator: undefined }}
+        selectedCredentials={selectedCredential}
+        onSelectCredentials={handleSelectCredentials}
+        showTitle={false}
+        isOptional
+        allowSystemCredentials={true}
+      />
+    </div>
+  );
+}

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

@@ -0,0 +1,63 @@
+"use client";
+
+import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import { Text } from "@/components/atoms/Text/Text";
+import { useAgentSystemCredentials } from "../../../../hooks/useAgentSystemCredentials";
+import { SystemCredentialRow } from "./SystemCredentialRow";
+
+interface Props {
+  agent: LibraryAgent;
+}
+
+export function SystemCredentialsSection({ agent }: Props) {
+  const { hasSystemCredentials, systemCredentials, isLoading } =
+    useAgentSystemCredentials(agent);
+
+  if (isLoading) {
+    return (
+      <div className="flex w-full max-w-2xl flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
+        <Text variant="large-semibold">System Credentials</Text>
+        <Text variant="body" className="text-muted-foreground">
+          Loading credentials...
+        </Text>
+      </div>
+    );
+  }
+
+  if (!hasSystemCredentials) return null;
+
+  // Group by credential field key (from schema) to show one row per field
+  const credentialsByField = systemCredentials.reduce(
+    (acc, item) => {
+      if (!acc[item.key]) {
+        acc[item.key] = item;
+      }
+      return acc;
+    },
+    {} as Record<string, (typeof systemCredentials)[0]>,
+  );
+
+  return (
+    <div className="flex w-full max-w-2xl flex-col items-start gap-4 rounded-xl border border-zinc-100 bg-white p-6">
+      <div>
+        <Text variant="large-semibold">System Credentials</Text>
+        <Text variant="body" className="mt-1 text-muted-foreground">
+          These credentials are managed by AutoGPT and used by the agent to
+          access various services. You can switch to your own credentials if
+          preferred.
+        </Text>
+      </div>
+      <div className="w-full space-y-4">
+        {Object.entries(credentialsByField).map(([fieldKey, item]) => (
+          <SystemCredentialRow
+            key={fieldKey}
+            credentialKey={fieldKey}
+            agentId={agent.id.toString()}
+            schema={item.schema}
+            systemCredential={item.credential}
+          />
+        ))}
+      </div>
+    </div>
+  );
+}

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

@@ -1,7 +1,7 @@
-import { Breadcrumbs } from "@/components/molecules/Breadcrumbs/Breadcrumbs";
-import { AgentSettingsButton } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/other/AgentSettingsButton";
 import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import { Breadcrumbs } from "@/components/molecules/Breadcrumbs/Breadcrumbs";
 import { AGENT_LIBRARY_SECTION_PADDING_X } from "../../helpers";
+import { AgentSettingsModal } from "../modals/AgentSettingsModal/AgentSettingsModal";
 import { SectionWrap } from "../other/SectionWrap";
 
 interface Props {
@@ -9,8 +9,6 @@ interface Props {
   children: React.ReactNode;
   banner?: React.ReactNode;
   additionalBreadcrumb?: { name: string; link?: string };
-  onSelectSettings?: () => void;
-  selectedSettings?: boolean;
 }
 
 export function SelectedViewLayout(props: Props) {
@@ -19,8 +17,8 @@ export function SelectedViewLayout(props: Props) {
       <div
         className={`${AGENT_LIBRARY_SECTION_PADDING_X} flex-shrink-0 border-b border-zinc-100 pb-0 lg:pb-4`}
       >
-        {props.banner && <div className="mb-4">{props.banner}</div>}
-        <div className="relative flex w-fit items-center gap-2">
+        {props.banner}
+        <div className="relative flex w-full items-center justify-between">
           <Breadcrumbs
             items={[
               { name: "My Library", link: "/library" },
@@ -33,15 +31,9 @@ export function SelectedViewLayout(props: Props) {
                 : []),
             ]}
           />
-          {props.agent && props.onSelectSettings && (
-            <div className="absolute -right-8">
-              <AgentSettingsButton
-                agent={props.agent}
-                onSelectSettings={props.onSelectSettings}
-                selected={props.selectedSettings}
-              />
-            </div>
-          )}
+          <div className="absolute right-0">
+            <AgentSettingsModal agent={props.agent} />
+          </div>
         </div>
       </div>
       <div className="flex min-h-0 flex-1 flex-col overflow-y-auto overflow-x-visible">

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/hooks/useAgentCredentialPreferences.ts

@@ -0,0 +1,109 @@
+"use client";
+
+import { CredentialsMetaInput } from "@/lib/autogpt-server-api/types";
+import { storage } from "@/services/storage/local-storage";
+import { useCallback, useEffect, useState } from "react";
+
+// Special marker to indicate "None" was explicitly selected
+export const NONE_CREDENTIAL_MARKER = { __none__: true } as const;
+
+type AgentCredentialPreferences = Record<
+  string,
+  CredentialsMetaInput | null | typeof NONE_CREDENTIAL_MARKER
+>;
+
+const STORAGE_KEY_PREFIX = "agent_credential_prefs_";
+
+function getStorageKey(agentId: string): string {
+  return `${STORAGE_KEY_PREFIX}${agentId}`;
+}
+
+function loadPreferences(agentId: string): AgentCredentialPreferences {
+  const key = getStorageKey(agentId);
+  const stored = storage.get(key as any);
+  if (!stored) return {};
+  try {
+    const parsed = JSON.parse(stored);
+    // Convert serialized NONE markers back to the constant
+    const result: AgentCredentialPreferences = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (
+        value &&
+        typeof value === "object" &&
+        "__none__" in value &&
+        (value as any).__none__ === true
+      ) {
+        result[key] = NONE_CREDENTIAL_MARKER;
+      } else {
+        result[key] = value as CredentialsMetaInput | null;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+function savePreferences(
+  agentId: string,
+  preferences: AgentCredentialPreferences,
+): void {
+  const key = getStorageKey(agentId);
+  storage.set(key as any, JSON.stringify(preferences));
+}
+
+export function useAgentCredentialPreferences(agentId: string) {
+  const [preferences, setPreferences] = useState<AgentCredentialPreferences>(
+    () => loadPreferences(agentId),
+  );
+
+  useEffect(() => {
+    const loaded = loadPreferences(agentId);
+    setPreferences(loaded);
+  }, [agentId]);
+
+  const setCredentialPreference = useCallback(
+    (
+      credentialKey: string,
+      credential: CredentialsMetaInput | null | typeof NONE_CREDENTIAL_MARKER,
+    ) => {
+      setPreferences((prev) => {
+        const updated = {
+          ...prev,
+          [credentialKey]: credential,
+        };
+        savePreferences(agentId, updated);
+        return updated;
+      });
+    },
+    [agentId],
+  );
+
+  const getCredentialPreference = useCallback(
+    (
+      credentialKey: string,
+    ): CredentialsMetaInput | null | typeof NONE_CREDENTIAL_MARKER => {
+      return preferences[credentialKey] ?? null;
+    },
+    [preferences],
+  );
+
+  const clearPreference = useCallback(
+    (credentialKey: string) => {
+      setPreferences((prev) => {
+        const updated = { ...prev };
+        delete updated[credentialKey];
+        savePreferences(agentId, updated);
+        return updated;
+      });
+    },
+    [agentId],
+  );
+
+  return {
+    preferences,
+    setCredentialPreference,
+    getCredentialPreference,
+    clearPreference,
+  };
+}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/hooks/useAgentMissingCredentials.ts

@@ -0,0 +1,105 @@
+"use client";
+
+import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import { CredentialsProvidersContext } from "@/providers/agent-credentials/credentials-provider";
+import { toDisplayName } from "@/providers/agent-credentials/helper";
+import { useContext, useMemo } from "react";
+import { getSystemCredentials } from "../components/modals/CredentialsInputs/helpers";
+
+/**
+ * Hook to check if an agent is missing required SYSTEM credentials.
+ * This is only used to block "New Task" buttons.
+ * User credential validation is handled separately in RunAgentModal.
+ */
+export function useAgentMissingCredentials(
+  agent: LibraryAgent | null | undefined,
+) {
+  const allProviders = useContext(CredentialsProvidersContext);
+
+  const result = useMemo(() => {
+    if (
+      !agent ||
+      !agent.id ||
+      !allProviders ||
+      !agent.credentials_input_schema?.properties
+    ) {
+      return {
+        hasMissingCredentials: false,
+        missingCredentials: [],
+        isLoading: !allProviders || !agent,
+      };
+    }
+
+    const properties = agent.credentials_input_schema.properties as Record<
+      string,
+      any
+    >;
+    const requiredCredentials = new Set(
+      (agent.credentials_input_schema.required as string[]) || [],
+    );
+
+    const missingCredentials: Array<{
+      key: string;
+      providerDisplayName: string;
+    }> = [];
+
+    for (const [key, schema] of Object.entries(properties)) {
+      const isRequired = requiredCredentials.has(key);
+      if (!isRequired) continue; // Only check required credentials
+
+      const providerNames = schema.credentials_provider || [];
+      const supportedTypes = schema.credentials_types || [];
+      const requiredScopes = schema.credentials_scopes;
+
+      let hasSystemCredential = false;
+
+      // Check if any provider has a system credential available
+      for (const providerName of providerNames) {
+        const providerData = allProviders[providerName];
+        if (!providerData) continue;
+
+        const systemCreds = getSystemCredentials(providerData.savedCredentials);
+        const matchingSystemCreds = systemCreds.filter((cred) => {
+          if (!supportedTypes.includes(cred.type)) return false;
+
+          if (
+            cred.type === "oauth2" &&
+            requiredScopes &&
+            requiredScopes.length > 0
+          ) {
+            const grantedScopes = new Set(cred.scopes || []);
+            const hasAllRequiredScopes = new Set(requiredScopes).isSubsetOf(
+              grantedScopes,
+            );
+            if (!hasAllRequiredScopes) return false;
+          }
+
+          return true;
+        });
+
+        // If there's a system credential available, it's not missing
+        if (matchingSystemCreds.length > 0) {
+          hasSystemCredential = true;
+          break;
+        }
+      }
+
+      // If no system credential available, mark as missing
+      if (!hasSystemCredential) {
+        const providerName = providerNames[0] || "";
+        missingCredentials.push({
+          key,
+          providerDisplayName: toDisplayName(providerName),
+        });
+      }
+    }
+
+    return {
+      hasMissingCredentials: missingCredentials.length > 0,
+      missingCredentials,
+      isLoading: false,
+    };
+  }, [allProviders, agent?.credentials_input_schema, agent?.id]);
+
+  return result;
+}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/hooks/useAgentSystemCredentials.ts

@@ -0,0 +1,130 @@
+"use client";
+
+import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
+import { CredentialsMetaResponse } from "@/lib/autogpt-server-api/types";
+import {
+  CredentialsProviderData,
+  CredentialsProvidersContext,
+} from "@/providers/agent-credentials/credentials-provider";
+import { toDisplayName } from "@/providers/agent-credentials/helper";
+import { useContext, useMemo } from "react";
+import {
+  filterSystemCredentials,
+  getSystemCredentials,
+} from "../components/modals/CredentialsInputs/helpers";
+
+interface SystemCredentialInfo {
+  key: string;
+  provider: string;
+  schema: any;
+  credential: CredentialsMetaResponse;
+}
+
+interface MissingCredentialInfo {
+  key: string;
+  provider: string;
+  providerDisplayName: string;
+}
+
+interface UseAgentSystemCredentialsResult {
+  hasSystemCredentials: boolean;
+  systemCredentials: SystemCredentialInfo[];
+  hasMissingSystemCredentials: boolean;
+  missingSystemCredentials: MissingCredentialInfo[];
+  isLoading: boolean;
+}
+
+export function useAgentSystemCredentials(
+  agent: LibraryAgent,
+): UseAgentSystemCredentialsResult {
+  const allProviders = useContext(CredentialsProvidersContext);
+
+  const result = useMemo(() => {
+    const empty = {
+      hasSystemCredentials: false,
+      systemCredentials: [],
+      hasMissingSystemCredentials: false,
+      missingSystemCredentials: [],
+      isLoading: false,
+    };
+
+    if (!agent.credentials_input_schema?.properties) return empty;
+
+    if (!allProviders) return { ...empty, isLoading: true };
+
+    const properties = agent.credentials_input_schema.properties as Record<
+      string,
+      any
+    >;
+    const requiredCredentials = new Set(
+      (agent.credentials_input_schema.required as string[]) || [],
+    );
+    const systemCredentials: SystemCredentialInfo[] = [];
+    const missingSystemCredentials: MissingCredentialInfo[] = [];
+
+    for (const [key, schema] of Object.entries(properties)) {
+      const providerNames = schema.credentials_provider || [];
+      const isRequired = requiredCredentials.has(key);
+      const supportedTypes = schema.credentials_types || [];
+
+      for (const providerName of providerNames) {
+        const providerData: CredentialsProviderData | undefined =
+          allProviders[providerName];
+
+        if (!providerData) {
+          // Provider not loaded yet - don't mark as missing, wait for load
+          continue;
+        }
+
+        // Check for system credentials - now backend always returns them with is_system: true
+        const systemCreds = getSystemCredentials(providerData.savedCredentials);
+        const userCreds = filterSystemCredentials(
+          providerData.savedCredentials,
+        );
+
+        const matchingSystemCreds = systemCreds.filter((cred) =>
+          supportedTypes.includes(cred.type),
+        );
+        const matchingUserCreds = userCreds.filter((cred) =>
+          supportedTypes.includes(cred.type),
+        );
+
+        // Add system credentials if they exist (even if not configured, backend returns them)
+        for (const cred of matchingSystemCreds) {
+          systemCredentials.push({
+            key,
+            provider: providerName,
+            schema,
+            credential: cred,
+          });
+        }
+
+        // Only mark as missing if it's required AND there are NO credentials available
+        // (neither system nor user). This is a true "missing" state.
+        // Note: We don't block based on this anymore since the run modal
+        // has its own validation (allRequiredInputsAreSet)
+        if (
+          isRequired &&
+          matchingSystemCreds.length === 0 &&
+          matchingUserCreds.length === 0
+        ) {
+          missingSystemCredentials.push({
+            key,
+            provider: providerName,
+            providerDisplayName: toDisplayName(providerName),
+          });
+        }
+      }
+    }
+
+    return {
+      hasSystemCredentials: systemCredentials.length > 0,
+      systemCredentials,
+      hasMissingSystemCredentials: missingSystemCredentials.length > 0,
+      missingSystemCredentials,
+      isLoading: false,
+    };
+  }, [agent.credentials_input_schema, allProviders]);
+
+  return result;
+}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/stores/agentCredentialPreferencesStore.ts

@@ -0,0 +1,135 @@
+import { CredentialsMetaInput } from "@/lib/autogpt-server-api/types";
+import { storage } from "@/services/storage/local-storage";
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+
+// Special marker to indicate "None" was explicitly selected
+export const NONE_CREDENTIAL_MARKER = { __none__: true } as const;
+
+type CredentialPreference =
+  | CredentialsMetaInput
+  | null
+  | typeof NONE_CREDENTIAL_MARKER;
+
+type AgentCredentialPreferences = Record<string, CredentialPreference>;
+
+interface AgentCredentialPreferencesStore {
+  preferences: Record<string, AgentCredentialPreferences>; // agentId -> preferences
+  setCredentialPreference: (
+    agentId: string,
+    credentialKey: string,
+    credential: CredentialPreference,
+  ) => void;
+  getCredentialPreference: (
+    agentId: string,
+    credentialKey: string,
+  ) => CredentialPreference;
+  clearPreference: (agentId: string, credentialKey: string) => void;
+}
+
+const STORAGE_KEY = "agent_credential_preferences";
+
+// Custom storage adapter for localStorage
+const customStorage = {
+  getItem: (name: string): string | null => {
+    return storage.get(name as any) || null;
+  },
+  setItem: (name: string, value: string): void => {
+    storage.set(name as any, value);
+  },
+  removeItem: (name: string): void => {
+    storage.clean(name as any);
+  },
+};
+
+export const useAgentCredentialPreferencesStore =
+  create<AgentCredentialPreferencesStore>()(
+    persist(
+      (set, get) => ({
+        preferences: {},
+
+        setCredentialPreference: (agentId, credentialKey, credential) => {
+          set((state) => {
+            const agentPrefs = state.preferences[agentId] || {};
+            const updated = {
+              ...state.preferences,
+              [agentId]: {
+                ...agentPrefs,
+                [credentialKey]: credential,
+              },
+            };
+            return { preferences: updated };
+          });
+        },
+
+        getCredentialPreference: (agentId, credentialKey) => {
+          const state = get();
+          const pref = state.preferences[agentId]?.[credentialKey];
+          // Convert serialized NONE marker back to constant
+          if (
+            pref &&
+            typeof pref === "object" &&
+            "__none__" in pref &&
+            (pref as any).__none__ === true &&
+            pref !== NONE_CREDENTIAL_MARKER
+          ) {
+            return NONE_CREDENTIAL_MARKER;
+          }
+          return pref ?? null;
+        },
+
+        clearPreference: (agentId, credentialKey) => {
+          set((state) => {
+            const agentPrefs = state.preferences[agentId] || {};
+            const updated = { ...agentPrefs };
+            delete updated[credentialKey];
+            return {
+              preferences: {
+                ...state.preferences,
+                [agentId]: updated,
+              },
+            };
+          });
+        },
+      }),
+      {
+        name: STORAGE_KEY,
+        storage: createJSONStorage(() => customStorage),
+        // Transform on rehydrate to convert NONE markers
+        onRehydrateStorage: () => (state, error) => {
+          if (error || !state) {
+            console.error("Failed to rehydrate credential preferences:", error);
+            return;
+          }
+          // Convert serialized NONE markers back to constant
+          const converted: Record<string, AgentCredentialPreferences> = {};
+          for (const [agentId, prefs] of Object.entries(
+            state.preferences || {},
+          )) {
+            const convertedPrefs: AgentCredentialPreferences = {};
+            for (const [key, value] of Object.entries(prefs)) {
+              if (
+                value &&
+                typeof value === "object" &&
+                "__none__" in value &&
+                (value as any).__none__ === true &&
+                value !== NONE_CREDENTIAL_MARKER
+              ) {
+                convertedPrefs[key] = NONE_CREDENTIAL_MARKER;
+              } else {
+                convertedPrefs[key] = value as CredentialPreference;
+              }
+            }
+            converted[agentId] = convertedPrefs;
+          }
+          // Update state with converted preferences
+          if (
+            Object.keys(converted).length > 0 ||
+            Object.keys(state.preferences || {}).length > 0
+          ) {
+            state.preferences = converted;
+          }
+        },
+      },
+    ),
+  );

autogpt_platform/frontend/src/app/api/openapi.json

@@ -6792,6 +6792,12 @@
             "anyOf": [{ "type": "string" }, { "type": "null" }],
             "title": "Host",
             "description": "Host pattern for host-scoped credentials"
+          },
+          "is_system": {
+            "type": "boolean",
+            "title": "Is System",
+            "description": "Whether this is a system-managed credential",
+            "default": false
           }
         },
         "type": "object",

autogpt_platform/frontend/src/components/atoms/Button/Button.tsx

@@ -20,6 +20,7 @@ export function Button(props: ButtonProps) {
     rightIcon,
     children,
     as = "button",
+    asChild: _asChild, // Destructure to prevent passing to DOM
     ...restProps
   } = props;
 

autogpt_platform/frontend/src/components/molecules/Dialog/components/DrawerWrap.tsx

@@ -49,7 +49,12 @@ export function DrawerWrap({
         >
           {title ? (
             <Drawer.Title className={drawerStyles.title}>{title}</Drawer.Title>
-          ) : null}
+          ) : (
+            <span className="sr-only">
+              {/* Title is required for a11y compliance even if not displayed so screen readers can announce it */}
+              <Drawer.Title>{title}</Drawer.Title>
+            </span>
+          )}
 
           {!isForceOpen ? (
             title ? (

autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts

@@ -593,6 +593,7 @@ export type CredentialsMetaResponse = {
   scopes?: Array<string>;
   username?: string;
   host?: string;
+  is_system?: boolean;
 };
 
 /* Mirror of backend/server/integrations/router.py:CredentialsDeletionResponse */

autogpt_platform/frontend/src/providers/agent-credentials/credentials-provider.tsx

@@ -1,5 +1,4 @@
-import { createContext, useCallback, useEffect, useState } from "react";
-import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
+import { useToastOnFail } from "@/components/molecules/Toast/use-toast";
 import {
   APIKeyCredentials,
   CredentialsDeleteNeedConfirmationResponse,
@@ -10,8 +9,9 @@ import {
   UserPasswordCredentials,
 } from "@/lib/autogpt-server-api";
 import { useBackendAPI } from "@/lib/autogpt-server-api/context";
-import { useToastOnFail } from "@/components/molecules/Toast/use-toast";
+import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
 import { toDisplayName } from "@/providers/agent-credentials/helper";
+import { createContext, useCallback, useEffect, useState } from "react";
 
 type APIKeyCredentialsCreatable = Omit<
   APIKeyCredentials,
@@ -72,6 +72,8 @@ export default function CredentialsProvider({
   const api = useBackendAPI();
   const onFailToast = useToastOnFail();
 
+  console.log("providers", providers);
+
   const addCredentials = useCallback(
     (
       provider: CredentialsProviderName,
@@ -218,17 +220,7 @@ export default function CredentialsProvider({
     [api, onFailToast],
   );
 
-  // Fetch provider names on mount
-  useEffect(() => {
-    api
-      .listProviders()
-      .then((names) => {
-        setProviderNames(names);
-      })
-      .catch(onFailToast("load provider names"));
-  }, [api, onFailToast]);
-
-  useEffect(() => {
+  const loadCredentials = useCallback(() => {
     if (!isLoggedIn || providerNames.length === 0) {
       if (isLoggedIn == false) setProviders({});
       return;
@@ -288,6 +280,20 @@ export default function CredentialsProvider({
     onFailToast,
   ]);
 
+  // Fetch provider names on mount
+  useEffect(() => {
+    api
+      .listProviders()
+      .then((names) => {
+        setProviderNames(names);
+      })
+      .catch(onFailToast("Load provider names"));
+  }, [api, onFailToast]);
+
+  useEffect(() => {
+    loadCredentials();
+  }, [loadCredentials]);
+
   return (
     <CredentialsProvidersContext.Provider value={providers}>
       {children}