fix poetry lock

- Added Langfuse configuration to settings and environment variables.
- Introduced Langfuse client for fetching prompts in chat service.
- Updated ChatConfig to include Langfuse prompt name.
- Enhanced service logic to retrieve prompts from Langfuse, improving prompt management capabilities.

This integration allows for rapid runtime prompt updates and eventual analytics of the performance of the Co-Pilot system.

This commit aims to trial this service as a potential option.

autogpt_platform/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(ls:*)",
+      "WebFetch(domain:langfuse.com)",
+      "Bash(poetry install:*)"
+    ]
+  }
+}

autogpt_platform/Makefile

@@ -1,4 +1,4 @@
-.PHONY: start-core stop-core logs-core format lint migrate run-backend run-frontend load-store-agents
+.PHONY: start-core stop-core logs-core format lint migrate run-backend stop-backend run-frontend load-store-agents backfill-store-embeddings
 
 # Run just Supabase + Redis + RabbitMQ
 start-core:
@@ -6,11 +6,12 @@ start-core:
 
 # Stop core services
 stop-core:
-	docker compose stop 
+	docker compose stop deps
 
 reset-db:
-	docker compose stop db
 	rm -rf db/docker/volumes/db/data
+	cd backend && poetry run prisma migrate deploy
+	cd backend && poetry run prisma generate
 	
 # View logs for core services
 logs-core:
@@ -33,7 +34,14 @@ migrate:
 	cd backend && poetry run prisma migrate deploy
 	cd backend && poetry run prisma generate
 
-run-backend:
+stop-backend:
+	@echo "Stopping backend processes..."
+	@cd backend && poetry run cli stop 2>/dev/null || true
+	@echo "Killing any processes using backend ports..."
+	@lsof -ti:8001,8002,8003,8004,8005,8006,8007 | xargs kill -9 2>/dev/null || true
+	@echo "Backend stopped"
+
+run-backend: stop-backend
 	cd backend && poetry run app
 
 run-frontend:
@@ -45,6 +53,9 @@ test-data:
 load-store-agents:
 	cd backend && poetry run load-store-agents
 
+backfill-store-embeddings:
+	cd backend && poetry run python -m backend.api.features.store.backfill_embeddings
+
 help:
 	@echo "Usage: make <target>"
 	@echo "Targets:"
@@ -54,7 +65,9 @@ help:
 	@echo "  logs-core - Tail the logs for core services"
 	@echo "  format - Format & lint backend (Python) and frontend (TypeScript) code"
 	@echo "  migrate - Run backend database migrations"
-	@echo "  run-backend - Run the backend FastAPI server"
+	@echo "  stop-backend - Stop any running backend processes"
+	@echo "  run-backend - Run the backend FastAPI server (stops existing processes first)"
 	@echo "  run-frontend - Run the frontend Next.js development server"
 	@echo "  test-data - Run the test data creator"
 	@echo "  load-store-agents - Load store agents from agents/ folder into test database"
+	@echo "  backfill-store-embeddings - Generate embeddings for store agents that don't have them"

autogpt_platform/backend/.env.default

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

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

@@ -9,6 +9,7 @@ import prisma.enums
 
 import backend.api.features.store.cache as store_cache
 import backend.api.features.store.db as store_db
+import backend.api.features.store.embeddings as store_embeddings
 import backend.api.features.store.model as store_model
 import backend.util.json
 
@@ -150,3 +151,54 @@ async def admin_download_agent_file(
         return fastapi.responses.FileResponse(
             tmp_file.name, filename=file_name, media_type="application/json"
         )
+
+
+@router.get(
+    "/embeddings/stats",
+    summary="Get Embedding Statistics",
+)
+async def get_embedding_stats() -> dict[str, typing.Any]:
+    """
+    Get statistics about embedding coverage for store listings.
+
+    Returns counts of total approved listings, listings with embeddings,
+    listings without embeddings, and coverage percentage.
+    """
+    try:
+        stats = await store_embeddings.get_embedding_stats()
+        return stats
+    except Exception as e:
+        logger.exception("Error getting embedding stats: %s", e)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="An error occurred while retrieving embedding stats",
+        )
+
+
+@router.post(
+    "/embeddings/backfill",
+    summary="Backfill Missing Embeddings",
+)
+async def backfill_embeddings(
+    batch_size: int = 10,
+) -> dict[str, typing.Any]:
+    """
+    Trigger backfill of embeddings for approved listings that don't have them.
+
+    Args:
+        batch_size: Number of embeddings to generate in one call (default 10)
+
+    Returns:
+        Dict with processed count, success count, failure count, and message
+    """
+    try:
+        result = await store_embeddings.backfill_missing_embeddings(
+            batch_size=batch_size
+        )
+        return result
+    except Exception as e:
+        logger.exception("Error backfilling embeddings: %s", e)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="An error occurred while backfilling embeddings",
+        )

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

@@ -45,6 +45,13 @@ class ChatConfig(BaseSettings):
         default=3, description="Maximum number of agent schedules"
     )
 
+    # Langfuse Prompt Management Configuration
+    # Note: Langfuse credentials are in Settings().secrets (settings.py)
+    langfuse_prompt_name: str = Field(
+        default="CoPilot Prompt",
+        description="Name of the prompt in Langfuse to fetch",
+    )
+
     @field_validator("api_key", mode="before")
     @classmethod
     def get_api_key(cls, v):

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

@@ -2,15 +2,11 @@
 
 import logging
 from datetime import UTC, datetime
-from typing import Any, cast
+from typing import Any
 
 from prisma.models import ChatMessage as PrismaChatMessage
 from prisma.models import ChatSession as PrismaChatSession
-from prisma.types import (
-    ChatMessageCreateInput,
-    ChatSessionCreateInput,
-    ChatSessionUpdateInput,
-)
+from prisma.types import ChatSessionUpdateInput
 
 from backend.util.json import SafeJson
 
@@ -34,13 +30,13 @@ async def create_chat_session(
     user_id: str | None,
 ) -> PrismaChatSession:
     """Create a new chat session in the database."""
-    data = ChatSessionCreateInput(
-        id=session_id,
-        userId=user_id,
-        credentials=SafeJson({}),
-        successfulAgentRuns=SafeJson({}),
-        successfulAgentSchedules=SafeJson({}),
-    )
+    data = {
+        "id": session_id,
+        "userId": user_id,
+        "credentials": SafeJson({}),
+        "successfulAgentRuns": SafeJson({}),
+        "successfulAgentSchedules": SafeJson({}),
+    }
     return await PrismaChatSession.prisma().create(
         data=data,
         include={"Messages": True},
@@ -94,16 +90,12 @@ async def add_chat_message(
     function_call: dict[str, Any] | None = None,
 ) -> PrismaChatMessage:
     """Add a message to a chat session."""
-    # Build the input dict dynamically - only include optional fields when they
-    # have values, as Prisma TypedDict validation fails when optional fields
-    # are explicitly set to None
     data: dict[str, Any] = {
         "Session": {"connect": {"id": session_id}},
         "role": role,
         "sequence": sequence,
     }
 
-    # Add optional string fields
     if content is not None:
         data["content"] = content
     if name is not None:
@@ -112,8 +104,6 @@ async def add_chat_message(
         data["toolCallId"] = tool_call_id
     if refusal is not None:
         data["refusal"] = refusal
-
-    # Add optional JSON fields only when they have values
     if tool_calls is not None:
         data["toolCalls"] = SafeJson(tool_calls)
     if function_call is not None:
@@ -125,9 +115,7 @@ async def add_chat_message(
         data={"updatedAt": datetime.now(UTC)},
     )
 
-    return await PrismaChatMessage.prisma().create(
-        data=cast(ChatMessageCreateInput, data)
-    )
+    return await PrismaChatMessage.prisma().create(data=data)
 
 
 async def add_chat_messages_batch(
@@ -141,16 +129,12 @@ async def add_chat_messages_batch(
 
     created_messages = []
     for i, msg in enumerate(messages):
-        # Build the input dict dynamically - only include optional JSON fields
-        # when they have values, as Prisma TypedDict validation fails when
-        # optional fields are explicitly set to None
         data: dict[str, Any] = {
             "Session": {"connect": {"id": session_id}},
             "role": msg["role"],
             "sequence": start_sequence + i,
         }
 
-        # Add optional string fields
         if msg.get("content") is not None:
             data["content"] = msg["content"]
         if msg.get("name") is not None:
@@ -159,16 +143,12 @@ async def add_chat_messages_batch(
             data["toolCallId"] = msg["tool_call_id"]
         if msg.get("refusal") is not None:
             data["refusal"] = msg["refusal"]
-
-        # Add optional JSON fields only when they have values
         if msg.get("tool_calls") is not None:
             data["toolCalls"] = SafeJson(msg["tool_calls"])
         if msg.get("function_call") is not None:
             data["functionCall"] = SafeJson(msg["function_call"])
 
-        created = await PrismaChatMessage.prisma().create(
-            data=cast(ChatMessageCreateInput, data)
-        )
+        created = await PrismaChatMessage.prisma().create(data=data)
         created_messages.append(created)
 
     # Update session's updatedAt timestamp

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

@@ -78,7 +78,7 @@ async def test_chatsession_db_storage():
     # Create session with messages including assistant message
     s = ChatSession.new(user_id=None)
     s.messages = messages  # Contains user, assistant, and tool messages
-    assert s.session_id is not None, "Session id is not set"
+
     # Upsert to save to both cache and DB
     s = await upsert_chat_session(s)
 

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

@@ -4,6 +4,7 @@ from datetime import UTC, datetime
 from typing import Any
 
 import orjson
+from langfuse import Langfuse
 from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletionChunk, ChatCompletionToolParam
 
@@ -12,12 +13,20 @@ from backend.data.understanding import (
     get_business_understanding,
 )
 from backend.util.exceptions import NotFoundError
+from backend.util.settings import Settings
 
 from . import db as chat_db
 from .config import ChatConfig
-from .model import ChatMessage, ChatSession, Usage
-from .model import create_chat_session as model_create_chat_session
-from .model import get_chat_session, upsert_chat_session
+from .model import (
+    ChatMessage,
+    ChatSession,
+    Usage,
+    get_chat_session,
+    upsert_chat_session,
+)
+from .model import (
+    create_chat_session as model_create_chat_session,
+)
 from .response_model import (
     StreamBaseResponse,
     StreamEnd,
@@ -34,8 +43,53 @@ from .tools import execute_tool, tools
 logger = logging.getLogger(__name__)
 
 config = ChatConfig()
+settings = Settings()
 client = AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
 
+# Langfuse client (lazy initialization)
+_langfuse_client: Langfuse | None = None
+
+
+def _get_langfuse_client() -> Langfuse:
+    """Get or create the Langfuse client for prompt management."""
+    global _langfuse_client
+    if _langfuse_client is None:
+        if not settings.secrets.langfuse_public_key or not settings.secrets.langfuse_secret_key:
+            raise ValueError(
+                "Langfuse credentials not configured. "
+                "Set LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY environment variables."
+            )
+        _langfuse_client = Langfuse(
+            public_key=settings.secrets.langfuse_public_key,
+            secret_key=settings.secrets.langfuse_secret_key,
+            host=settings.secrets.langfuse_host or "https://cloud.langfuse.com",
+        )
+    return _langfuse_client
+
+
+def _get_langfuse_prompt() -> str:
+    """Fetch the latest production prompt from Langfuse.
+
+    Returns:
+        The compiled prompt text from Langfuse.
+
+    Raises:
+        Exception: If Langfuse is unavailable or prompt fetch fails.
+    """
+    try:
+        langfuse = _get_langfuse_client()
+        # cache_ttl_seconds=0 disables SDK caching to always get the latest prompt
+        prompt = langfuse.get_prompt(config.langfuse_prompt_name, cache_ttl_seconds=0)
+        compiled = prompt.compile()
+        logger.info(
+            f"Fetched prompt '{config.langfuse_prompt_name}' from Langfuse "
+            f"(version: {prompt.version})"
+        )
+        return compiled
+    except Exception as e:
+        logger.error(f"Failed to fetch prompt from Langfuse: {e}")
+        raise
+
 
 async def _is_first_session(user_id: str) -> bool:
     """Check if this is the user's first chat session.
@@ -71,7 +125,12 @@ async def _build_system_prompt(
             effective_prompt_type = "onboarding"
 
     # Start with the base system prompt for the specified type
-    base_prompt = config.get_system_prompt_for_type(effective_prompt_type)
+    if effective_prompt_type == "default":
+        # Fetch from Langfuse for the default prompt
+        base_prompt = _get_langfuse_prompt()
+    else:
+        # Use local file for other prompt types (e.g., onboarding)
+        base_prompt = config.get_system_prompt_for_type(effective_prompt_type)
 
     # If user is authenticated, try to fetch their business understanding
     if user_id:

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

@@ -7,26 +7,41 @@ from backend.api.features.chat.model import ChatSession
 from .add_understanding import AddUnderstandingTool
 from .agent_output import AgentOutputTool
 from .base import BaseTool
+from .create_agent import CreateAgentTool
+from .edit_agent import EditAgentTool
 from .find_agent import FindAgentTool
+from .find_block import FindBlockTool
 from .find_library_agent import FindLibraryAgentTool
 from .run_agent import RunAgentTool
+from .run_block import RunBlockTool
+from .search_docs import SearchDocsTool
 
 if TYPE_CHECKING:
     from backend.api.features.chat.response_model import StreamToolExecutionResult
 
 # Initialize tool instances
 add_understanding_tool = AddUnderstandingTool()
+create_agent_tool = CreateAgentTool()
+edit_agent_tool = EditAgentTool()
 find_agent_tool = FindAgentTool()
+find_block_tool = FindBlockTool()
 find_library_agent_tool = FindLibraryAgentTool()
 run_agent_tool = RunAgentTool()
+run_block_tool = RunBlockTool()
+search_docs_tool = SearchDocsTool()
 agent_output_tool = AgentOutputTool()
 
 # Export tools as OpenAI format
 tools: list[ChatCompletionToolParam] = [
     add_understanding_tool.as_openai_tool(),
+    create_agent_tool.as_openai_tool(),
+    edit_agent_tool.as_openai_tool(),
     find_agent_tool.as_openai_tool(),
+    find_block_tool.as_openai_tool(),
     find_library_agent_tool.as_openai_tool(),
     run_agent_tool.as_openai_tool(),
+    run_block_tool.as_openai_tool(),
+    search_docs_tool.as_openai_tool(),
     agent_output_tool.as_openai_tool(),
 ]
 
@@ -41,9 +56,14 @@ async def execute_tool(
 
     tool_map: dict[str, BaseTool] = {
         "add_understanding": add_understanding_tool,
+        "create_agent": create_agent_tool,
+        "edit_agent": edit_agent_tool,
         "find_agent": find_agent_tool,
+        "find_block": find_block_tool,
         "find_library_agent": find_library_agent_tool,
         "run_agent": run_agent_tool,
+        "run_block": run_block_tool,
+        "search_platform_docs": search_docs_tool,
         "agent_output": agent_output_tool,
     }
     if tool_name not in tool_map:

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

@@ -3,7 +3,6 @@ from datetime import UTC, datetime
 from os import getenv
 
 import pytest
-from prisma.types import ProfileCreateInput
 from pydantic import SecretStr
 
 from backend.api.features.chat.model import ChatSession
@@ -50,13 +49,13 @@ async def setup_test_data():
     # 1b. Create a profile with username for the user (required for store agent lookup)
     username = user.email.split("@")[0]
     await prisma.profile.create(
-        data=ProfileCreateInput(
-            userId=user.id,
-            username=username,
-            name=f"Test User {username}",
-            description="Test user profile",
-            links=[],  # Required field - empty array for test profiles
-        )
+        data={
+            "userId": user.id,
+            "username": username,
+            "name": f"Test User {username}",
+            "description": "Test user profile",
+            "links": [],  # Required field - empty array for test profiles
+        }
     )
 
     # 2. Create a test graph with agent input -> agent output
@@ -173,13 +172,13 @@ async def setup_llm_test_data():
     # 1b. Create a profile with username for the user (required for store agent lookup)
     username = user.email.split("@")[0]
     await prisma.profile.create(
-        data=ProfileCreateInput(
-            userId=user.id,
-            username=username,
-            name=f"Test User {username}",
-            description="Test user profile for LLM tests",
-            links=[],  # Required field - empty array for test profiles
-        )
+        data={
+            "userId": user.id,
+            "username": username,
+            "name": f"Test User {username}",
+            "description": "Test user profile for LLM tests",
+            "links": [],  # Required field - empty array for test profiles
+        }
     )
 
     # 2. Create test OpenAI credentials for the user
@@ -333,13 +332,13 @@ async def setup_firecrawl_test_data():
     # 1b. Create a profile with username for the user (required for store agent lookup)
     username = user.email.split("@")[0]
     await prisma.profile.create(
-        data=ProfileCreateInput(
-            userId=user.id,
-            username=username,
-            name=f"Test User {username}",
-            description="Test user profile for Firecrawl tests",
-            links=[],  # Required field - empty array for test profiles
-        )
+        data={
+            "userId": user.id,
+            "username": username,
+            "name": f"Test User {username}",
+            "description": "Test user profile for Firecrawl tests",
+            "links": [],  # Required field - empty array for test profiles
+        }
     )
 
     # NOTE: We deliberately do NOT create Firecrawl credentials for this user

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

@@ -10,7 +10,11 @@ from backend.data.understanding import (
 )
 
 from .base import BaseTool
-from .models import ErrorResponse, ToolResponseBase, UnderstandingUpdatedResponse
+from .models import (
+    ErrorResponse,
+    ToolResponseBase,
+    UnderstandingUpdatedResponse,
+)
 
 logger = logging.getLogger(__name__)
 

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

@@ -0,0 +1,29 @@
+"""Agent generator package - Creates agents from natural language."""
+
+from .core import (
+    apply_agent_patch,
+    decompose_goal,
+    generate_agent,
+    generate_agent_patch,
+    get_agent_as_json,
+    save_agent_to_library,
+)
+from .fixer import apply_all_fixes
+from .utils import get_blocks_info
+from .validator import validate_agent
+
+__all__ = [
+    # Core functions
+    "decompose_goal",
+    "generate_agent",
+    "generate_agent_patch",
+    "apply_agent_patch",
+    "save_agent_to_library",
+    "get_agent_as_json",
+    # Fixer
+    "apply_all_fixes",
+    # Validator
+    "validate_agent",
+    # Utils
+    "get_blocks_info",
+]

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/client.py

@@ -0,0 +1,25 @@
+"""OpenRouter client configuration for agent generation."""
+
+import os
+
+from openai import AsyncOpenAI
+
+# Configuration - use OPEN_ROUTER_API_KEY for consistency with chat/config.py
+OPENROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY") or os.getenv("OPENROUTER_API_KEY")
+AGENT_GENERATOR_MODEL = os.getenv("AGENT_GENERATOR_MODEL", "anthropic/claude-opus-4.5")
+
+# OpenRouter client (OpenAI-compatible API)
+_client: AsyncOpenAI | None = None
+
+
+def get_client() -> AsyncOpenAI:
+    """Get or create the OpenRouter client."""
+    global _client
+    if _client is None:
+        if not OPENROUTER_API_KEY:
+            raise ValueError("OPENROUTER_API_KEY environment variable is required")
+        _client = AsyncOpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=OPENROUTER_API_KEY,
+        )
+    return _client

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/core.py

@@ -0,0 +1,390 @@
+"""Core agent generation functions."""
+
+import copy
+import json
+import logging
+import uuid
+from typing import Any
+
+from backend.api.features.library import db as library_db
+from backend.data.graph import Graph, Link, Node, create_graph
+
+from .client import AGENT_GENERATOR_MODEL, get_client
+from .prompts import DECOMPOSITION_PROMPT, GENERATION_PROMPT, PATCH_PROMPT
+from .utils import get_block_summaries, parse_json_from_llm
+
+logger = logging.getLogger(__name__)
+
+
+async def decompose_goal(description: str, context: str = "") -> dict[str, Any] | None:
+    """Break down a goal into steps or return clarifying questions.
+
+    Args:
+        description: Natural language goal description
+        context: Additional context (e.g., answers to previous questions)
+
+    Returns:
+        Dict with either:
+        - {"type": "clarifying_questions", "questions": [...]}
+        - {"type": "instructions", "steps": [...]}
+        Or None on error
+    """
+    client = get_client()
+    prompt = DECOMPOSITION_PROMPT.format(block_summaries=get_block_summaries())
+
+    full_description = description
+    if context:
+        full_description = f"{description}\n\nAdditional context:\n{context}"
+
+    try:
+        response = await client.chat.completions.create(
+            model=AGENT_GENERATOR_MODEL,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": full_description},
+            ],
+            temperature=0,
+        )
+
+        content = response.choices[0].message.content
+        if content is None:
+            logger.error("LLM returned empty content for decomposition")
+            return None
+
+        result = parse_json_from_llm(content)
+
+        if result is None:
+            logger.error(f"Failed to parse decomposition response: {content[:200]}")
+            return None
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Error decomposing goal: {e}")
+        return None
+
+
+async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
+    """Generate agent JSON from instructions.
+
+    Args:
+        instructions: Structured instructions from decompose_goal
+
+    Returns:
+        Agent JSON dict or None on error
+    """
+    client = get_client()
+    prompt = GENERATION_PROMPT.format(block_summaries=get_block_summaries())
+
+    try:
+        response = await client.chat.completions.create(
+            model=AGENT_GENERATOR_MODEL,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": json.dumps(instructions, indent=2)},
+            ],
+            temperature=0,
+        )
+
+        content = response.choices[0].message.content
+        if content is None:
+            logger.error("LLM returned empty content for agent generation")
+            return None
+
+        result = parse_json_from_llm(content)
+
+        if result is None:
+            logger.error(f"Failed to parse agent JSON: {content[:200]}")
+            return None
+
+        # Ensure required fields
+        if "id" not in result:
+            result["id"] = str(uuid.uuid4())
+        if "version" not in result:
+            result["version"] = 1
+        if "is_active" not in result:
+            result["is_active"] = True
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Error generating agent: {e}")
+        return None
+
+
+def json_to_graph(agent_json: dict[str, Any]) -> Graph:
+    """Convert agent JSON dict to Graph model.
+
+    Args:
+        agent_json: Agent JSON with nodes and links
+
+    Returns:
+        Graph ready for saving
+    """
+    nodes = []
+    for n in agent_json.get("nodes", []):
+        node = Node(
+            id=n.get("id", str(uuid.uuid4())),
+            block_id=n["block_id"],
+            input_default=n.get("input_default", {}),
+            metadata=n.get("metadata", {}),
+        )
+        nodes.append(node)
+
+    links = []
+    for link_data in agent_json.get("links", []):
+        link = Link(
+            id=link_data.get("id", str(uuid.uuid4())),
+            source_id=link_data["source_id"],
+            sink_id=link_data["sink_id"],
+            source_name=link_data["source_name"],
+            sink_name=link_data["sink_name"],
+            is_static=link_data.get("is_static", False),
+        )
+        links.append(link)
+
+    return Graph(
+        id=agent_json.get("id", str(uuid.uuid4())),
+        version=agent_json.get("version", 1),
+        is_active=agent_json.get("is_active", True),
+        name=agent_json.get("name", "Generated Agent"),
+        description=agent_json.get("description", ""),
+        nodes=nodes,
+        links=links,
+    )
+
+
+def _reassign_node_ids(graph: Graph) -> None:
+    """Reassign all node and link IDs to new UUIDs.
+
+    This is needed when creating a new version to avoid unique constraint violations.
+    """
+    # Create mapping from old node IDs to new UUIDs
+    id_map = {node.id: str(uuid.uuid4()) for node in graph.nodes}
+
+    # Reassign node IDs
+    for node in graph.nodes:
+        node.id = id_map[node.id]
+
+    # Update link references to use new node IDs
+    for link in graph.links:
+        link.id = str(uuid.uuid4())  # Also give links new IDs
+        if link.source_id in id_map:
+            link.source_id = id_map[link.source_id]
+        if link.sink_id in id_map:
+            link.sink_id = id_map[link.sink_id]
+
+
+async def save_agent_to_library(
+    agent_json: dict[str, Any], user_id: str, is_update: bool = False
+) -> tuple[Graph, Any]:
+    """Save agent to database and user's library.
+
+    Args:
+        agent_json: Agent JSON dict
+        user_id: User ID
+        is_update: Whether this is an update to an existing agent
+
+    Returns:
+        Tuple of (created Graph, LibraryAgent)
+    """
+    from backend.data.graph import get_graph_all_versions
+
+    graph = json_to_graph(agent_json)
+
+    if is_update:
+        # For updates, keep the same graph ID but increment version
+        # and reassign node/link IDs to avoid conflicts
+        if graph.id:
+            existing_versions = await get_graph_all_versions(graph.id, user_id)
+            if existing_versions:
+                latest_version = max(v.version for v in existing_versions)
+                graph.version = latest_version + 1
+                # Reassign node IDs (but keep graph ID the same)
+                _reassign_node_ids(graph)
+                logger.info(f"Updating agent {graph.id} to version {graph.version}")
+    else:
+        # For new agents, always generate a fresh UUID to avoid collisions
+        graph.id = str(uuid.uuid4())
+        graph.version = 1
+        # Reassign all node IDs as well
+        _reassign_node_ids(graph)
+        logger.info(f"Creating new agent with ID {graph.id}")
+
+    # Save to database
+    created_graph = await create_graph(graph, user_id)
+
+    # Add to user's library (or update existing library agent)
+    library_agents = await library_db.create_library_agent(
+        graph=created_graph,
+        user_id=user_id,
+        create_library_agents_for_sub_graphs=False,
+    )
+
+    return created_graph, library_agents[0]
+
+
+async def get_agent_as_json(
+    graph_id: str, user_id: str | None
+) -> dict[str, Any] | None:
+    """Fetch an agent and convert to JSON format for editing.
+
+    Args:
+        graph_id: Graph ID or library agent ID
+        user_id: User ID
+
+    Returns:
+        Agent as JSON dict or None if not found
+    """
+    from backend.data.graph import get_graph
+
+    # Try to get the graph (version=None gets the active version)
+    graph = await get_graph(graph_id, version=None, user_id=user_id)
+    if not graph:
+        return None
+
+    # Convert to JSON format
+    nodes = []
+    for node in graph.nodes:
+        nodes.append(
+            {
+                "id": node.id,
+                "block_id": node.block_id,
+                "input_default": node.input_default,
+                "metadata": node.metadata,
+            }
+        )
+
+    links = []
+    for node in graph.nodes:
+        for link in node.output_links:
+            links.append(
+                {
+                    "id": link.id,
+                    "source_id": link.source_id,
+                    "sink_id": link.sink_id,
+                    "source_name": link.source_name,
+                    "sink_name": link.sink_name,
+                    "is_static": link.is_static,
+                }
+            )
+
+    return {
+        "id": graph.id,
+        "name": graph.name,
+        "description": graph.description,
+        "version": graph.version,
+        "is_active": graph.is_active,
+        "nodes": nodes,
+        "links": links,
+    }
+
+
+async def generate_agent_patch(
+    update_request: str, current_agent: dict[str, Any]
+) -> dict[str, Any] | None:
+    """Generate a patch to update an existing agent.
+
+    Args:
+        update_request: Natural language description of changes
+        current_agent: Current agent JSON
+
+    Returns:
+        Patch dict or clarifying questions, or None on error
+    """
+    client = get_client()
+    prompt = PATCH_PROMPT.format(
+        current_agent=json.dumps(current_agent, indent=2),
+        block_summaries=get_block_summaries(),
+    )
+
+    try:
+        response = await client.chat.completions.create(
+            model=AGENT_GENERATOR_MODEL,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": update_request},
+            ],
+            temperature=0,
+        )
+
+        content = response.choices[0].message.content
+        if content is None:
+            logger.error("LLM returned empty content for patch generation")
+            return None
+
+        return parse_json_from_llm(content)
+
+    except Exception as e:
+        logger.error(f"Error generating patch: {e}")
+        return None
+
+
+def apply_agent_patch(
+    current_agent: dict[str, Any], patch: dict[str, Any]
+) -> dict[str, Any]:
+    """Apply a patch to an existing agent.
+
+    Args:
+        current_agent: Current agent JSON
+        patch: Patch dict with operations
+
+    Returns:
+        Updated agent JSON
+    """
+    agent = copy.deepcopy(current_agent)
+    patches = patch.get("patches", [])
+
+    for p in patches:
+        patch_type = p.get("type")
+
+        if patch_type == "modify":
+            node_id = p.get("node_id")
+            changes = p.get("changes", {})
+
+            for node in agent.get("nodes", []):
+                if node["id"] == node_id:
+                    _deep_update(node, changes)
+                    logger.debug(f"Modified node {node_id}")
+                    break
+
+        elif patch_type == "add":
+            new_nodes = p.get("new_nodes", [])
+            new_links = p.get("new_links", [])
+
+            agent["nodes"] = agent.get("nodes", []) + new_nodes
+            agent["links"] = agent.get("links", []) + new_links
+            logger.debug(f"Added {len(new_nodes)} nodes, {len(new_links)} links")
+
+        elif patch_type == "remove":
+            node_ids_to_remove = set(p.get("node_ids", []))
+            link_ids_to_remove = set(p.get("link_ids", []))
+
+            # Remove nodes
+            agent["nodes"] = [
+                n for n in agent.get("nodes", []) if n["id"] not in node_ids_to_remove
+            ]
+
+            # Remove links (both explicit and those referencing removed nodes)
+            agent["links"] = [
+                link
+                for link in agent.get("links", [])
+                if link["id"] not in link_ids_to_remove
+                and link["source_id"] not in node_ids_to_remove
+                and link["sink_id"] not in node_ids_to_remove
+            ]
+
+            logger.debug(
+                f"Removed {len(node_ids_to_remove)} nodes, {len(link_ids_to_remove)} links"
+            )
+
+    return agent
+
+
+def _deep_update(target: dict, source: dict) -> None:
+    """Recursively update a dict with another dict."""
+    for key, value in source.items():
+        if key in target and isinstance(target[key], dict) and isinstance(value, dict):
+            _deep_update(target[key], value)
+        else:
+            target[key] = value

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/fixer.py

@@ -0,0 +1,606 @@
+"""Agent fixer - Fixes common LLM generation errors."""
+
+import logging
+import re
+import uuid
+from typing import Any
+
+from .utils import (
+    ADDTODICTIONARY_BLOCK_ID,
+    ADDTOLIST_BLOCK_ID,
+    CODE_EXECUTION_BLOCK_ID,
+    CONDITION_BLOCK_ID,
+    CREATEDICT_BLOCK_ID,
+    CREATELIST_BLOCK_ID,
+    DATA_SAMPLING_BLOCK_ID,
+    DOUBLE_CURLY_BRACES_BLOCK_IDS,
+    GET_CURRENT_DATE_BLOCK_ID,
+    STORE_VALUE_BLOCK_ID,
+    UNIVERSAL_TYPE_CONVERTER_BLOCK_ID,
+    get_blocks_info,
+    is_valid_uuid,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def fix_agent_ids(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix invalid UUIDs in agent and link IDs."""
+    # Fix agent ID
+    if not is_valid_uuid(agent.get("id", "")):
+        agent["id"] = str(uuid.uuid4())
+        logger.debug(f"Fixed agent ID: {agent['id']}")
+
+    # Fix node IDs
+    id_mapping = {}  # Old ID -> New ID
+    for node in agent.get("nodes", []):
+        if not is_valid_uuid(node.get("id", "")):
+            old_id = node.get("id", "")
+            new_id = str(uuid.uuid4())
+            id_mapping[old_id] = new_id
+            node["id"] = new_id
+            logger.debug(f"Fixed node ID: {old_id} -> {new_id}")
+
+    # Fix link IDs and update references
+    for link in agent.get("links", []):
+        if not is_valid_uuid(link.get("id", "")):
+            link["id"] = str(uuid.uuid4())
+            logger.debug(f"Fixed link ID: {link['id']}")
+
+        # Update source/sink IDs if they were remapped
+        if link.get("source_id") in id_mapping:
+            link["source_id"] = id_mapping[link["source_id"]]
+        if link.get("sink_id") in id_mapping:
+            link["sink_id"] = id_mapping[link["sink_id"]]
+
+    return agent
+
+
+def fix_double_curly_braces(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix single curly braces to double in template blocks."""
+    for node in agent.get("nodes", []):
+        if node.get("block_id") not in DOUBLE_CURLY_BRACES_BLOCK_IDS:
+            continue
+
+        input_data = node.get("input_default", {})
+        for key in ("prompt", "format"):
+            if key in input_data and isinstance(input_data[key], str):
+                original = input_data[key]
+                # Fix simple variable references: {var} -> {{var}}
+                fixed = re.sub(
+                    r"(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_]*)\}(?!\})",
+                    r"{{\1}}",
+                    original,
+                )
+                if fixed != original:
+                    input_data[key] = fixed
+                    logger.debug(f"Fixed curly braces in {key}")
+
+    return agent
+
+
+def fix_storevalue_before_condition(agent: dict[str, Any]) -> dict[str, Any]:
+    """Add StoreValueBlock before ConditionBlock if needed for value2."""
+    nodes = agent.get("nodes", [])
+    links = agent.get("links", [])
+
+    # Find all ConditionBlock nodes
+    condition_node_ids = {
+        node["id"] for node in nodes if node.get("block_id") == CONDITION_BLOCK_ID
+    }
+
+    if not condition_node_ids:
+        return agent
+
+    new_nodes = []
+    new_links = []
+    processed_conditions = set()
+
+    for link in links:
+        sink_id = link.get("sink_id")
+        sink_name = link.get("sink_name")
+
+        # Check if this link goes to a ConditionBlock's value2
+        if sink_id in condition_node_ids and sink_name == "value2":
+            source_node = next(
+                (n for n in nodes if n["id"] == link.get("source_id")), None
+            )
+
+            # Skip if source is already a StoreValueBlock
+            if source_node and source_node.get("block_id") == STORE_VALUE_BLOCK_ID:
+                continue
+
+            # Skip if we already processed this condition
+            if sink_id in processed_conditions:
+                continue
+
+            processed_conditions.add(sink_id)
+
+            # Create StoreValueBlock
+            store_node_id = str(uuid.uuid4())
+            store_node = {
+                "id": store_node_id,
+                "block_id": STORE_VALUE_BLOCK_ID,
+                "input_default": {"data": None},
+                "metadata": {"position": {"x": 0, "y": -100}},
+            }
+            new_nodes.append(store_node)
+
+            # Create link: original source -> StoreValueBlock
+            new_links.append(
+                {
+                    "id": str(uuid.uuid4()),
+                    "source_id": link["source_id"],
+                    "source_name": link["source_name"],
+                    "sink_id": store_node_id,
+                    "sink_name": "input",
+                    "is_static": False,
+                }
+            )
+
+            # Update original link: StoreValueBlock -> ConditionBlock
+            link["source_id"] = store_node_id
+            link["source_name"] = "output"
+
+            logger.debug(f"Added StoreValueBlock before ConditionBlock {sink_id}")
+
+    if new_nodes:
+        agent["nodes"] = nodes + new_nodes
+
+    return agent
+
+
+def fix_addtolist_blocks(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix AddToList blocks by adding prerequisite empty AddToList block.
+
+    When an AddToList block is found:
+    1. Checks if there's a CreateListBlock before it
+    2. Removes CreateListBlock if linked directly to AddToList
+    3. Adds an empty AddToList block before the original
+    4. Ensures the original has a self-referencing link
+    """
+    nodes = agent.get("nodes", [])
+    links = agent.get("links", [])
+    new_nodes = []
+    original_addtolist_ids = set()
+    nodes_to_remove = set()
+    links_to_remove = []
+
+    # First pass: identify CreateListBlock nodes to remove
+    for link in links:
+        source_node = next(
+            (n for n in nodes if n.get("id") == link.get("source_id")), None
+        )
+        sink_node = next((n for n in nodes if n.get("id") == link.get("sink_id")), None)
+
+        if (
+            source_node
+            and sink_node
+            and source_node.get("block_id") == CREATELIST_BLOCK_ID
+            and sink_node.get("block_id") == ADDTOLIST_BLOCK_ID
+        ):
+            nodes_to_remove.add(source_node.get("id"))
+            links_to_remove.append(link)
+            logger.debug(f"Removing CreateListBlock {source_node.get('id')}")
+
+    # Second pass: process AddToList blocks
+    filtered_nodes = []
+    for node in nodes:
+        if node.get("id") in nodes_to_remove:
+            continue
+
+        if node.get("block_id") == ADDTOLIST_BLOCK_ID:
+            original_addtolist_ids.add(node.get("id"))
+            node_id = node.get("id")
+            pos = node.get("metadata", {}).get("position", {"x": 0, "y": 0})
+
+            # Check if already has prerequisite
+            has_prereq = any(
+                link.get("sink_id") == node_id
+                and link.get("sink_name") == "list"
+                and link.get("source_name") == "updated_list"
+                for link in links
+            )
+
+            if not has_prereq:
+                # Remove links to "list" input (except self-reference)
+                for link in links:
+                    if (
+                        link.get("sink_id") == node_id
+                        and link.get("sink_name") == "list"
+                        and link.get("source_id") != node_id
+                        and link not in links_to_remove
+                    ):
+                        links_to_remove.append(link)
+
+                # Create prerequisite AddToList block
+                prereq_id = str(uuid.uuid4())
+                prereq_node = {
+                    "id": prereq_id,
+                    "block_id": ADDTOLIST_BLOCK_ID,
+                    "input_default": {"list": [], "entry": None, "entries": []},
+                    "metadata": {
+                        "position": {"x": pos.get("x", 0) - 800, "y": pos.get("y", 0)}
+                    },
+                }
+                new_nodes.append(prereq_node)
+
+                # Link prerequisite to original
+                links.append(
+                    {
+                        "id": str(uuid.uuid4()),
+                        "source_id": prereq_id,
+                        "source_name": "updated_list",
+                        "sink_id": node_id,
+                        "sink_name": "list",
+                        "is_static": False,
+                    }
+                )
+                logger.debug(f"Added prerequisite AddToList block for {node_id}")
+
+        filtered_nodes.append(node)
+
+    # Remove marked links
+    filtered_links = [link for link in links if link not in links_to_remove]
+
+    # Add self-referencing links for original AddToList blocks
+    for node in filtered_nodes + new_nodes:
+        if (
+            node.get("block_id") == ADDTOLIST_BLOCK_ID
+            and node.get("id") in original_addtolist_ids
+        ):
+            node_id = node.get("id")
+            has_self_ref = any(
+                link["source_id"] == node_id
+                and link["sink_id"] == node_id
+                and link["source_name"] == "updated_list"
+                and link["sink_name"] == "list"
+                for link in filtered_links
+            )
+            if not has_self_ref:
+                filtered_links.append(
+                    {
+                        "id": str(uuid.uuid4()),
+                        "source_id": node_id,
+                        "source_name": "updated_list",
+                        "sink_id": node_id,
+                        "sink_name": "list",
+                        "is_static": False,
+                    }
+                )
+                logger.debug(f"Added self-reference for AddToList {node_id}")
+
+    agent["nodes"] = filtered_nodes + new_nodes
+    agent["links"] = filtered_links
+    return agent
+
+
+def fix_addtodictionary_blocks(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix AddToDictionary blocks by removing empty CreateDictionary nodes."""
+    nodes = agent.get("nodes", [])
+    links = agent.get("links", [])
+    nodes_to_remove = set()
+    links_to_remove = []
+
+    for link in links:
+        source_node = next(
+            (n for n in nodes if n.get("id") == link.get("source_id")), None
+        )
+        sink_node = next((n for n in nodes if n.get("id") == link.get("sink_id")), None)
+
+        if (
+            source_node
+            and sink_node
+            and source_node.get("block_id") == CREATEDICT_BLOCK_ID
+            and sink_node.get("block_id") == ADDTODICTIONARY_BLOCK_ID
+        ):
+            nodes_to_remove.add(source_node.get("id"))
+            links_to_remove.append(link)
+            logger.debug(f"Removing CreateDictionary {source_node.get('id')}")
+
+    agent["nodes"] = [n for n in nodes if n.get("id") not in nodes_to_remove]
+    agent["links"] = [link for link in links if link not in links_to_remove]
+    return agent
+
+
+def fix_code_execution_output(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix CodeExecutionBlock output: change 'response' to 'stdout_logs'."""
+    nodes = agent.get("nodes", [])
+    links = agent.get("links", [])
+
+    for link in links:
+        source_node = next(
+            (n for n in nodes if n.get("id") == link.get("source_id")), None
+        )
+        if (
+            source_node
+            and source_node.get("block_id") == CODE_EXECUTION_BLOCK_ID
+            and link.get("source_name") == "response"
+        ):
+            link["source_name"] = "stdout_logs"
+            logger.debug("Fixed CodeExecutionBlock output: response -> stdout_logs")
+
+    return agent
+
+
+def fix_data_sampling_sample_size(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix DataSamplingBlock by setting sample_size to 1 as default."""
+    nodes = agent.get("nodes", [])
+    links = agent.get("links", [])
+    links_to_remove = []
+
+    for node in nodes:
+        if node.get("block_id") == DATA_SAMPLING_BLOCK_ID:
+            node_id = node.get("id")
+            input_default = node.get("input_default", {})
+
+            # Remove links to sample_size
+            for link in links:
+                if (
+                    link.get("sink_id") == node_id
+                    and link.get("sink_name") == "sample_size"
+                ):
+                    links_to_remove.append(link)
+
+            # Set default
+            input_default["sample_size"] = 1
+            node["input_default"] = input_default
+            logger.debug(f"Fixed DataSamplingBlock {node_id} sample_size to 1")
+
+    if links_to_remove:
+        agent["links"] = [link for link in links if link not in links_to_remove]
+
+    return agent
+
+
+def fix_node_x_coordinates(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix node x-coordinates to ensure 800+ unit spacing between linked nodes."""
+    nodes = agent.get("nodes", [])
+    links = agent.get("links", [])
+    node_lookup = {n.get("id"): n for n in nodes}
+
+    for link in links:
+        source_id = link.get("source_id")
+        sink_id = link.get("sink_id")
+
+        source_node = node_lookup.get(source_id)
+        sink_node = node_lookup.get(sink_id)
+
+        if not source_node or not sink_node:
+            continue
+
+        source_pos = source_node.get("metadata", {}).get("position", {})
+        sink_pos = sink_node.get("metadata", {}).get("position", {})
+
+        source_x = source_pos.get("x", 0)
+        sink_x = sink_pos.get("x", 0)
+
+        if abs(sink_x - source_x) < 800:
+            new_x = source_x + 800
+            if "metadata" not in sink_node:
+                sink_node["metadata"] = {}
+            if "position" not in sink_node["metadata"]:
+                sink_node["metadata"]["position"] = {}
+            sink_node["metadata"]["position"]["x"] = new_x
+            logger.debug(f"Fixed node {sink_id} x: {sink_x} -> {new_x}")
+
+    return agent
+
+
+def fix_getcurrentdate_offset(agent: dict[str, Any]) -> dict[str, Any]:
+    """Fix GetCurrentDateBlock offset to ensure it's positive."""
+    for node in agent.get("nodes", []):
+        if node.get("block_id") == GET_CURRENT_DATE_BLOCK_ID:
+            input_default = node.get("input_default", {})
+            if "offset" in input_default:
+                offset = input_default["offset"]
+                if isinstance(offset, (int, float)) and offset < 0:
+                    input_default["offset"] = abs(offset)
+                    logger.debug(f"Fixed offset: {offset} -> {abs(offset)}")
+
+    return agent
+
+
+def fix_ai_model_parameter(
+    agent: dict[str, Any],
+    blocks_info: list[dict[str, Any]],
+    default_model: str = "gpt-4o",
+) -> dict[str, Any]:
+    """Add default model parameter to AI blocks if missing."""
+    block_map = {b.get("id"): b for b in blocks_info}
+
+    for node in agent.get("nodes", []):
+        block_id = node.get("block_id")
+        block = block_map.get(block_id)
+
+        if not block:
+            continue
+
+        # Check if block has AI category
+        categories = block.get("categories", [])
+        is_ai_block = any(
+            cat.get("category") == "AI" for cat in categories if isinstance(cat, dict)
+        )
+
+        if is_ai_block:
+            input_default = node.get("input_default", {})
+            if "model" not in input_default:
+                input_default["model"] = default_model
+                node["input_default"] = input_default
+                logger.debug(
+                    f"Added model '{default_model}' to AI block {node.get('id')}"
+                )
+
+    return agent
+
+
+def fix_link_static_properties(
+    agent: dict[str, Any], blocks_info: list[dict[str, Any]]
+) -> dict[str, Any]:
+    """Fix is_static property based on source block's staticOutput."""
+    block_map = {b.get("id"): b for b in blocks_info}
+    node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
+
+    for link in agent.get("links", []):
+        source_node = node_lookup.get(link.get("source_id"))
+        if not source_node:
+            continue
+
+        source_block = block_map.get(source_node.get("block_id"))
+        if not source_block:
+            continue
+
+        static_output = source_block.get("staticOutput", False)
+        if link.get("is_static") != static_output:
+            link["is_static"] = static_output
+            logger.debug(f"Fixed link {link.get('id')} is_static to {static_output}")
+
+    return agent
+
+
+def fix_data_type_mismatch(
+    agent: dict[str, Any], blocks_info: list[dict[str, Any]]
+) -> dict[str, Any]:
+    """Fix data type mismatches by inserting UniversalTypeConverterBlock."""
+    nodes = agent.get("nodes", [])
+    links = agent.get("links", [])
+    block_map = {b.get("id"): b for b in blocks_info}
+    node_lookup = {n.get("id"): n for n in nodes}
+
+    def get_property_type(schema: dict, name: str) -> str | None:
+        if "_#_" in name:
+            parent, child = name.split("_#_", 1)
+            parent_schema = schema.get(parent, {})
+            if "properties" in parent_schema:
+                return parent_schema["properties"].get(child, {}).get("type")
+            return None
+        return schema.get(name, {}).get("type")
+
+    def are_types_compatible(src: str, sink: str) -> bool:
+        if {src, sink} <= {"integer", "number"}:
+            return True
+        return src == sink
+
+    type_mapping = {
+        "string": "string",
+        "text": "string",
+        "integer": "number",
+        "number": "number",
+        "float": "number",
+        "boolean": "boolean",
+        "bool": "boolean",
+        "array": "list",
+        "list": "list",
+        "object": "dictionary",
+        "dict": "dictionary",
+        "dictionary": "dictionary",
+    }
+
+    new_links = []
+    nodes_to_add = []
+
+    for link in links:
+        source_node = node_lookup.get(link.get("source_id"))
+        sink_node = node_lookup.get(link.get("sink_id"))
+
+        if not source_node or not sink_node:
+            new_links.append(link)
+            continue
+
+        source_block = block_map.get(source_node.get("block_id"))
+        sink_block = block_map.get(sink_node.get("block_id"))
+
+        if not source_block or not sink_block:
+            new_links.append(link)
+            continue
+
+        source_outputs = source_block.get("outputSchema", {}).get("properties", {})
+        sink_inputs = sink_block.get("inputSchema", {}).get("properties", {})
+
+        source_type = get_property_type(source_outputs, link.get("source_name", ""))
+        sink_type = get_property_type(sink_inputs, link.get("sink_name", ""))
+
+        if (
+            source_type
+            and sink_type
+            and not are_types_compatible(source_type, sink_type)
+        ):
+            # Insert type converter
+            converter_id = str(uuid.uuid4())
+            target_type = type_mapping.get(sink_type, sink_type)
+
+            converter_node = {
+                "id": converter_id,
+                "block_id": UNIVERSAL_TYPE_CONVERTER_BLOCK_ID,
+                "input_default": {"type": target_type},
+                "metadata": {"position": {"x": 0, "y": 100}},
+            }
+            nodes_to_add.append(converter_node)
+
+            # source -> converter
+            new_links.append(
+                {
+                    "id": str(uuid.uuid4()),
+                    "source_id": link["source_id"],
+                    "source_name": link["source_name"],
+                    "sink_id": converter_id,
+                    "sink_name": "value",
+                    "is_static": False,
+                }
+            )
+
+            # converter -> sink
+            new_links.append(
+                {
+                    "id": str(uuid.uuid4()),
+                    "source_id": converter_id,
+                    "source_name": "value",
+                    "sink_id": link["sink_id"],
+                    "sink_name": link["sink_name"],
+                    "is_static": False,
+                }
+            )
+
+            logger.debug(f"Inserted type converter: {source_type} -> {target_type}")
+        else:
+            new_links.append(link)
+
+    if nodes_to_add:
+        agent["nodes"] = nodes + nodes_to_add
+        agent["links"] = new_links
+
+    return agent
+
+
+def apply_all_fixes(
+    agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
+) -> dict[str, Any]:
+    """Apply all fixes to an agent JSON.
+
+    Args:
+        agent: Agent JSON dict
+        blocks_info: Optional list of block info dicts for advanced fixes
+
+    Returns:
+        Fixed agent JSON
+    """
+    # Basic fixes (no block info needed)
+    agent = fix_agent_ids(agent)
+    agent = fix_double_curly_braces(agent)
+    agent = fix_storevalue_before_condition(agent)
+    agent = fix_addtolist_blocks(agent)
+    agent = fix_addtodictionary_blocks(agent)
+    agent = fix_code_execution_output(agent)
+    agent = fix_data_sampling_sample_size(agent)
+    agent = fix_node_x_coordinates(agent)
+    agent = fix_getcurrentdate_offset(agent)
+
+    # Advanced fixes (require block info)
+    if blocks_info is None:
+        blocks_info = get_blocks_info()
+
+    agent = fix_ai_model_parameter(agent, blocks_info)
+    agent = fix_link_static_properties(agent, blocks_info)
+    agent = fix_data_type_mismatch(agent, blocks_info)
+
+    return agent

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/prompts.py

@@ -0,0 +1,225 @@
+"""Prompt templates for agent generation."""
+
+DECOMPOSITION_PROMPT = """
+You are an expert AutoGPT Workflow Decomposer. Your task is to analyze a user's high-level goal and break it down into a clear, step-by-step plan using the available blocks.
+
+Each step should represent a distinct, automatable action suitable for execution by an AI automation system.
+
+---
+
+FIRST: Analyze the user's goal and determine:
+1) Design-time configuration (fixed settings that won't change per run)
+2) Runtime inputs (values the agent's end-user will provide each time it runs)
+
+For anything that can vary per run (email addresses, names, dates, search terms, etc.):
+- DO NOT ask for the actual value
+- Instead, define it as an Agent Input with a clear name, type, and description
+
+Only ask clarifying questions about design-time config that affects how you build the workflow:
+- Which external service to use (e.g., "Gmail vs Outlook", "Notion vs Google Docs")
+- Required formats or structures (e.g., "CSV, JSON, or PDF output?")
+- Business rules that must be hard-coded
+
+IMPORTANT CLARIFICATIONS POLICY:
+- Ask no more than five essential questions
+- Do not ask for concrete values that can be provided at runtime as Agent Inputs
+- Do not ask for API keys or credentials; the platform handles those directly
+- If there is enough information to infer reasonable defaults, prefer to propose defaults
+
+---
+
+GUIDELINES:
+1. List each step as a numbered item
+2. Describe the action clearly and specify inputs/outputs
+3. Ensure steps are in logical, sequential order
+4. Mention block names naturally (e.g., "Use GetWeatherByLocationBlock to...")
+5. Help the user reach their goal efficiently
+
+---
+
+RULES:
+1. OUTPUT FORMAT: Only output either clarifying questions OR step-by-step instructions, not both
+2. USE ONLY THE BLOCKS PROVIDED
+3. ALL required_input fields must be provided
+4. Data types of linked properties must match
+5. Write expert-level prompts for AI-related blocks
+
+---
+
+CRITICAL BLOCK RESTRICTIONS:
+1. AddToListBlock: Outputs updated list EVERY addition, not after all additions
+2. SendEmailBlock: Draft the email for user review; set SMTP config based on email type
+3. ConditionBlock: value2 is reference, value1 is contrast
+4. CodeExecutionBlock: DO NOT USE - use AI blocks instead
+5. ReadCsvBlock: Only use the 'rows' output, not 'row'
+
+---
+
+OUTPUT FORMAT:
+
+If more information is needed:
+```json
+{{
+  "type": "clarifying_questions",
+  "questions": [
+    {{
+      "question": "Which email provider should be used? (Gmail, Outlook, custom SMTP)",
+      "keyword": "email_provider",
+      "example": "Gmail"
+    }}
+  ]
+}}
+```
+
+If ready to proceed:
+```json
+{{
+  "type": "instructions",
+  "steps": [
+    {{
+      "step_number": 1,
+      "block_name": "AgentShortTextInputBlock",
+      "description": "Get the URL of the content to analyze.",
+      "inputs": [{{"name": "name", "value": "URL"}}],
+      "outputs": [{{"name": "result", "description": "The URL entered by user"}}]
+    }}
+  ]
+}}
+```
+
+---
+
+AVAILABLE BLOCKS:
+{block_summaries}
+"""
+
+GENERATION_PROMPT = """
+You are an expert AI workflow builder. Generate a valid agent JSON from the given instructions.
+
+---
+
+NODES:
+Each node must include:
+- `id`: Unique UUID v4 (e.g. `a8f5b1e2-c3d4-4e5f-8a9b-0c1d2e3f4a5b`)
+- `block_id`: The block identifier (must match an Allowed Block)
+- `input_default`: Dict of inputs (can be empty if no static inputs needed)
+- `metadata`: Must contain:
+  - `position`: {{"x": number, "y": number}} - adjacent nodes should differ by 800+ in X
+  - `customized_name`: Clear name describing this block's purpose in the workflow
+
+---
+
+LINKS:
+Each link connects a source node's output to a sink node's input:
+- `id`: MUST be UUID v4 (NOT "link-1", "link-2", etc.)
+- `source_id`: ID of the source node
+- `source_name`: Output field name from the source block
+- `sink_id`: ID of the sink node
+- `sink_name`: Input field name on the sink block
+- `is_static`: true only if source block has static_output: true
+
+CRITICAL: All IDs must be valid UUID v4 format!
+
+---
+
+AGENT (GRAPH):
+Wrap nodes and links in:
+- `id`: UUID of the agent
+- `name`: Short, generic name (avoid specific company names, URLs)
+- `description`: Short, generic description
+- `nodes`: List of all nodes
+- `links`: List of all links
+- `version`: 1
+- `is_active`: true
+
+---
+
+TIPS:
+- All required_input fields must be provided via input_default or a valid link
+- Ensure consistent source_id and sink_id references
+- Avoid dangling links
+- Input/output pins must match block schemas
+- Do not invent unknown block_ids
+
+---
+
+ALLOWED BLOCKS:
+{block_summaries}
+
+---
+
+Generate the complete agent JSON. Output ONLY valid JSON, no explanation.
+"""
+
+PATCH_PROMPT = """
+You are an expert at modifying AutoGPT agent workflows. Given the current agent and a modification request, generate a JSON patch to update the agent.
+
+CURRENT AGENT:
+{current_agent}
+
+AVAILABLE BLOCKS:
+{block_summaries}
+
+---
+
+PATCH FORMAT:
+Return a JSON object with the following structure:
+
+```json
+{{
+  "type": "patch",
+  "intent": "Brief description of what the patch does",
+  "patches": [
+    {{
+      "type": "modify",
+      "node_id": "uuid-of-node-to-modify",
+      "changes": {{
+        "input_default": {{"field": "new_value"}},
+        "metadata": {{"customized_name": "New Name"}}
+      }}
+    }},
+    {{
+      "type": "add",
+      "new_nodes": [
+        {{
+          "id": "new-uuid",
+          "block_id": "block-uuid",
+          "input_default": {{}},
+          "metadata": {{"position": {{"x": 0, "y": 0}}, "customized_name": "Name"}}
+        }}
+      ],
+      "new_links": [
+        {{
+          "id": "link-uuid",
+          "source_id": "source-node-id",
+          "source_name": "output_field",
+          "sink_id": "sink-node-id",
+          "sink_name": "input_field"
+        }}
+      ]
+    }},
+    {{
+      "type": "remove",
+      "node_ids": ["uuid-of-node-to-remove"],
+      "link_ids": ["uuid-of-link-to-remove"]
+    }}
+  ]
+}}
+```
+
+If you need more information, return:
+```json
+{{
+  "type": "clarifying_questions",
+  "questions": [
+    {{
+      "question": "What specific change do you want?",
+      "keyword": "change_type",
+      "example": "Add error handling"
+    }}
+  ]
+}}
+```
+
+Generate the minimal patch needed. Output ONLY valid JSON.
+"""

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/utils.py

@@ -0,0 +1,213 @@
+"""Utilities for agent generation."""
+
+import json
+import re
+from typing import Any
+
+from backend.data.block import get_blocks
+
+# UUID validation regex
+UUID_REGEX = re.compile(
+    r"^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$"
+)
+
+# Block IDs for various fixes
+STORE_VALUE_BLOCK_ID = "1ff065e9-88e8-4358-9d82-8dc91f622ba9"
+CONDITION_BLOCK_ID = "715696a0-e1da-45c8-b209-c2fa9c3b0be6"
+ADDTOLIST_BLOCK_ID = "aeb08fc1-2fc1-4141-bc8e-f758f183a822"
+ADDTODICTIONARY_BLOCK_ID = "31d1064e-7446-4693-a7d4-65e5ca1180d1"
+CREATELIST_BLOCK_ID = "a912d5c7-6e00-4542-b2a9-8034136930e4"
+CREATEDICT_BLOCK_ID = "b924ddf4-de4f-4b56-9a85-358930dcbc91"
+CODE_EXECUTION_BLOCK_ID = "0b02b072-abe7-11ef-8372-fb5d162dd712"
+DATA_SAMPLING_BLOCK_ID = "4a448883-71fa-49cf-91cf-70d793bd7d87"
+UNIVERSAL_TYPE_CONVERTER_BLOCK_ID = "95d1b990-ce13-4d88-9737-ba5c2070c97b"
+GET_CURRENT_DATE_BLOCK_ID = "b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1"
+
+DOUBLE_CURLY_BRACES_BLOCK_IDS = [
+    "44f6c8ad-d75c-4ae1-8209-aad1c0326928",  # FillTextTemplateBlock
+    "6ab085e2-20b3-4055-bc3e-08036e01eca6",
+    "90f8c45e-e983-4644-aa0b-b4ebe2f531bc",
+    "363ae599-353e-4804-937e-b2ee3cef3da4",  # AgentOutputBlock
+    "3b191d9f-356f-482d-8238-ba04b6d18381",
+    "db7d8f02-2f44-4c55-ab7a-eae0941f0c30",
+    "3a7c4b8d-6e2f-4a5d-b9c1-f8d23c5a9b0e",
+    "ed1ae7a0-b770-4089-b520-1f0005fad19a",
+    "a892b8d9-3e4e-4e9c-9c1e-75f8efcf1bfa",
+    "b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1",
+    "716a67b3-6760-42e7-86dc-18645c6e00fc",
+    "530cf046-2ce0-4854-ae2c-659db17c7a46",
+    "ed55ac19-356e-4243-a6cb-bc599e9b716f",
+    "1f292d4a-41a4-4977-9684-7c8d560b9f91",  # LLM blocks
+    "32a87eab-381e-4dd4-bdb8-4c47151be35a",
+]
+
+
+def is_valid_uuid(value: str) -> bool:
+    """Check if a string is a valid UUID v4."""
+    return isinstance(value, str) and UUID_REGEX.match(value) is not None
+
+
+def _compact_schema(schema: dict) -> dict[str, str]:
+    """Extract compact type info from a JSON schema properties dict.
+
+    Returns a dict of {field_name: type_string} for essential info only.
+    """
+    props = schema.get("properties", {})
+    result = {}
+
+    for name, prop in props.items():
+        # Skip internal/complex fields
+        if name.startswith("_"):
+            continue
+
+        # Get type string
+        type_str = prop.get("type", "any")
+
+        # Handle anyOf/oneOf (optional types)
+        if "anyOf" in prop:
+            types = [t.get("type", "?") for t in prop["anyOf"] if t.get("type")]
+            type_str = "|".join(types) if types else "any"
+        elif "allOf" in prop:
+            type_str = "object"
+
+        # Add array item type if present
+        if type_str == "array" and "items" in prop:
+            items = prop["items"]
+            if isinstance(items, dict):
+                item_type = items.get("type", "any")
+                type_str = f"array[{item_type}]"
+
+        result[name] = type_str
+
+    return result
+
+
+def get_block_summaries(include_schemas: bool = True) -> str:
+    """Generate compact block summaries for prompts.
+
+    Args:
+        include_schemas: Whether to include input/output type info
+
+    Returns:
+        Formatted string of block summaries (compact format)
+    """
+    blocks = get_blocks()
+    summaries = []
+
+    for block_id, block_cls in blocks.items():
+        block = block_cls()
+        name = block.name
+        desc = getattr(block, "description", "") or ""
+
+        # Truncate description
+        if len(desc) > 150:
+            desc = desc[:147] + "..."
+
+        if not include_schemas:
+            summaries.append(f"- {name} (id: {block_id}): {desc}")
+        else:
+            # Compact format with type info only
+            inputs = {}
+            outputs = {}
+            required = []
+
+            if hasattr(block, "input_schema"):
+                try:
+                    schema = block.input_schema.jsonschema()
+                    inputs = _compact_schema(schema)
+                    required = schema.get("required", [])
+                except Exception:
+                    pass
+
+            if hasattr(block, "output_schema"):
+                try:
+                    schema = block.output_schema.jsonschema()
+                    outputs = _compact_schema(schema)
+                except Exception:
+                    pass
+
+            # Build compact line format
+            # Format: NAME (id): desc | in: {field:type, ...} [required] | out: {field:type}
+            in_str = ", ".join(f"{k}:{v}" for k, v in inputs.items())
+            out_str = ", ".join(f"{k}:{v}" for k, v in outputs.items())
+            req_str = f" req=[{','.join(required)}]" if required else ""
+
+            static = " [static]" if getattr(block, "static_output", False) else ""
+
+            line = f"- {name} (id: {block_id}): {desc}"
+            if in_str:
+                line += f"\n  in: {{{in_str}}}{req_str}"
+            if out_str:
+                line += f"\n  out: {{{out_str}}}{static}"
+
+            summaries.append(line)
+
+    return "\n".join(summaries)
+
+
+def get_blocks_info() -> list[dict[str, Any]]:
+    """Get block information with schemas for validation and fixing."""
+    blocks = get_blocks()
+    blocks_info = []
+    for block_id, block_cls in blocks.items():
+        block = block_cls()
+        blocks_info.append(
+            {
+                "id": block_id,
+                "name": block.name,
+                "description": getattr(block, "description", ""),
+                "categories": getattr(block, "categories", []),
+                "staticOutput": getattr(block, "static_output", False),
+                "inputSchema": (
+                    block.input_schema.jsonschema()
+                    if hasattr(block, "input_schema")
+                    else {}
+                ),
+                "outputSchema": (
+                    block.output_schema.jsonschema()
+                    if hasattr(block, "output_schema")
+                    else {}
+                ),
+            }
+        )
+    return blocks_info
+
+
+def parse_json_from_llm(text: str) -> dict[str, Any] | None:
+    """Extract JSON from LLM response (handles markdown code blocks)."""
+    if not text:
+        return None
+
+    # Try fenced code block
+    match = re.search(r"```(?:json)?\s*([\s\S]*?)```", text, re.IGNORECASE)
+    if match:
+        try:
+            return json.loads(match.group(1).strip())
+        except json.JSONDecodeError:
+            pass
+
+    # Try raw text
+    try:
+        return json.loads(text.strip())
+    except json.JSONDecodeError:
+        pass
+
+    # Try finding {...} span
+    start = text.find("{")
+    end = text.rfind("}")
+    if start != -1 and end > start:
+        try:
+            return json.loads(text[start : end + 1])
+        except json.JSONDecodeError:
+            pass
+
+    # Try finding [...] span
+    start = text.find("[")
+    end = text.rfind("]")
+    if start != -1 and end > start:
+        try:
+            return json.loads(text[start : end + 1])
+        except json.JSONDecodeError:
+            pass
+
+    return None

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/validator.py

@@ -0,0 +1,279 @@
+"""Agent validator - Validates agent structure and connections."""
+
+import logging
+import re
+from typing import Any
+
+from .utils import get_blocks_info
+
+logger = logging.getLogger(__name__)
+
+
+class AgentValidator:
+    """Validator for AutoGPT agents with detailed error reporting."""
+
+    def __init__(self):
+        self.errors: list[str] = []
+
+    def add_error(self, error: str) -> None:
+        """Add an error message."""
+        self.errors.append(error)
+
+    def validate_block_existence(
+        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
+    ) -> bool:
+        """Validate all block IDs exist in the blocks library."""
+        valid = True
+        valid_block_ids = {b.get("id") for b in blocks_info if b.get("id")}
+
+        for node in agent.get("nodes", []):
+            block_id = node.get("block_id")
+            node_id = node.get("id")
+
+            if not block_id:
+                self.add_error(f"Node '{node_id}' is missing 'block_id' field.")
+                valid = False
+                continue
+
+            if block_id not in valid_block_ids:
+                self.add_error(
+                    f"Node '{node_id}' references block_id '{block_id}' which does not exist."
+                )
+                valid = False
+
+        return valid
+
+    def validate_link_node_references(self, agent: dict[str, Any]) -> bool:
+        """Validate all node IDs referenced in links exist."""
+        valid = True
+        valid_node_ids = {n.get("id") for n in agent.get("nodes", []) if n.get("id")}
+
+        for link in agent.get("links", []):
+            link_id = link.get("id", "Unknown")
+            source_id = link.get("source_id")
+            sink_id = link.get("sink_id")
+
+            if not source_id:
+                self.add_error(f"Link '{link_id}' is missing 'source_id'.")
+                valid = False
+            elif source_id not in valid_node_ids:
+                self.add_error(
+                    f"Link '{link_id}' references non-existent source_id '{source_id}'."
+                )
+                valid = False
+
+            if not sink_id:
+                self.add_error(f"Link '{link_id}' is missing 'sink_id'.")
+                valid = False
+            elif sink_id not in valid_node_ids:
+                self.add_error(
+                    f"Link '{link_id}' references non-existent sink_id '{sink_id}'."
+                )
+                valid = False
+
+        return valid
+
+    def validate_required_inputs(
+        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
+    ) -> bool:
+        """Validate required inputs are provided."""
+        valid = True
+        block_map = {b.get("id"): b for b in blocks_info}
+
+        for node in agent.get("nodes", []):
+            block_id = node.get("block_id")
+            block = block_map.get(block_id)
+
+            if not block:
+                continue
+
+            required_inputs = block.get("inputSchema", {}).get("required", [])
+            input_defaults = node.get("input_default", {})
+            node_id = node.get("id")
+
+            # Get linked inputs
+            linked_inputs = {
+                link["sink_name"]
+                for link in agent.get("links", [])
+                if link.get("sink_id") == node_id
+            }
+
+            for req_input in required_inputs:
+                if (
+                    req_input not in input_defaults
+                    and req_input not in linked_inputs
+                    and req_input != "credentials"
+                ):
+                    block_name = block.get("name", "Unknown Block")
+                    self.add_error(
+                        f"Node '{node_id}' ({block_name}) is missing required input '{req_input}'."
+                    )
+                    valid = False
+
+        return valid
+
+    def validate_data_type_compatibility(
+        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
+    ) -> bool:
+        """Validate linked data types are compatible."""
+        valid = True
+        block_map = {b.get("id"): b for b in blocks_info}
+        node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
+
+        def get_type(schema: dict, name: str) -> str | None:
+            if "_#_" in name:
+                parent, child = name.split("_#_", 1)
+                parent_schema = schema.get(parent, {})
+                if "properties" in parent_schema:
+                    return parent_schema["properties"].get(child, {}).get("type")
+                return None
+            return schema.get(name, {}).get("type")
+
+        def are_compatible(src: str, sink: str) -> bool:
+            if {src, sink} <= {"integer", "number"}:
+                return True
+            return src == sink
+
+        for link in agent.get("links", []):
+            source_node = node_lookup.get(link.get("source_id"))
+            sink_node = node_lookup.get(link.get("sink_id"))
+
+            if not source_node or not sink_node:
+                continue
+
+            source_block = block_map.get(source_node.get("block_id"))
+            sink_block = block_map.get(sink_node.get("block_id"))
+
+            if not source_block or not sink_block:
+                continue
+
+            source_outputs = source_block.get("outputSchema", {}).get("properties", {})
+            sink_inputs = sink_block.get("inputSchema", {}).get("properties", {})
+
+            source_type = get_type(source_outputs, link.get("source_name", ""))
+            sink_type = get_type(sink_inputs, link.get("sink_name", ""))
+
+            if source_type and sink_type and not are_compatible(source_type, sink_type):
+                self.add_error(
+                    f"Type mismatch: {source_block.get('name')} output '{link['source_name']}' "
+                    f"({source_type}) -> {sink_block.get('name')} input '{link['sink_name']}' ({sink_type})."
+                )
+                valid = False
+
+        return valid
+
+    def validate_nested_sink_links(
+        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
+    ) -> bool:
+        """Validate nested sink links (with _#_ notation)."""
+        valid = True
+        block_map = {b.get("id"): b for b in blocks_info}
+        node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
+
+        for link in agent.get("links", []):
+            sink_name = link.get("sink_name", "")
+
+            if "_#_" in sink_name:
+                parent, child = sink_name.split("_#_", 1)
+
+                sink_node = node_lookup.get(link.get("sink_id"))
+                if not sink_node:
+                    continue
+
+                block = block_map.get(sink_node.get("block_id"))
+                if not block:
+                    continue
+
+                input_props = block.get("inputSchema", {}).get("properties", {})
+                parent_schema = input_props.get(parent)
+
+                if not parent_schema:
+                    self.add_error(
+                        f"Invalid nested link '{sink_name}': parent '{parent}' not found."
+                    )
+                    valid = False
+                    continue
+
+                if not parent_schema.get("additionalProperties"):
+                    if not (
+                        isinstance(parent_schema, dict)
+                        and "properties" in parent_schema
+                        and child in parent_schema.get("properties", {})
+                    ):
+                        self.add_error(
+                            f"Invalid nested link '{sink_name}': child '{child}' not found in '{parent}'."
+                        )
+                        valid = False
+
+        return valid
+
+    def validate_prompt_spaces(self, agent: dict[str, Any]) -> bool:
+        """Validate prompts don't have spaces in template variables."""
+        valid = True
+
+        for node in agent.get("nodes", []):
+            input_default = node.get("input_default", {})
+            prompt = input_default.get("prompt", "")
+
+            if not isinstance(prompt, str):
+                continue
+
+            # Find {{...}} with spaces
+            matches = re.finditer(r"\{\{([^}]+)\}\}", prompt)
+            for match in matches:
+                content = match.group(1)
+                if " " in content:
+                    self.add_error(
+                        f"Node '{node.get('id')}' has spaces in template variable: "
+                        f"'{{{{{content}}}}}' should be '{{{{{content.replace(' ', '_')}}}}}'."
+                    )
+                    valid = False
+
+        return valid
+
+    def validate(
+        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
+    ) -> tuple[bool, str | None]:
+        """Run all validations.
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        self.errors = []
+
+        if blocks_info is None:
+            blocks_info = get_blocks_info()
+
+        checks = [
+            self.validate_block_existence(agent, blocks_info),
+            self.validate_link_node_references(agent),
+            self.validate_required_inputs(agent, blocks_info),
+            self.validate_data_type_compatibility(agent, blocks_info),
+            self.validate_nested_sink_links(agent, blocks_info),
+            self.validate_prompt_spaces(agent),
+        ]
+
+        all_passed = all(checks)
+
+        if all_passed:
+            logger.info("Agent validation successful")
+            return True, None
+
+        error_message = "Agent validation failed:\n"
+        for i, error in enumerate(self.errors, 1):
+            error_message += f"{i}. {error}\n"
+
+        logger.warning(f"Agent validation failed with {len(self.errors)} errors")
+        return False, error_message
+
+
+def validate_agent(
+    agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
+) -> tuple[bool, str | None]:
+    """Convenience function to validate an agent.
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    validator = AgentValidator()
+    return validator.validate(agent, blocks_info)

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

@@ -0,0 +1,279 @@
+"""CreateAgentTool - Creates agents from natural language descriptions."""
+
+import logging
+from typing import Any
+
+from backend.api.features.chat.model import ChatSession
+
+from .agent_generator import (
+    apply_all_fixes,
+    decompose_goal,
+    generate_agent,
+    get_blocks_info,
+    save_agent_to_library,
+    validate_agent,
+)
+from .base import BaseTool
+from .models import (
+    AgentPreviewResponse,
+    AgentSavedResponse,
+    ClarificationNeededResponse,
+    ClarifyingQuestion,
+    ErrorResponse,
+    ToolResponseBase,
+)
+
+logger = logging.getLogger(__name__)
+
+# Maximum retries for agent generation with validation feedback
+MAX_GENERATION_RETRIES = 2
+
+
+class CreateAgentTool(BaseTool):
+    """Tool for creating agents from natural language descriptions."""
+
+    @property
+    def name(self) -> str:
+        return "create_agent"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Create a new agent workflow from a natural language description. "
+            "First generates a preview, then saves to library if save=true."
+        )
+
+    @property
+    def requires_auth(self) -> bool:
+        return True
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "description": {
+                    "type": "string",
+                    "description": (
+                        "Natural language description of what the agent should do. "
+                        "Be specific about inputs, outputs, and the workflow steps."
+                    ),
+                },
+                "context": {
+                    "type": "string",
+                    "description": (
+                        "Additional context or answers to previous clarifying questions. "
+                        "Include any preferences or constraints mentioned by the user."
+                    ),
+                },
+                "save": {
+                    "type": "boolean",
+                    "description": (
+                        "Whether to save the agent to the user's library. "
+                        "Default is true. Set to false for preview only."
+                    ),
+                    "default": True,
+                },
+            },
+            "required": ["description"],
+        }
+
+    async def _execute(
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        **kwargs,
+    ) -> ToolResponseBase:
+        """Execute the create_agent tool.
+
+        Flow:
+        1. Decompose the description into steps (may return clarifying questions)
+        2. Generate agent JSON from the steps
+        3. Apply fixes to correct common LLM errors
+        4. Preview or save based on the save parameter
+        """
+        description = kwargs.get("description", "").strip()
+        context = kwargs.get("context", "")
+        save = kwargs.get("save", True)
+        session_id = session.session_id if session else None
+
+        if not description:
+            return ErrorResponse(
+                message="Please provide a description of what the agent should do.",
+                error="Missing description parameter",
+                session_id=session_id,
+            )
+
+        # Step 1: Decompose goal into steps
+        try:
+            decomposition_result = await decompose_goal(description, context)
+        except ValueError as e:
+            # Handle missing API key or configuration errors
+            return ErrorResponse(
+                message=f"Agent generation is not configured: {str(e)}",
+                error="configuration_error",
+                session_id=session_id,
+            )
+
+        if decomposition_result is None:
+            return ErrorResponse(
+                message="Failed to analyze the goal. Please try rephrasing.",
+                error="Decomposition failed",
+                session_id=session_id,
+            )
+
+        # Check if LLM returned clarifying questions
+        if decomposition_result.get("type") == "clarifying_questions":
+            questions = decomposition_result.get("questions", [])
+            return ClarificationNeededResponse(
+                message=(
+                    "I need some more information to create this agent. "
+                    "Please answer the following questions:"
+                ),
+                questions=[
+                    ClarifyingQuestion(
+                        question=q.get("question", ""),
+                        keyword=q.get("keyword", ""),
+                        example=q.get("example"),
+                    )
+                    for q in questions
+                ],
+                session_id=session_id,
+            )
+
+        # Check for unachievable/vague goals
+        if decomposition_result.get("type") == "unachievable_goal":
+            suggested = decomposition_result.get("suggested_goal", "")
+            reason = decomposition_result.get("reason", "")
+            return ErrorResponse(
+                message=(
+                    f"This goal cannot be accomplished with the available blocks. "
+                    f"{reason} "
+                    f"Suggestion: {suggested}"
+                ),
+                error="unachievable_goal",
+                details={"suggested_goal": suggested, "reason": reason},
+                session_id=session_id,
+            )
+
+        if decomposition_result.get("type") == "vague_goal":
+            suggested = decomposition_result.get("suggested_goal", "")
+            return ErrorResponse(
+                message=(
+                    f"The goal is too vague to create a specific workflow. "
+                    f"Suggestion: {suggested}"
+                ),
+                error="vague_goal",
+                details={"suggested_goal": suggested},
+                session_id=session_id,
+            )
+
+        # Step 2: Generate agent JSON with retry on validation failure
+        blocks_info = get_blocks_info()
+        agent_json = None
+        validation_errors = None
+
+        for attempt in range(MAX_GENERATION_RETRIES + 1):
+            # Generate agent (include validation errors from previous attempt)
+            if attempt == 0:
+                agent_json = await generate_agent(decomposition_result)
+            else:
+                # Retry with validation error feedback
+                logger.info(
+                    f"Retry {attempt}/{MAX_GENERATION_RETRIES} with validation feedback"
+                )
+                retry_instructions = {
+                    **decomposition_result,
+                    "previous_errors": validation_errors,
+                    "retry_instructions": (
+                        "The previous generation had validation errors. "
+                        "Please fix these issues in the new generation:\n"
+                        f"{validation_errors}"
+                    ),
+                }
+                agent_json = await generate_agent(retry_instructions)
+
+            if agent_json is None:
+                if attempt == MAX_GENERATION_RETRIES:
+                    return ErrorResponse(
+                        message="Failed to generate the agent. Please try again.",
+                        error="Generation failed",
+                        session_id=session_id,
+                    )
+                continue
+
+            # Step 3: Apply fixes to correct common errors
+            agent_json = apply_all_fixes(agent_json, blocks_info)
+
+            # Step 4: Validate the agent
+            is_valid, validation_errors = validate_agent(agent_json, blocks_info)
+
+            if is_valid:
+                logger.info(f"Agent generated successfully on attempt {attempt + 1}")
+                break
+
+            logger.warning(
+                f"Validation failed on attempt {attempt + 1}: {validation_errors}"
+            )
+
+            if attempt == MAX_GENERATION_RETRIES:
+                # Return error with validation details
+                return ErrorResponse(
+                    message=(
+                        f"Generated agent has validation errors after {MAX_GENERATION_RETRIES + 1} attempts. "
+                        f"Please try rephrasing your request or simplify the workflow."
+                    ),
+                    error="validation_failed",
+                    details={"validation_errors": validation_errors},
+                    session_id=session_id,
+                )
+
+        agent_name = agent_json.get("name", "Generated Agent")
+        agent_description = agent_json.get("description", "")
+        node_count = len(agent_json.get("nodes", []))
+        link_count = len(agent_json.get("links", []))
+
+        # Step 4: Preview or save
+        if not save:
+            return AgentPreviewResponse(
+                message=(
+                    f"I've generated an agent called '{agent_name}' with {node_count} blocks. "
+                    f"Review it and call create_agent with save=true to save it to your library."
+                ),
+                agent_json=agent_json,
+                agent_name=agent_name,
+                description=agent_description,
+                node_count=node_count,
+                link_count=link_count,
+                session_id=session_id,
+            )
+
+        # Save to library
+        if not user_id:
+            return ErrorResponse(
+                message="You must be logged in to save agents.",
+                error="auth_required",
+                session_id=session_id,
+            )
+
+        try:
+            created_graph, library_agent = await save_agent_to_library(
+                agent_json, user_id
+            )
+
+            return AgentSavedResponse(
+                message=f"Agent '{created_graph.name}' has been saved to your library!",
+                agent_id=created_graph.id,
+                agent_name=created_graph.name,
+                library_agent_id=library_agent.id,
+                library_agent_link=f"/library/{library_agent.id}",
+                agent_page_link=f"/build?flowID={created_graph.id}",
+                session_id=session_id,
+            )
+        except Exception as e:
+            return ErrorResponse(
+                message=f"Failed to save the agent: {str(e)}",
+                error="save_failed",
+                details={"exception": str(e)},
+                session_id=session_id,
+            )

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

@@ -0,0 +1,294 @@
+"""EditAgentTool - Edits existing agents using natural language."""
+
+import logging
+from typing import Any
+
+from backend.api.features.chat.model import ChatSession
+
+from .agent_generator import (
+    apply_agent_patch,
+    apply_all_fixes,
+    generate_agent_patch,
+    get_agent_as_json,
+    get_blocks_info,
+    save_agent_to_library,
+    validate_agent,
+)
+from .base import BaseTool
+from .models import (
+    AgentPreviewResponse,
+    AgentSavedResponse,
+    ClarificationNeededResponse,
+    ClarifyingQuestion,
+    ErrorResponse,
+    ToolResponseBase,
+)
+
+logger = logging.getLogger(__name__)
+
+# Maximum retries for patch generation with validation feedback
+MAX_GENERATION_RETRIES = 2
+
+
+class EditAgentTool(BaseTool):
+    """Tool for editing existing agents using natural language."""
+
+    @property
+    def name(self) -> str:
+        return "edit_agent"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Edit an existing agent from the user's library using natural language. "
+            "Generates a patch to update the agent while preserving unchanged parts."
+        )
+
+    @property
+    def requires_auth(self) -> bool:
+        return True
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "agent_id": {
+                    "type": "string",
+                    "description": (
+                        "The ID of the agent to edit. "
+                        "Can be a graph ID or library agent ID."
+                    ),
+                },
+                "changes": {
+                    "type": "string",
+                    "description": (
+                        "Natural language description of what changes to make. "
+                        "Be specific about what to add, remove, or modify."
+                    ),
+                },
+                "context": {
+                    "type": "string",
+                    "description": (
+                        "Additional context or answers to previous clarifying questions."
+                    ),
+                },
+                "save": {
+                    "type": "boolean",
+                    "description": (
+                        "Whether to save the changes. "
+                        "Default is true. Set to false for preview only."
+                    ),
+                    "default": True,
+                },
+            },
+            "required": ["agent_id", "changes"],
+        }
+
+    async def _execute(
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        **kwargs,
+    ) -> ToolResponseBase:
+        """Execute the edit_agent tool.
+
+        Flow:
+        1. Fetch the current agent
+        2. Generate a patch based on the requested changes
+        3. Apply the patch to create an updated agent
+        4. Preview or save based on the save parameter
+        """
+        agent_id = kwargs.get("agent_id", "").strip()
+        changes = kwargs.get("changes", "").strip()
+        context = kwargs.get("context", "")
+        save = kwargs.get("save", True)
+        session_id = session.session_id if session else None
+
+        if not agent_id:
+            return ErrorResponse(
+                message="Please provide the agent ID to edit.",
+                error="Missing agent_id parameter",
+                session_id=session_id,
+            )
+
+        if not changes:
+            return ErrorResponse(
+                message="Please describe what changes you want to make.",
+                error="Missing changes parameter",
+                session_id=session_id,
+            )
+
+        # Step 1: Fetch current agent
+        current_agent = await get_agent_as_json(agent_id, user_id)
+
+        if current_agent is None:
+            return ErrorResponse(
+                message=f"Could not find agent with ID '{agent_id}' in your library.",
+                error="agent_not_found",
+                session_id=session_id,
+            )
+
+        # Build the update request with context
+        update_request = changes
+        if context:
+            update_request = f"{changes}\n\nAdditional context:\n{context}"
+
+        # Step 2: Generate patch with retry on validation failure
+        blocks_info = get_blocks_info()
+        updated_agent = None
+        validation_errors = None
+        intent = "Applied requested changes"
+
+        for attempt in range(MAX_GENERATION_RETRIES + 1):
+            # Generate patch (include validation errors from previous attempt)
+            try:
+                if attempt == 0:
+                    patch_result = await generate_agent_patch(
+                        update_request, current_agent
+                    )
+                else:
+                    # Retry with validation error feedback
+                    logger.info(
+                        f"Retry {attempt}/{MAX_GENERATION_RETRIES} with validation feedback"
+                    )
+                    retry_request = (
+                        f"{update_request}\n\n"
+                        f"IMPORTANT: The previous edit had validation errors. "
+                        f"Please fix these issues:\n{validation_errors}"
+                    )
+                    patch_result = await generate_agent_patch(
+                        retry_request, current_agent
+                    )
+            except ValueError as e:
+                # Handle missing API key or configuration errors
+                return ErrorResponse(
+                    message=f"Agent generation is not configured: {str(e)}",
+                    error="configuration_error",
+                    session_id=session_id,
+                )
+
+            if patch_result is None:
+                if attempt == MAX_GENERATION_RETRIES:
+                    return ErrorResponse(
+                        message="Failed to generate changes. Please try rephrasing.",
+                        error="Patch generation failed",
+                        session_id=session_id,
+                    )
+                continue
+
+            # Check if LLM returned clarifying questions
+            if patch_result.get("type") == "clarifying_questions":
+                questions = patch_result.get("questions", [])
+                return ClarificationNeededResponse(
+                    message=(
+                        "I need some more information about the changes. "
+                        "Please answer the following questions:"
+                    ),
+                    questions=[
+                        ClarifyingQuestion(
+                            question=q.get("question", ""),
+                            keyword=q.get("keyword", ""),
+                            example=q.get("example"),
+                        )
+                        for q in questions
+                    ],
+                    session_id=session_id,
+                )
+
+            # Step 3: Apply patch and fixes
+            try:
+                updated_agent = apply_agent_patch(current_agent, patch_result)
+                updated_agent = apply_all_fixes(updated_agent, blocks_info)
+            except Exception as e:
+                if attempt == MAX_GENERATION_RETRIES:
+                    return ErrorResponse(
+                        message=f"Failed to apply changes: {str(e)}",
+                        error="patch_apply_failed",
+                        details={"exception": str(e)},
+                        session_id=session_id,
+                    )
+                validation_errors = str(e)
+                continue
+
+            # Step 4: Validate the updated agent
+            is_valid, validation_errors = validate_agent(updated_agent, blocks_info)
+
+            if is_valid:
+                logger.info(f"Agent edited successfully on attempt {attempt + 1}")
+                intent = patch_result.get("intent", "Applied requested changes")
+                break
+
+            logger.warning(
+                f"Validation failed on attempt {attempt + 1}: {validation_errors}"
+            )
+
+            if attempt == MAX_GENERATION_RETRIES:
+                # Return error with validation details
+                return ErrorResponse(
+                    message=(
+                        f"Updated agent has validation errors after "
+                        f"{MAX_GENERATION_RETRIES + 1} attempts. "
+                        f"Please try rephrasing your request or simplify the changes."
+                    ),
+                    error="validation_failed",
+                    details={"validation_errors": validation_errors},
+                    session_id=session_id,
+                )
+
+        # At this point, updated_agent is guaranteed to be set (we return on all failure paths)
+        assert updated_agent is not None
+
+        agent_name = updated_agent.get("name", "Updated Agent")
+        agent_description = updated_agent.get("description", "")
+        node_count = len(updated_agent.get("nodes", []))
+        link_count = len(updated_agent.get("links", []))
+
+        # Step 5: Preview or save
+        if not save:
+            return AgentPreviewResponse(
+                message=(
+                    f"I've updated the agent. Changes: {intent}. "
+                    f"The agent now has {node_count} blocks. "
+                    f"Review it and call edit_agent with save=true to save the changes."
+                ),
+                agent_json=updated_agent,
+                agent_name=agent_name,
+                description=agent_description,
+                node_count=node_count,
+                link_count=link_count,
+                session_id=session_id,
+            )
+
+        # Save to library (creates a new version)
+        if not user_id:
+            return ErrorResponse(
+                message="You must be logged in to save agents.",
+                error="auth_required",
+                session_id=session_id,
+            )
+
+        try:
+            created_graph, library_agent = await save_agent_to_library(
+                updated_agent, user_id, is_update=True
+            )
+
+            return AgentSavedResponse(
+                message=(
+                    f"Updated agent '{created_graph.name}' has been saved to your library! "
+                    f"Changes: {intent}"
+                ),
+                agent_id=created_graph.id,
+                agent_name=created_graph.name,
+                library_agent_id=library_agent.id,
+                library_agent_link=f"/library/{library_agent.id}",
+                agent_page_link=f"/build?flowID={created_graph.id}",
+                session_id=session_id,
+            )
+        except Exception as e:
+            return ErrorResponse(
+                message=f"Failed to save the updated agent: {str(e)}",
+                error="save_failed",
+                details={"exception": str(e)},
+                session_id=session_id,
+            )

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

@@ -0,0 +1,253 @@
+"""Tool for searching available blocks using hybrid search."""
+
+import logging
+from typing import Any
+
+from backend.api.features.chat.model import ChatSession
+from backend.blocks import load_all_blocks
+
+from .base import BaseTool
+from .models import (
+    BlockInfoSummary,
+    BlockListResponse,
+    ErrorResponse,
+    NoResultsResponse,
+    ToolResponseBase,
+)
+from .search_blocks import get_block_search_index
+
+logger = logging.getLogger(__name__)
+
+
+class FindBlockTool(BaseTool):
+    """Tool for searching available blocks."""
+
+    @property
+    def name(self) -> str:
+        return "find_block"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Search for available blocks by name or description. "
+            "Blocks are reusable components that perform specific tasks like "
+            "sending emails, making API calls, processing text, etc. "
+            "Use this to find blocks that can be executed directly."
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": (
+                        "Search query to find blocks by name or description. "
+                        "Use keywords like 'email', 'http', 'text', 'ai', etc."
+                    ),
+                },
+            },
+            "required": ["query"],
+        }
+
+    @property
+    def requires_auth(self) -> bool:
+        return True
+
+    def _matches_query(self, block, query: str) -> tuple[int, bool]:
+        """
+        Check if a block matches the query and return a priority score.
+
+        Returns (priority, matches) where:
+        - priority 0: exact name match
+        - priority 1: name contains query
+        - priority 2: description contains query
+        - priority 3: category contains query
+        """
+        query_lower = query.lower()
+        name_lower = block.name.lower()
+        desc_lower = block.description.lower()
+
+        # Exact name match
+        if query_lower == name_lower:
+            return 0, True
+
+        # Name contains query
+        if query_lower in name_lower:
+            return 1, True
+
+        # Description contains query
+        if query_lower in desc_lower:
+            return 2, True
+
+        # Category contains query
+        for category in block.categories:
+            if query_lower in category.name.lower():
+                return 3, True
+
+        return 4, False
+
+    async def _execute(
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        **kwargs,
+    ) -> ToolResponseBase:
+        """Search for blocks matching the query.
+
+        Args:
+            user_id: User ID (required)
+            session: Chat session
+            query: Search query
+
+        Returns:
+            BlockListResponse: List of matching blocks
+            NoResultsResponse: No blocks found
+            ErrorResponse: Error message
+        """
+        query = kwargs.get("query", "").strip()
+        session_id = session.session_id
+
+        if not query:
+            return ErrorResponse(
+                message="Please provide a search query",
+                session_id=session_id,
+            )
+
+        try:
+            # Try hybrid search first
+            search_results = self._hybrid_search(query)
+
+            if search_results is not None:
+                # Hybrid search succeeded
+                if not search_results:
+                    return NoResultsResponse(
+                        message=f"No blocks found matching '{query}'",
+                        session_id=session_id,
+                        suggestions=[
+                            "Try more general terms",
+                            "Search by category: ai, text, social, search, etc.",
+                            "Check block names like 'SendEmail', 'HttpRequest', etc.",
+                        ],
+                    )
+
+                # Get full block info for each result
+                all_blocks = load_all_blocks()
+                blocks = []
+                for result in search_results:
+                    block_cls = all_blocks.get(result.block_id)
+                    if block_cls:
+                        block = block_cls()
+                        blocks.append(
+                            BlockInfoSummary(
+                                id=block.id,
+                                name=block.name,
+                                description=block.description,
+                                categories=[cat.name for cat in block.categories],
+                                input_schema=block.input_schema.jsonschema(),
+                                output_schema=block.output_schema.jsonschema(),
+                            )
+                        )
+
+                return BlockListResponse(
+                    message=(
+                        f"Found {len(blocks)} block{'s' if len(blocks) != 1 else ''} "
+                        f"matching '{query}'. Use run_block to execute a block with "
+                        "the required inputs."
+                    ),
+                    blocks=blocks,
+                    count=len(blocks),
+                    query=query,
+                    session_id=session_id,
+                )
+
+            # Fallback to simple search if hybrid search failed
+            return self._simple_search(query, session_id)
+
+        except Exception as e:
+            logger.error(f"Error searching blocks: {e}", exc_info=True)
+            return ErrorResponse(
+                message="Failed to search blocks. Please try again.",
+                error=str(e),
+                session_id=session_id,
+            )
+
+    def _hybrid_search(self, query: str) -> list | None:
+        """
+        Perform hybrid search using embeddings and BM25.
+
+        Returns:
+            List of BlockSearchResult if successful, None if index not available
+        """
+        try:
+            index = get_block_search_index()
+            if not index.load():
+                logger.info(
+                    "Block search index not available, falling back to simple search"
+                )
+                return None
+
+            results = index.search(query, top_k=10)
+            logger.info(f"Hybrid search found {len(results)} blocks for: {query}")
+            return results
+
+        except Exception as e:
+            logger.warning(f"Hybrid search failed, falling back to simple: {e}")
+            return None
+
+    def _simple_search(self, query: str, session_id: str) -> ToolResponseBase:
+        """Fallback simple search using substring matching."""
+        all_blocks = load_all_blocks()
+        logger.info(f"Simple searching {len(all_blocks)} blocks for: {query}")
+
+        # Find matching blocks with priority scores
+        matches: list[tuple[int, Any]] = []
+        for block_id, block_cls in all_blocks.items():
+            block = block_cls()
+            priority, is_match = self._matches_query(block, query)
+            if is_match:
+                matches.append((priority, block))
+
+        # Sort by priority (lower is better)
+        matches.sort(key=lambda x: x[0])
+
+        # Take top 10 results
+        top_matches = [block for _, block in matches[:10]]
+
+        if not top_matches:
+            return NoResultsResponse(
+                message=f"No blocks found matching '{query}'",
+                session_id=session_id,
+                suggestions=[
+                    "Try more general terms",
+                    "Search by category: ai, text, social, search, etc.",
+                    "Check block names like 'SendEmail', 'HttpRequest', etc.",
+                ],
+            )
+
+        # Build response
+        blocks = []
+        for block in top_matches:
+            blocks.append(
+                BlockInfoSummary(
+                    id=block.id,
+                    name=block.name,
+                    description=block.description,
+                    categories=[cat.name for cat in block.categories],
+                    input_schema=block.input_schema.jsonschema(),
+                    output_schema=block.output_schema.jsonschema(),
+                )
+            )
+
+        return BlockListResponse(
+            message=(
+                f"Found {len(blocks)} block{'s' if len(blocks) != 1 else ''} "
+                f"matching '{query}'. Use run_block to execute a block with "
+                "the required inputs."
+            ),
+            blocks=blocks,
+            count=len(blocks),
+            query=query,
+            session_id=session_id,
+        )

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

@@ -0,0 +1,483 @@
+#!/usr/bin/env python3
+"""
+Block Indexer for Hybrid Search
+
+Creates a hybrid search index from blocks:
+- OpenAI embeddings (text-embedding-3-small)
+- BM25 index for lexical search
+- Name index for title matching boost
+
+Supports incremental updates by tracking content hashes.
+
+Usage:
+    python -m backend.server.v2.chat.tools.index_blocks [--force]
+"""
+
+import argparse
+import base64
+import hashlib
+import json
+import logging
+import os
+import re
+import sys
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+# Check for OpenAI availability
+try:
+    import openai  # noqa: F401
+
+    HAS_OPENAI = True
+except ImportError:
+    HAS_OPENAI = False
+    print("Warning: openai not installed. Run: pip install openai")
+
+# Default embedding model (OpenAI)
+DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small"
+DEFAULT_EMBEDDING_DIM = 1536
+
+# Output path (relative to this file)
+INDEX_PATH = Path(__file__).parent / "blocks_index.json"
+
+# Stopwords for tokenization
+STOPWORDS = {
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "ought",
+    "used",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "so",
+    "yet",
+    "both",
+    "either",
+    "neither",
+    "not",
+    "only",
+    "own",
+    "same",
+    "than",
+    "too",
+    "very",
+    "just",
+    "also",
+    "now",
+    "here",
+    "there",
+    "when",
+    "where",
+    "why",
+    "how",
+    "all",
+    "each",
+    "every",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "any",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its",
+    "block",  # Too common in block context
+}
+
+
+def tokenize(text: str) -> list[str]:
+    """Simple tokenizer for BM25."""
+    text = text.lower()
+    # Remove code blocks if any
+    text = re.sub(r"```[\s\S]*?```", "", text)
+    text = re.sub(r"`[^`]+`", "", text)
+    # Extract words (including camelCase split)
+    # First, split camelCase
+    text = re.sub(r"([a-z])([A-Z])", r"\1 \2", text)
+    # Extract words
+    words = re.findall(r"\b[a-z][a-z0-9_-]*\b", text)
+    # Remove very short words and stopwords
+    return [w for w in words if len(w) > 2 and w not in STOPWORDS]
+
+
+def build_searchable_text(block: Any) -> str:
+    """Build searchable text from block attributes."""
+    parts = []
+
+    # Block name (split camelCase for better tokenization)
+    name = block.name
+    # Split camelCase: GetCurrentTimeBlock -> Get Current Time Block
+    name_split = re.sub(r"([a-z])([A-Z])", r"\1 \2", name)
+    parts.append(name_split)
+
+    # Description
+    if block.description:
+        parts.append(block.description)
+
+    # Categories
+    for category in block.categories:
+        parts.append(category.name)
+
+    # Input schema field names and descriptions
+    try:
+        input_schema = block.input_schema.jsonschema()
+        if "properties" in input_schema:
+            for field_name, field_info in input_schema["properties"].items():
+                parts.append(field_name)
+                if "description" in field_info:
+                    parts.append(field_info["description"])
+    except Exception:
+        pass
+
+    # Output schema field names
+    try:
+        output_schema = block.output_schema.jsonschema()
+        if "properties" in output_schema:
+            for field_name in output_schema["properties"]:
+                parts.append(field_name)
+    except Exception:
+        pass
+
+    return " ".join(parts)
+
+
+def compute_content_hash(text: str) -> str:
+    """Compute MD5 hash of text for change detection."""
+    return hashlib.md5(text.encode()).hexdigest()
+
+
+def load_existing_index(index_path: Path) -> dict[str, Any] | None:
+    """Load existing index if present."""
+    if not index_path.exists():
+        return None
+
+    try:
+        with open(index_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        logger.warning(f"Failed to load existing index: {e}")
+        return None
+
+
+def create_embeddings(
+    texts: list[str],
+    model_name: str = DEFAULT_EMBEDDING_MODEL,
+    batch_size: int = 100,
+) -> np.ndarray:
+    """Create embeddings using OpenAI API."""
+    if not HAS_OPENAI:
+        raise RuntimeError("openai not installed. Run: pip install openai")
+
+    # Import here to satisfy type checker
+    from openai import OpenAI
+
+    # Check for API key
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise RuntimeError("OPENAI_API_KEY environment variable not set")
+
+    client = OpenAI(api_key=api_key)
+    embeddings = []
+
+    print(f"Creating embeddings for {len(texts)} texts using {model_name}...")
+
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i : i + batch_size]
+        # Truncate texts to max token limit (8191 tokens for text-embedding-3-small)
+        # Roughly 4 chars per token, so ~32000 chars max
+        batch = [text[:32000] for text in batch]
+
+        response = client.embeddings.create(
+            model=model_name,
+            input=batch,
+        )
+
+        for embedding_data in response.data:
+            embeddings.append(embedding_data.embedding)
+
+        print(f"  Processed {min(i + batch_size, len(texts))}/{len(texts)} texts")
+
+    return np.array(embeddings, dtype=np.float32)
+
+
+def build_bm25_data(
+    blocks_data: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Build BM25 metadata from block data."""
+    # Tokenize all searchable texts
+    tokenized_docs = []
+    for block in blocks_data:
+        tokens = tokenize(block["searchable_text"])
+        tokenized_docs.append(tokens)
+
+    # Calculate document frequencies
+    doc_freq: dict[str, int] = {}
+    for tokens in tokenized_docs:
+        seen = set()
+        for token in tokens:
+            if token not in seen:
+                doc_freq[token] = doc_freq.get(token, 0) + 1
+                seen.add(token)
+
+    n_docs = len(tokenized_docs)
+    doc_lens = [len(d) for d in tokenized_docs]
+    avgdl = sum(doc_lens) / max(n_docs, 1)
+
+    return {
+        "n_docs": n_docs,
+        "avgdl": avgdl,
+        "df": doc_freq,
+        "doc_lens": doc_lens,
+    }
+
+
+def build_name_index(
+    blocks_data: list[dict[str, Any]],
+) -> dict[str, list[list[int | float]]]:
+    """Build inverted index for name search boost."""
+    index: dict[str, list[list[int | float]]] = defaultdict(list)
+
+    for idx, block in enumerate(blocks_data):
+        # Tokenize block name
+        name_tokens = tokenize(block["name"])
+        seen = set()
+
+        for i, token in enumerate(name_tokens):
+            if token in seen:
+                continue
+            seen.add(token)
+
+            # Score: first token gets higher weight
+            score = 1.5 if i == 0 else 1.0
+            index[token].append([idx, score])
+
+    return dict(index)
+
+
+def build_block_index(
+    force_rebuild: bool = False,
+    output_path: Path = INDEX_PATH,
+) -> dict[str, Any]:
+    """
+    Build the block search index.
+
+    Args:
+        force_rebuild: If True, rebuild all embeddings even if unchanged
+        output_path: Path to save the index
+
+    Returns:
+        The generated index dictionary
+    """
+    # Import here to avoid circular imports
+    from backend.blocks import load_all_blocks
+
+    print("Loading all blocks...")
+    all_blocks = load_all_blocks()
+    print(f"Found {len(all_blocks)} blocks")
+
+    # Load existing index for incremental updates
+    existing_index = None if force_rebuild else load_existing_index(output_path)
+    existing_blocks: dict[str, dict[str, Any]] = {}
+
+    if existing_index:
+        print(
+            f"Loaded existing index with {len(existing_index.get('blocks', []))} blocks"
+        )
+        for block in existing_index.get("blocks", []):
+            existing_blocks[block["id"]] = block
+
+    # Process each block
+    blocks_data: list[dict[str, Any]] = []
+    blocks_needing_embedding: list[tuple[int, str]] = []  # (index, searchable_text)
+
+    for block_id, block_cls in all_blocks.items():
+        try:
+            block = block_cls()
+
+            # Skip disabled blocks
+            if block.disabled:
+                continue
+
+            searchable_text = build_searchable_text(block)
+            content_hash = compute_content_hash(searchable_text)
+
+            block_data = {
+                "id": block.id,
+                "name": block.name,
+                "description": block.description,
+                "categories": [cat.name for cat in block.categories],
+                "searchable_text": searchable_text,
+                "content_hash": content_hash,
+                "emb": None,  # Will be filled later
+            }
+
+            # Check if we can reuse existing embedding
+            if (
+                block.id in existing_blocks
+                and existing_blocks[block.id].get("content_hash") == content_hash
+                and existing_blocks[block.id].get("emb")
+            ):
+                # Reuse existing embedding
+                block_data["emb"] = existing_blocks[block.id]["emb"]
+            else:
+                # Need new embedding
+                blocks_needing_embedding.append((len(blocks_data), searchable_text))
+
+            blocks_data.append(block_data)
+
+        except Exception as e:
+            logger.warning(f"Failed to process block {block_id}: {e}")
+            continue
+
+    print(f"Processed {len(blocks_data)} blocks")
+    print(f"Blocks needing new embeddings: {len(blocks_needing_embedding)}")
+
+    # Create embeddings for new/changed blocks
+    if blocks_needing_embedding and HAS_OPENAI:
+        texts_to_embed = [text for _, text in blocks_needing_embedding]
+        try:
+            embeddings = create_embeddings(texts_to_embed)
+
+            # Assign embeddings to blocks
+            for i, (block_idx, _) in enumerate(blocks_needing_embedding):
+                emb = embeddings[i].astype(np.float32)
+                # Encode as base64
+                blocks_data[block_idx]["emb"] = base64.b64encode(emb.tobytes()).decode(
+                    "ascii"
+                )
+        except Exception as e:
+            print(f"Warning: Failed to create embeddings: {e}")
+    elif blocks_needing_embedding:
+        print(
+            "Warning: Cannot create embeddings (openai not installed or OPENAI_API_KEY not set)"
+        )
+
+    # Build BM25 data
+    print("Building BM25 index...")
+    bm25_data = build_bm25_data(blocks_data)
+
+    # Build name index
+    print("Building name index...")
+    name_index = build_name_index(blocks_data)
+
+    # Build final index
+    index = {
+        "version": "1.0.0",
+        "embedding_model": DEFAULT_EMBEDDING_MODEL,
+        "embedding_dim": DEFAULT_EMBEDDING_DIM,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "blocks": blocks_data,
+        "bm25": bm25_data,
+        "name_index": name_index,
+    }
+
+    # Save index
+    print(f"Saving index to {output_path}...")
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(index, f, separators=(",", ":"))
+
+    size_kb = output_path.stat().st_size / 1024
+    print(f"Index saved ({size_kb:.1f} KB)")
+
+    # Print statistics
+    print("\nIndex Statistics:")
+    print(f"  Blocks indexed: {len(blocks_data)}")
+    print(f"  BM25 vocabulary size: {len(bm25_data['df'])}")
+    print(f"  Name index terms: {len(name_index)}")
+    print(f"  Embeddings: {'Yes' if any(b.get('emb') for b in blocks_data) else 'No'}")
+
+    return index
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build hybrid search index for blocks")
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force rebuild all embeddings even if unchanged",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=INDEX_PATH,
+        help=f"Output index file path (default: {INDEX_PATH})",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        build_block_index(
+            force_rebuild=args.force,
+            output_path=args.output,
+        )
+    except Exception as e:
+        print(f"Error building index: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,287 @@
+"""Tool for executing blocks directly."""
+
+import logging
+from collections import defaultdict
+from typing import Any
+
+from backend.api.features.chat.model import ChatSession
+from backend.data.block import get_block
+from backend.data.model import CredentialsMetaInput
+from backend.integrations.creds_manager import IntegrationCredentialsManager
+from backend.util.exceptions import BlockError
+
+from .base import BaseTool
+from .models import (
+    BlockOutputResponse,
+    ErrorResponse,
+    SetupInfo,
+    SetupRequirementsResponse,
+    ToolResponseBase,
+    UserReadiness,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class RunBlockTool(BaseTool):
+    """Tool for executing a block and returning its outputs."""
+
+    @property
+    def name(self) -> str:
+        return "run_block"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Execute a specific block with the provided input data. "
+            "Use find_block to discover available blocks and their input schemas. "
+            "The block will run and return its outputs once complete."
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "block_id": {
+                    "type": "string",
+                    "description": "The UUID of the block to execute",
+                },
+                "input_data": {
+                    "type": "object",
+                    "description": (
+                        "Input values for the block. Must match the block's input schema. "
+                        "Check the block's input_schema from find_block for required fields."
+                    ),
+                },
+            },
+            "required": ["block_id", "input_data"],
+        }
+
+    @property
+    def requires_auth(self) -> bool:
+        return True
+
+    async def _check_block_credentials(
+        self,
+        user_id: str,
+        block: Any,
+    ) -> tuple[dict[str, CredentialsMetaInput], list[CredentialsMetaInput]]:
+        """
+        Check if user has required credentials for a block.
+
+        Returns:
+            tuple[matched_credentials, missing_credentials]
+        """
+        matched_credentials: dict[str, CredentialsMetaInput] = {}
+        missing_credentials: list[CredentialsMetaInput] = []
+
+        # Get credential field info from block's input schema
+        credentials_fields_info = block.input_schema.get_credentials_fields_info()
+
+        if not credentials_fields_info:
+            return matched_credentials, missing_credentials
+
+        # Get user's available credentials
+        creds_manager = IntegrationCredentialsManager()
+        available_creds = await creds_manager.store.get_all_creds(user_id)
+
+        for field_name, field_info in credentials_fields_info.items():
+            # field_info.provider is a frozenset of acceptable providers
+            # field_info.supported_types is a frozenset of acceptable types
+            matching_cred = next(
+                (
+                    cred
+                    for cred in available_creds
+                    if cred.provider in field_info.provider
+                    and cred.type in field_info.supported_types
+                ),
+                None,
+            )
+
+            if matching_cred:
+                matched_credentials[field_name] = CredentialsMetaInput(
+                    id=matching_cred.id,
+                    provider=matching_cred.provider,  # type: ignore
+                    type=matching_cred.type,
+                    title=matching_cred.title,
+                )
+            else:
+                # Create a placeholder for the missing credential
+                provider = next(iter(field_info.provider), "unknown")
+                cred_type = next(iter(field_info.supported_types), "api_key")
+                missing_credentials.append(
+                    CredentialsMetaInput(
+                        id=field_name,
+                        provider=provider,  # type: ignore
+                        type=cred_type,  # type: ignore
+                        title=field_name.replace("_", " ").title(),
+                    )
+                )
+
+        return matched_credentials, missing_credentials
+
+    async def _execute(
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        **kwargs,
+    ) -> ToolResponseBase:
+        """Execute a block with the given input data.
+
+        Args:
+            user_id: User ID (required)
+            session: Chat session
+            block_id: Block UUID to execute
+            input_data: Input values for the block
+
+        Returns:
+            BlockOutputResponse: Block execution outputs
+            SetupRequirementsResponse: Missing credentials
+            ErrorResponse: Error message
+        """
+        block_id = kwargs.get("block_id", "").strip()
+        input_data = kwargs.get("input_data", {})
+        session_id = session.session_id
+
+        if not block_id:
+            return ErrorResponse(
+                message="Please provide a block_id",
+                session_id=session_id,
+            )
+
+        if not isinstance(input_data, dict):
+            return ErrorResponse(
+                message="input_data must be an object",
+                session_id=session_id,
+            )
+
+        if not user_id:
+            return ErrorResponse(
+                message="Authentication required",
+                session_id=session_id,
+            )
+
+        # Get the block
+        block = get_block(block_id)
+        if not block:
+            return ErrorResponse(
+                message=f"Block '{block_id}' not found",
+                session_id=session_id,
+            )
+
+        logger.info(f"Executing block {block.name} ({block_id}) for user {user_id}")
+
+        # Check credentials
+        creds_manager = IntegrationCredentialsManager()
+        matched_credentials, missing_credentials = await self._check_block_credentials(
+            user_id, block
+        )
+
+        if missing_credentials:
+            # Return setup requirements response with missing credentials
+            missing_creds_dict = {c.id: c.model_dump() for c in missing_credentials}
+
+            return SetupRequirementsResponse(
+                message=(
+                    f"Block '{block.name}' requires credentials that are not configured. "
+                    "Please set up the required credentials before running this block."
+                ),
+                session_id=session_id,
+                setup_info=SetupInfo(
+                    agent_id=block_id,
+                    agent_name=block.name,
+                    user_readiness=UserReadiness(
+                        has_all_credentials=False,
+                        missing_credentials=missing_creds_dict,
+                        ready_to_run=False,
+                    ),
+                    requirements={
+                        "credentials": [c.model_dump() for c in missing_credentials],
+                        "inputs": self._get_inputs_list(block),
+                        "execution_modes": ["immediate"],
+                    },
+                ),
+                graph_id=None,
+                graph_version=None,
+            )
+
+        try:
+            # Fetch actual credentials and prepare kwargs for block execution
+            exec_kwargs: dict[str, Any] = {"user_id": user_id}
+
+            for field_name, cred_meta in matched_credentials.items():
+                # Inject metadata into input_data (for validation)
+                if field_name not in input_data:
+                    input_data[field_name] = cred_meta.model_dump()
+
+                # Fetch actual credentials and pass as kwargs (for execution)
+                actual_credentials = await creds_manager.get(
+                    user_id, cred_meta.id, lock=False
+                )
+                if actual_credentials:
+                    exec_kwargs[field_name] = actual_credentials
+                else:
+                    return ErrorResponse(
+                        message=f"Failed to retrieve credentials for {field_name}",
+                        session_id=session_id,
+                    )
+
+            # Execute the block and collect outputs
+            outputs: dict[str, list[Any]] = defaultdict(list)
+            async for output_name, output_data in block.execute(
+                input_data,
+                **exec_kwargs,
+            ):
+                outputs[output_name].append(output_data)
+
+            return BlockOutputResponse(
+                message=f"Block '{block.name}' executed successfully",
+                block_id=block_id,
+                block_name=block.name,
+                outputs=dict(outputs),
+                success=True,
+                session_id=session_id,
+            )
+
+        except BlockError as e:
+            logger.warning(f"Block execution failed: {e}")
+            return ErrorResponse(
+                message=f"Block execution failed: {e}",
+                error=str(e),
+                session_id=session_id,
+            )
+        except Exception as e:
+            logger.error(f"Unexpected error executing block: {e}", exc_info=True)
+            return ErrorResponse(
+                message=f"Failed to execute block: {str(e)}",
+                error=str(e),
+                session_id=session_id,
+            )
+
+    def _get_inputs_list(self, block: Any) -> list[dict[str, Any]]:
+        """Extract non-credential inputs from block schema."""
+        inputs_list = []
+        schema = block.input_schema.jsonschema()
+        properties = schema.get("properties", {})
+        required_fields = set(schema.get("required", []))
+
+        # Get credential field names to exclude
+        credentials_fields = set(block.input_schema.get_credentials_fields().keys())
+
+        for field_name, field_schema in properties.items():
+            # Skip credential fields
+            if field_name in credentials_fields:
+                continue
+
+            inputs_list.append(
+                {
+                    "name": field_name,
+                    "title": field_schema.get("title", field_name),
+                    "type": field_schema.get("type", "string"),
+                    "description": field_schema.get("description", ""),
+                    "required": field_name in required_fields,
+                }
+            )
+
+        return inputs_list

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

@@ -0,0 +1,460 @@
+"""
+Block Hybrid Search
+
+Combines multiple ranking signals for block search:
+- Semantic search (OpenAI embeddings + cosine similarity)
+- Lexical search (BM25)
+- Name matching (boost for block name matches)
+- Category matching (boost for category matches)
+
+Based on the docs search implementation.
+"""
+
+import base64
+import json
+import logging
+import math
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+# OpenAI embedding model
+EMBEDDING_MODEL = "text-embedding-3-small"
+
+# Path to the JSON index file
+INDEX_PATH = Path(__file__).parent / "blocks_index.json"
+
+# Stopwords for tokenization (same as index_blocks.py)
+STOPWORDS = {
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "ought",
+    "used",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "so",
+    "yet",
+    "both",
+    "either",
+    "neither",
+    "not",
+    "only",
+    "own",
+    "same",
+    "than",
+    "too",
+    "very",
+    "just",
+    "also",
+    "now",
+    "here",
+    "there",
+    "when",
+    "where",
+    "why",
+    "how",
+    "all",
+    "each",
+    "every",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "any",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its",
+    "block",
+}
+
+
+def tokenize(text: str) -> list[str]:
+    """Simple tokenizer for search."""
+    text = text.lower()
+    # Remove code blocks if any
+    text = re.sub(r"```[\s\S]*?```", "", text)
+    text = re.sub(r"`[^`]+`", "", text)
+    # Split camelCase
+    text = re.sub(r"([a-z])([A-Z])", r"\1 \2", text)
+    # Extract words
+    words = re.findall(r"\b[a-z][a-z0-9_-]*\b", text)
+    # Remove very short words and stopwords
+    return [w for w in words if len(w) > 2 and w not in STOPWORDS]
+
+
+@dataclass
+class SearchWeights:
+    """Configuration for hybrid search signal weights."""
+
+    semantic: float = 0.40  # Embedding similarity
+    bm25: float = 0.25  # Lexical matching
+    name_match: float = 0.25  # Block name matches
+    category_match: float = 0.10  # Category matches
+
+
+@dataclass
+class BlockSearchResult:
+    """A single block search result."""
+
+    block_id: str
+    name: str
+    description: str
+    categories: list[str]
+    score: float
+
+    # Individual signal scores (for debugging)
+    semantic_score: float = 0.0
+    bm25_score: float = 0.0
+    name_score: float = 0.0
+    category_score: float = 0.0
+
+
+class BlockSearchIndex:
+    """Hybrid search index for blocks combining BM25 + embeddings."""
+
+    def __init__(self, index_path: Path = INDEX_PATH):
+        self.blocks: list[dict[str, Any]] = []
+        self.bm25_data: dict[str, Any] = {}
+        self.name_index: dict[str, list[list[int | float]]] = {}
+        self.embeddings: Optional[np.ndarray] = None
+        self.normalized_embeddings: Optional[np.ndarray] = None
+        self._loaded = False
+        self._index_path = index_path
+        self._embedding_model: Any = None
+
+    def load(self) -> bool:
+        """Load the index from JSON file."""
+        if self._loaded:
+            return True
+
+        if not self._index_path.exists():
+            logger.warning(f"Block index not found at {self._index_path}")
+            return False
+
+        try:
+            with open(self._index_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            self.blocks = data.get("blocks", [])
+            self.bm25_data = data.get("bm25", {})
+            self.name_index = data.get("name_index", {})
+
+            # Decode embeddings from base64
+            embeddings_list = []
+            for block in self.blocks:
+                if block.get("emb"):
+                    emb_bytes = base64.b64decode(block["emb"])
+                    emb = np.frombuffer(emb_bytes, dtype=np.float32)
+                    embeddings_list.append(emb)
+                else:
+                    # No embedding, use zeros
+                    dim = data.get("embedding_dim", 384)
+                    embeddings_list.append(np.zeros(dim, dtype=np.float32))
+
+            if embeddings_list:
+                self.embeddings = np.stack(embeddings_list)
+                # Precompute normalized embeddings for cosine similarity
+                norms = np.linalg.norm(self.embeddings, axis=1, keepdims=True)
+                self.normalized_embeddings = self.embeddings / (norms + 1e-10)
+
+            self._loaded = True
+            logger.info(f"Loaded block index with {len(self.blocks)} blocks")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to load block index: {e}")
+            return False
+
+    def _get_openai_client(self) -> Any:
+        """Get OpenAI client for query embedding."""
+        if self._embedding_model is None:
+            try:
+                from openai import OpenAI
+
+                api_key = os.getenv("OPENAI_API_KEY")
+                if not api_key:
+                    logger.warning("OPENAI_API_KEY not set")
+                    return None
+                self._embedding_model = OpenAI(api_key=api_key)
+            except ImportError:
+                logger.warning("openai not installed")
+                return None
+        return self._embedding_model
+
+    def _embed_query(self, query: str) -> Optional[np.ndarray]:
+        """Embed the search query using OpenAI."""
+        client = self._get_openai_client()
+        if client is None:
+            return None
+
+        try:
+            response = client.embeddings.create(
+                model=EMBEDDING_MODEL,
+                input=query,
+            )
+            embedding = response.data[0].embedding
+            return np.array(embedding, dtype=np.float32)
+        except Exception as e:
+            logger.warning(f"Failed to embed query: {e}")
+            return None
+
+    def _compute_semantic_scores(self, query_embedding: np.ndarray) -> np.ndarray:
+        """Compute cosine similarity between query and all blocks."""
+        if self.normalized_embeddings is None:
+            return np.zeros(len(self.blocks))
+
+        # Normalize query embedding
+        query_norm = query_embedding / (np.linalg.norm(query_embedding) + 1e-10)
+
+        # Cosine similarity via dot product
+        similarities = self.normalized_embeddings @ query_norm
+
+        # Scale to [0, 1] (cosine ranges from -1 to 1)
+        return (similarities + 1) / 2
+
+    def _compute_bm25_scores(self, query_tokens: list[str]) -> np.ndarray:
+        """Compute BM25 scores for all blocks."""
+        scores = np.zeros(len(self.blocks))
+
+        if not self.bm25_data or not query_tokens:
+            return scores
+
+        # BM25 parameters
+        k1 = 1.5
+        b = 0.75
+        n_docs = self.bm25_data.get("n_docs", len(self.blocks))
+        avgdl = self.bm25_data.get("avgdl", 100)
+        df = self.bm25_data.get("df", {})
+        doc_lens = self.bm25_data.get("doc_lens", [100] * len(self.blocks))
+
+        for i, block in enumerate(self.blocks):
+            # Tokenize block's searchable text
+            block_tokens = tokenize(block.get("searchable_text", ""))
+            doc_len = doc_lens[i] if i < len(doc_lens) else len(block_tokens)
+
+            # Calculate BM25 score
+            score = 0.0
+            for token in query_tokens:
+                if token not in df:
+                    continue
+
+                # Term frequency in this document
+                tf = block_tokens.count(token)
+                if tf == 0:
+                    continue
+
+                # IDF
+                doc_freq = df.get(token, 0)
+                idf = math.log((n_docs - doc_freq + 0.5) / (doc_freq + 0.5) + 1)
+
+                # BM25 score component
+                numerator = tf * (k1 + 1)
+                denominator = tf + k1 * (1 - b + b * doc_len / avgdl)
+                score += idf * numerator / denominator
+
+            scores[i] = score
+
+        # Normalize to [0, 1]
+        max_score = scores.max()
+        if max_score > 0:
+            scores = scores / max_score
+
+        return scores
+
+    def _compute_name_scores(self, query_tokens: list[str]) -> np.ndarray:
+        """Compute name match scores using the name index."""
+        scores = np.zeros(len(self.blocks))
+
+        if not self.name_index or not query_tokens:
+            return scores
+
+        for token in query_tokens:
+            if token in self.name_index:
+                for block_idx, weight in self.name_index[token]:
+                    if block_idx < len(scores):
+                        scores[int(block_idx)] += weight
+
+        # Also check for partial matches in block names
+        for i, block in enumerate(self.blocks):
+            name_lower = block.get("name", "").lower()
+            for token in query_tokens:
+                if token in name_lower:
+                    scores[i] += 0.5
+
+        # Normalize to [0, 1]
+        max_score = scores.max()
+        if max_score > 0:
+            scores = scores / max_score
+
+        return scores
+
+    def _compute_category_scores(self, query_tokens: list[str]) -> np.ndarray:
+        """Compute category match scores."""
+        scores = np.zeros(len(self.blocks))
+
+        if not query_tokens:
+            return scores
+
+        for i, block in enumerate(self.blocks):
+            categories = block.get("categories", [])
+            category_text = " ".join(categories).lower()
+
+            for token in query_tokens:
+                if token in category_text:
+                    scores[i] += 1.0
+
+        # Normalize to [0, 1]
+        max_score = scores.max()
+        if max_score > 0:
+            scores = scores / max_score
+
+        return scores
+
+    def search(
+        self,
+        query: str,
+        top_k: int = 10,
+        weights: Optional[SearchWeights] = None,
+    ) -> list[BlockSearchResult]:
+        """
+        Perform hybrid search combining multiple signals.
+
+        Args:
+            query: Search query string
+            top_k: Number of results to return
+            weights: Optional custom weights for signals
+
+        Returns:
+            List of BlockSearchResult sorted by score
+        """
+        if not self._loaded and not self.load():
+            return []
+
+        if weights is None:
+            weights = SearchWeights()
+
+        # Tokenize query
+        query_tokens = tokenize(query)
+        if not query_tokens:
+            # Fallback: try raw query words
+            query_tokens = query.lower().split()
+
+        # Compute semantic scores
+        semantic_scores = np.zeros(len(self.blocks))
+        if self.normalized_embeddings is not None:
+            query_embedding = self._embed_query(query)
+            if query_embedding is not None:
+                semantic_scores = self._compute_semantic_scores(query_embedding)
+
+        # Compute other scores
+        bm25_scores = self._compute_bm25_scores(query_tokens)
+        name_scores = self._compute_name_scores(query_tokens)
+        category_scores = self._compute_category_scores(query_tokens)
+
+        # Combine scores using weights
+        combined_scores = (
+            weights.semantic * semantic_scores
+            + weights.bm25 * bm25_scores
+            + weights.name_match * name_scores
+            + weights.category_match * category_scores
+        )
+
+        # Get top-k indices
+        top_indices = np.argsort(combined_scores)[::-1][:top_k]
+
+        # Build results
+        results = []
+        for idx in top_indices:
+            if combined_scores[idx] <= 0:
+                continue
+
+            block = self.blocks[idx]
+            results.append(
+                BlockSearchResult(
+                    block_id=block["id"],
+                    name=block["name"],
+                    description=block["description"],
+                    categories=block.get("categories", []),
+                    score=float(combined_scores[idx]),
+                    semantic_score=float(semantic_scores[idx]),
+                    bm25_score=float(bm25_scores[idx]),
+                    name_score=float(name_scores[idx]),
+                    category_score=float(category_scores[idx]),
+                )
+            )
+
+        return results
+
+
+# Global index instance (lazy loaded)
+_block_search_index: Optional[BlockSearchIndex] = None
+
+
+def get_block_search_index() -> BlockSearchIndex:
+    """Get or create the block search index singleton."""
+    global _block_search_index
+    if _block_search_index is None:
+        _block_search_index = BlockSearchIndex(INDEX_PATH)
+    return _block_search_index

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

@@ -0,0 +1,386 @@
+"""Tool for searching platform documentation."""
+
+import json
+import logging
+import math
+import re
+from pathlib import Path
+from typing import Any
+
+from backend.api.features.chat.model import ChatSession
+
+from .base import BaseTool
+from .models import (
+    DocSearchResult,
+    DocSearchResultsResponse,
+    ErrorResponse,
+    NoResultsResponse,
+    ToolResponseBase,
+)
+
+logger = logging.getLogger(__name__)
+
+# Documentation base URL
+DOCS_BASE_URL = "https://docs.agpt.co/platform"
+
+# Path to the JSON index file (relative to this file)
+INDEX_PATH = Path(__file__).parent / "docs_index.json"
+
+
+def tokenize(text: str) -> list[str]:
+    """Simple tokenizer for BM25."""
+    text = text.lower()
+    # Remove code blocks
+    text = re.sub(r"```[\s\S]*?```", "", text)
+    text = re.sub(r"`[^`]+`", "", text)
+    # Extract words
+    words = re.findall(r"\b[a-z][a-z0-9_-]*\b", text)
+    # Remove very short words and stopwords
+    stopwords = {
+        "the",
+        "a",
+        "an",
+        "is",
+        "are",
+        "was",
+        "were",
+        "be",
+        "been",
+        "being",
+        "have",
+        "has",
+        "had",
+        "do",
+        "does",
+        "did",
+        "will",
+        "would",
+        "could",
+        "should",
+        "may",
+        "might",
+        "must",
+        "shall",
+        "can",
+        "need",
+        "dare",
+        "ought",
+        "used",
+        "to",
+        "of",
+        "in",
+        "for",
+        "on",
+        "with",
+        "at",
+        "by",
+        "from",
+        "as",
+        "into",
+        "through",
+        "during",
+        "before",
+        "after",
+        "above",
+        "below",
+        "between",
+        "under",
+        "again",
+        "further",
+        "then",
+        "once",
+        "and",
+        "but",
+        "or",
+        "nor",
+        "so",
+        "yet",
+        "both",
+        "either",
+        "neither",
+        "not",
+        "only",
+        "own",
+        "same",
+        "than",
+        "too",
+        "very",
+        "just",
+        "also",
+        "now",
+        "here",
+        "there",
+        "when",
+        "where",
+        "why",
+        "how",
+        "all",
+        "each",
+        "every",
+        "both",
+        "few",
+        "more",
+        "most",
+        "other",
+        "some",
+        "such",
+        "no",
+        "any",
+        "this",
+        "that",
+        "these",
+        "those",
+        "it",
+        "its",
+    }
+    return [w for w in words if len(w) > 2 and w not in stopwords]
+
+
+class DocSearchIndex:
+    """Lightweight documentation search index using BM25."""
+
+    def __init__(self, index_path: Path):
+        self.chunks: list[dict] = []
+        self.bm25_data: dict = {}
+        self._loaded = False
+        self._index_path = index_path
+
+    def load(self) -> bool:
+        """Load the index from JSON file."""
+        if self._loaded:
+            return True
+
+        if not self._index_path.exists():
+            logger.warning(f"Documentation index not found at {self._index_path}")
+            return False
+
+        try:
+            with open(self._index_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            self.chunks = data.get("chunks", [])
+            self.bm25_data = data.get("bm25", {})
+            self._loaded = True
+            logger.info(f"Loaded documentation index with {len(self.chunks)} chunks")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load documentation index: {e}")
+            return False
+
+    def search(self, query: str, top_k: int = 5) -> list[dict]:
+        """Search the index using BM25."""
+        if not self._loaded and not self.load():
+            return []
+
+        query_tokens = tokenize(query)
+        if not query_tokens:
+            return []
+
+        # BM25 parameters
+        k1 = 1.5
+        b = 0.75
+        n_docs = self.bm25_data.get("n_docs", len(self.chunks))
+        avgdl = self.bm25_data.get("avgdl", 100)
+        df = self.bm25_data.get("df", {})
+        doc_lens = self.bm25_data.get("doc_lens", [100] * len(self.chunks))
+
+        scores = []
+        for i, chunk in enumerate(self.chunks):
+            # Tokenize chunk text
+            chunk_tokens = tokenize(chunk.get("text", ""))
+            doc_len = doc_lens[i] if i < len(doc_lens) else len(chunk_tokens)
+
+            # Calculate BM25 score
+            score = 0.0
+            for token in query_tokens:
+                if token not in df:
+                    continue
+
+                # Term frequency in this document
+                tf = chunk_tokens.count(token)
+                if tf == 0:
+                    continue
+
+                # IDF
+                doc_freq = df.get(token, 0)
+                idf = math.log((n_docs - doc_freq + 0.5) / (doc_freq + 0.5) + 1)
+
+                # BM25 score component
+                numerator = tf * (k1 + 1)
+                denominator = tf + k1 * (1 - b + b * doc_len / avgdl)
+                score += idf * numerator / denominator
+
+            # Boost for title/heading matches
+            title = chunk.get("title", "").lower()
+            heading = chunk.get("heading", "").lower()
+            for token in query_tokens:
+                if token in title:
+                    score *= 1.5
+                if token in heading:
+                    score *= 1.2
+
+            scores.append((i, score))
+
+        # Sort by score and return top_k
+        scores.sort(key=lambda x: x[1], reverse=True)
+
+        results = []
+        seen_sections = set()
+        for idx, score in scores:
+            if score <= 0:
+                continue
+
+            chunk = self.chunks[idx]
+            section_key = (chunk.get("doc", ""), chunk.get("heading", ""))
+
+            # Deduplicate by section
+            if section_key in seen_sections:
+                continue
+            seen_sections.add(section_key)
+
+            results.append(
+                {
+                    "title": chunk.get("title", ""),
+                    "path": chunk.get("doc", ""),
+                    "heading": chunk.get("heading", ""),
+                    "text": chunk.get("text", ""),  # Full text for LLM comprehension
+                    "score": score,
+                }
+            )
+
+            if len(results) >= top_k:
+                break
+
+        return results
+
+
+# Global index instance (lazy loaded)
+_search_index: DocSearchIndex | None = None
+
+
+def get_search_index() -> DocSearchIndex:
+    """Get or create the search index singleton."""
+    global _search_index
+    if _search_index is None:
+        _search_index = DocSearchIndex(INDEX_PATH)
+    return _search_index
+
+
+class SearchDocsTool(BaseTool):
+    """Tool for searching AutoGPT platform documentation."""
+
+    @property
+    def name(self) -> str:
+        return "search_platform_docs"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Search the AutoGPT platform documentation and support Q&A for information about "
+            "how to use the platform, create agents, configure blocks, "
+            "set up integrations, troubleshoot issues, and more. Use this when users ask "
+            "support questions or want to learn how to do something with AutoGPT."
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": (
+                        "Search query describing what the user wants to learn about. "
+                        "Use keywords like 'blocks', 'agents', 'credentials', 'API', etc."
+                    ),
+                },
+            },
+            "required": ["query"],
+        }
+
+    async def _execute(
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        **kwargs,
+    ) -> ToolResponseBase:
+        """Search documentation for the query.
+
+        Args:
+            user_id: User ID (may be anonymous)
+            session: Chat session
+            query: Search query
+
+        Returns:
+            DocSearchResultsResponse: List of matching documentation sections
+            NoResultsResponse: No results found
+            ErrorResponse: Error message
+        """
+        query = kwargs.get("query", "").strip()
+        session_id = session.session_id
+
+        if not query:
+            return ErrorResponse(
+                message="Please provide a search query",
+                session_id=session_id,
+            )
+
+        try:
+            index = get_search_index()
+            results = index.search(query, top_k=5)
+
+            if not results:
+                return NoResultsResponse(
+                    message=f"No documentation found for '{query}'. Try different keywords.",
+                    session_id=session_id,
+                    suggestions=[
+                        "Try more general terms like 'blocks', 'agents', 'setup'",
+                        "Check the documentation at docs.agpt.co",
+                    ],
+                )
+
+            # Convert to response format
+            doc_results = []
+            for r in results:
+                # Build documentation URL
+                path = r["path"]
+                if path.endswith(".md"):
+                    path = path[:-3]  # Remove .md extension
+                doc_url = f"{DOCS_BASE_URL}/{path}"
+
+                full_text = r["text"]
+                doc_results.append(
+                    DocSearchResult(
+                        title=r["title"],
+                        path=r["path"],
+                        section=r["heading"],
+                        snippet=(
+                            full_text[:300] + "..."
+                            if len(full_text) > 300
+                            else full_text
+                        ),
+                        content=full_text,  # Full text for LLM to read and understand
+                        score=round(r["score"], 3),
+                        doc_url=doc_url,
+                    )
+                )
+
+            return DocSearchResultsResponse(
+                message=(
+                    f"Found {len(doc_results)} relevant documentation sections. "
+                    "Use these to help answer the user's question. "
+                    "Include links to the documentation when helpful."
+                ),
+                results=doc_results,
+                count=len(doc_results),
+                query=query,
+                session_id=session_id,
+            )
+
+        except Exception as e:
+            logger.error(f"Error searching documentation: {e}", exc_info=True)
+            return ErrorResponse(
+                message="Failed to search documentation. Please try again.",
+                error=str(e),
+                session_id=session_id,
+            )

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

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""
+CLI script to backfill embeddings for store agents.
+
+Usage:
+    poetry run python -m backend.server.v2.store.backfill_embeddings [--batch-size N]
+"""
+
+import argparse
+import asyncio
+import sys
+
+import prisma
+
+
+async def main(batch_size: int = 100) -> int:
+    """Run the backfill process."""
+    # Initialize Prisma client
+    client = prisma.Prisma()
+    await client.connect()
+    prisma.register(client)
+
+    try:
+        from backend.api.features.store.embeddings import (
+            backfill_missing_embeddings,
+            get_embedding_stats,
+        )
+
+        # Get current stats
+        print("Current embedding stats:")
+        stats = await get_embedding_stats()
+        print(f"  Total approved: {stats['total_approved']}")
+        print(f"  With embeddings: {stats['with_embeddings']}")
+        print(f"  Without embeddings: {stats['without_embeddings']}")
+        print(f"  Coverage: {stats['coverage_percent']}%")
+
+        if stats["without_embeddings"] == 0:
+            print("\nAll agents already have embeddings. Nothing to do.")
+            return 0
+
+        # Run backfill
+        print(f"\nBackfilling up to {batch_size} embeddings...")
+        result = await backfill_missing_embeddings(batch_size=batch_size)
+        print(f"  Processed: {result['processed']}")
+        print(f"  Success: {result['success']}")
+        print(f"  Failed: {result['failed']}")
+
+        # Get final stats
+        print("\nFinal embedding stats:")
+        stats = await get_embedding_stats()
+        print(f"  Total approved: {stats['total_approved']}")
+        print(f"  With embeddings: {stats['with_embeddings']}")
+        print(f"  Without embeddings: {stats['without_embeddings']}")
+        print(f"  Coverage: {stats['coverage_percent']}%")
+
+        return 0 if result["failed"] == 0 else 1
+
+    finally:
+        await client.disconnect()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Backfill embeddings for store agents")
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=100,
+        help="Number of embeddings to generate (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,6 +1,5 @@
 import asyncio
 import logging
-import typing
 from datetime import datetime, timezone
 from typing import Literal
 
@@ -10,7 +9,7 @@ import prisma.errors
 import prisma.models
 import prisma.types
 
-from backend.data.db import query_raw_with_schema, transaction
+from backend.data.db import transaction
 from backend.data.graph import (
     GraphMeta,
     GraphModel,
@@ -57,95 +56,21 @@ async def get_store_agents(
     )
 
     try:
-        # If search_query is provided, use full-text search
+        # If search_query is provided, use hybrid search (embeddings + tsvector)
         if search_query:
-            offset = (page - 1) * page_size
+            from backend.api.features.store.hybrid_search import hybrid_search
 
-            # 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",
-            }
+            # Use hybrid search combining semantic and lexical signals
+            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,
+            )
 
-            # 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
@@ -1564,6 +1489,24 @@ async def review_store_submission(
                     },
                 )
 
+            # Generate embedding for approved listing (non-blocking)
+            try:
+                from backend.api.features.store.embeddings import ensure_embedding
+
+                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 [],
+                )
+            except Exception as e:
+                # Don't fail approval if embedding generation fails
+                logger.warning(
+                    f"Failed to generate embedding for approved listing "
+                    f"{store_listing_version_id}: {e}"
+                )
+
         # If rejecting an approved agent, update the StoreListing accordingly
         if is_rejecting_approved:
             # Check if there are other approved versions

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

@@ -0,0 +1,408 @@
+"""
+Store Listing Embeddings Service
+
+Handles generation and storage of OpenAI embeddings for store listings
+to enable semantic/hybrid search.
+"""
+
+import hashlib
+import logging
+import os
+from typing import Any
+
+import prisma
+
+logger = logging.getLogger(__name__)
+
+# OpenAI embedding model configuration
+EMBEDDING_MODEL = "text-embedding-3-small"
+EMBEDDING_DIM = 1536
+
+
+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)
+
+
+def compute_content_hash(text: str) -> str:
+    """Compute MD5 hash of text for change detection."""
+    return hashlib.md5(text.encode()).hexdigest()
+
+
+async def generate_embedding(text: str) -> list[float] | None:
+    """
+    Generate embedding for text using OpenAI API.
+
+    Returns None if embedding generation fails.
+    """
+    try:
+        from openai import OpenAI
+
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            logger.warning("OPENAI_API_KEY not set, cannot generate embedding")
+            return None
+
+        client = OpenAI(api_key=api_key)
+
+        # Truncate text to avoid token limits (~32k chars for safety)
+        truncated_text = text[:32000]
+
+        response = client.embeddings.create(
+            model=EMBEDDING_MODEL,
+            input=truncated_text,
+        )
+
+        embedding = response.data[0].embedding
+        logger.debug(f"Generated embedding with {len(embedding)} dimensions")
+        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],
+    searchable_text: str,
+    content_hash: str,
+    tx: prisma.Prisma | None = None,
+) -> bool:
+    """
+    Store embedding in the database.
+
+    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 = "[" + ",".join(str(x) for x in embedding) + "]"
+
+        # Upsert the embedding
+        # Set search_path to include public for vector type visibility
+        await client.execute_raw(
+            """
+            SET LOCAL search_path TO platform, public;
+            INSERT INTO platform."StoreListingEmbedding" (
+                "id", "storeListingVersionId", "embedding",
+                "searchableText", "contentHash", "createdAt", "updatedAt"
+            )
+            VALUES (
+                gen_random_uuid(), $1, $2::vector,
+                $3, $4, NOW(), NOW()
+            )
+            ON CONFLICT ("storeListingVersionId")
+            DO UPDATE SET
+                "embedding" = $2::vector,
+                "searchableText" = $3,
+                "contentHash" = $4,
+                "updatedAt" = NOW()
+            """,
+            version_id,
+            embedding_str,
+            searchable_text,
+            content_hash,
+        )
+
+        logger.info(f"Stored embedding for version {version_id}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to store embedding for version {version_id}: {e}")
+        return False
+
+
+async def get_embedding(version_id: str) -> dict[str, Any] | None:
+    """
+    Retrieve embedding record for a listing version.
+
+    Returns dict with embedding, searchableText, contentHash or None if not found.
+    """
+    try:
+        client = prisma.get_client()
+
+        result = await client.query_raw(
+            """
+            SELECT
+                "id",
+                "storeListingVersionId",
+                "embedding"::text as "embedding",
+                "searchableText",
+                "contentHash",
+                "createdAt",
+                "updatedAt"
+            FROM platform."StoreListingEmbedding"
+            WHERE "storeListingVersionId" = $1
+            """,
+            version_id,
+        )
+
+        if result and len(result) > 0:
+            return result[0]
+        return None
+
+    except Exception as e:
+        logger.error(f"Failed to get embedding for version {version_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 or if content has changed.
+    Skips if content hash matches existing embedding.
+
+    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 hash matches
+        tx: Optional transaction client
+
+    Returns:
+        True if embedding exists/was created, False on failure
+    """
+    try:
+        # Build searchable text and compute hash
+        searchable_text = build_searchable_text(
+            name, description, sub_heading, categories
+        )
+        content_hash = compute_content_hash(searchable_text)
+
+        # Check if embedding already exists with same hash
+        if not force:
+            existing = await get_embedding(version_id)
+            if existing and existing.get("contentHash") == content_hash:
+                logger.debug(
+                    f"Embedding for version {version_id} is up to date (hash match)"
+                )
+                return True
+
+        # 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
+        return await store_embedding(
+            version_id=version_id,
+            embedding=embedding,
+            searchable_text=searchable_text,
+            content_hash=content_hash,
+            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.
+
+    Note: This is usually handled automatically by CASCADE delete,
+    but provided for manual cleanup if needed.
+    """
+    try:
+        client = prisma.get_client()
+
+        await client.execute_raw(
+            """
+            DELETE FROM platform."StoreListingEmbedding"
+            WHERE "storeListingVersionId" = $1
+            """,
+            version_id,
+        )
+
+        logger.info(f"Deleted embedding for version {version_id}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to delete embedding for version {version_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:
+        client = prisma.get_client()
+
+        # Count approved versions
+        approved_result = await client.query_raw(
+            """
+            SELECT COUNT(*) as count
+            FROM platform."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 client.query_raw(
+            """
+            SELECT COUNT(*) as count
+            FROM platform."StoreListingVersion" slv
+            JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
+            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:
+        client = prisma.get_client()
+
+        # Find approved versions without embeddings
+        missing = await client.query_raw(
+            """
+            SELECT
+                slv.id,
+                slv.name,
+                slv.description,
+                slv."subHeading",
+                slv.categories
+            FROM platform."StoreListingVersion" slv
+            LEFT JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
+            WHERE slv."submissionStatus" = 'APPROVED'
+            AND slv."isDeleted" = false
+            AND sle.id IS NULL
+            LIMIT $1
+            """,
+            batch_size,
+        )
+
+        if not missing:
+            return {
+                "processed": 0,
+                "success": 0,
+                "failed": 0,
+                "message": "No missing embeddings",
+            }
+
+        success = 0
+        failed = 0
+
+        for row in missing:
+            result = await ensure_embedding(
+                version_id=row["id"],
+                name=row["name"],
+                description=row["description"],
+                sub_heading=row["subHeading"],
+                categories=row["categories"] or [],
+            )
+            if result:
+                success += 1
+            else:
+                failed += 1
+
+        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) + "]"

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

@@ -0,0 +1,440 @@
+"""
+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
+
+import prisma
+
+from backend.api.features.store.embeddings import (
+    embed_query,
+    embedding_to_vector_string,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class HybridSearchWeights:
+    """Weights for combining search signals."""
+
+    semantic: float = 0.35  # Embedding cosine similarity
+    lexical: float = 0.35  # tsvector ts_rank_cd score
+    category: float = 0.20  # Category match boost
+    recency: float = 0.10  # Newer agents ranked higher
+
+
+DEFAULT_WEIGHTS = HybridSearchWeights()
+
+# Minimum relevance score threshold - agents below this are filtered out
+# With weights (0.35 semantic + 0.35 lexical + 0.20 category + 0.10 recency):
+# - 0.20 means at least ~50% semantic match OR strong lexical match required
+# - Ensures only genuinely relevant results are returned
+# - Recency alone (0.10 max) 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
+
+
+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.
+    """
+    if weights is None:
+        weights = DEFAULT_WEIGHTS
+    if min_score is None:
+        min_score = DEFAULT_MIN_SCORE
+
+    offset = (page - 1) * page_size
+    client = prisma.get_client()
+
+    # 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
+
+    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
+
+    where_clause = " AND ".join(where_parts)
+
+    # Determine if we can use hybrid search (have query embedding)
+    use_hybrid = query_embedding is not None
+
+    if use_hybrid:
+        # Add embedding parameter
+        embedding_str = embedding_to_vector_string(query_embedding)
+        params.append(embedding_str)
+        embedding_param = f"${param_index}"
+        param_index += 1
+
+        # Build hybrid search query with weighted scoring
+        # The semantic score is (1 - cosine_distance), normalized to [0,1]
+        # The lexical score is ts_rank_cd, normalized by max value
+        # Set search_path to include public for vector type visibility
+        sql_query = f"""
+            SET LOCAL search_path TO platform, public;
+            WITH search_scores AS (
+                SELECT
+                    sa.*,
+                    -- Semantic score: cosine similarity (1 - distance)
+                    COALESCE(1 - (sle.embedding <=> {embedding_param}::vector), 0) as semantic_score,
+                    -- Lexical score: ts_rank_cd normalized
+                    COALESCE(ts_rank_cd(sa.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
+                    -- Category match: 1 if query term appears in categories, else 0
+                    CASE
+                        WHEN EXISTS (
+                            SELECT 1 FROM unnest(sa.categories) cat
+                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
+                        ) THEN 1.0
+                        ELSE 0.0
+                    END as category_score,
+                    -- Recency score: exponential decay over 90 days
+                    EXP(-EXTRACT(EPOCH FROM (NOW() - sa.updated_at)) / (90 * 24 * 3600)) as recency_score
+                FROM platform."StoreAgent" sa
+                LEFT JOIN platform."StoreListing" sl ON sa.slug = sl.slug
+                LEFT JOIN platform."StoreListingVersion" slv ON sl."activeVersionId" = slv.id
+                LEFT JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
+                WHERE {where_clause}
+                AND (
+                    sa.search @@ plainto_tsquery('english', {query_param})
+                    OR sle.embedding IS NOT NULL
+                )
+            ),
+            normalized AS (
+                SELECT
+                    *,
+                    -- Normalize lexical score by max in result set
+                    CASE
+                        WHEN MAX(lexical_raw) OVER () > 0
+                        THEN lexical_raw / MAX(lexical_raw) OVER ()
+                        ELSE 0
+                    END as lexical_score
+                FROM search_scores
+            ),
+            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,
+                    (
+                        {weights.semantic} * semantic_score +
+                        {weights.lexical} * lexical_score +
+                        {weights.category} * category_score +
+                        {weights.recency} * recency_score
+                    ) as combined_score
+                FROM normalized
+            )
+            SELECT * FROM scored
+            WHERE combined_score >= {min_score}
+            ORDER BY combined_score DESC
+            LIMIT ${param_index} OFFSET ${param_index + 1}
+        """
+
+        # Add pagination params
+        params.extend([page_size, offset])
+
+        # Count query - must also filter by min_score
+        count_query = f"""
+            SET LOCAL search_path TO platform, public;
+            WITH search_scores AS (
+                SELECT
+                    sa.slug,
+                    COALESCE(1 - (sle.embedding <=> {embedding_param}::vector), 0) as semantic_score,
+                    COALESCE(ts_rank_cd(sa.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
+                    CASE
+                        WHEN EXISTS (
+                            SELECT 1 FROM unnest(sa.categories) cat
+                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
+                        ) THEN 1.0
+                        ELSE 0.0
+                    END as category_score,
+                    EXP(-EXTRACT(EPOCH FROM (NOW() - sa.updated_at)) / (90 * 24 * 3600)) as recency_score
+                FROM platform."StoreAgent" sa
+                LEFT JOIN platform."StoreListing" sl ON sa.slug = sl.slug
+                LEFT JOIN platform."StoreListingVersion" slv ON sl."activeVersionId" = slv.id
+                LEFT JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
+                WHERE {where_clause}
+                AND (
+                    sa.search @@ plainto_tsquery('english', {query_param})
+                    OR sle.embedding IS NOT NULL
+                )
+            ),
+            normalized AS (
+                SELECT
+                    slug,
+                    semantic_score,
+                    category_score,
+                    recency_score,
+                    CASE
+                        WHEN MAX(lexical_raw) OVER () > 0
+                        THEN lexical_raw / MAX(lexical_raw) OVER ()
+                        ELSE 0
+                    END as lexical_score
+                FROM search_scores
+            ),
+            scored AS (
+                SELECT
+                    slug,
+                    (
+                        {weights.semantic} * semantic_score +
+                        {weights.lexical} * lexical_score +
+                        {weights.category} * category_score +
+                        {weights.recency} * recency_score
+                    ) as combined_score
+                FROM normalized
+            )
+            SELECT COUNT(*) as count FROM scored
+            WHERE combined_score >= {min_score}
+        """
+
+    else:
+        # Fallback to lexical-only search (existing behavior)
+        # Note: For lexical-only, we still require tsvector match but don't
+        # apply min_score since ts_rank_cd isn't normalized to [0,1]
+        logger.warning("Falling back to lexical-only search (no query embedding)")
+
+        sql_query = f"""
+            WITH lexical_scores AS (
+                SELECT
+                    slug,
+                    agent_name,
+                    agent_image,
+                    creator_username,
+                    creator_avatar,
+                    sub_heading,
+                    description,
+                    runs,
+                    rating,
+                    categories,
+                    featured,
+                    is_available,
+                    updated_at,
+                    0.0 as semantic_score,
+                    ts_rank_cd(search, plainto_tsquery('english', {query_param})) as lexical_raw,
+                    CASE
+                        WHEN EXISTS (
+                            SELECT 1 FROM unnest(categories) cat
+                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
+                        ) THEN 1.0
+                        ELSE 0.0
+                    END as category_score,
+                    EXP(-EXTRACT(EPOCH FROM (NOW() - updated_at)) / (90 * 24 * 3600)) as recency_score
+                FROM platform."StoreAgent" sa
+                WHERE {where_clause}
+                AND search @@ plainto_tsquery('english', {query_param})
+            ),
+            normalized AS (
+                SELECT
+                    *,
+                    CASE
+                        WHEN MAX(lexical_raw) OVER () > 0
+                        THEN lexical_raw / MAX(lexical_raw) OVER ()
+                        ELSE 0
+                    END as lexical_score
+                FROM lexical_scores
+            ),
+            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,
+                    (
+                        {weights.lexical} * lexical_score +
+                        {weights.category} * category_score +
+                        {weights.recency} * recency_score
+                    ) as combined_score
+                FROM normalized
+            )
+            SELECT * FROM scored
+            WHERE combined_score >= {min_score}
+            ORDER BY combined_score DESC
+            LIMIT ${param_index} OFFSET ${param_index + 1}
+        """
+
+        params.extend([page_size, offset])
+
+        count_query = f"""
+            WITH lexical_scores AS (
+                SELECT
+                    slug,
+                    ts_rank_cd(search, plainto_tsquery('english', {query_param})) as lexical_raw,
+                    CASE
+                        WHEN EXISTS (
+                            SELECT 1 FROM unnest(categories) cat
+                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
+                        ) THEN 1.0
+                        ELSE 0.0
+                    END as category_score,
+                    EXP(-EXTRACT(EPOCH FROM (NOW() - updated_at)) / (90 * 24 * 3600)) as recency_score
+                FROM platform."StoreAgent" sa
+                WHERE {where_clause}
+                AND search @@ plainto_tsquery('english', {query_param})
+            ),
+            normalized AS (
+                SELECT
+                    slug,
+                    category_score,
+                    recency_score,
+                    CASE
+                        WHEN MAX(lexical_raw) OVER () > 0
+                        THEN lexical_raw / MAX(lexical_raw) OVER ()
+                        ELSE 0
+                    END as lexical_score
+                FROM lexical_scores
+            ),
+            scored AS (
+                SELECT
+                    slug,
+                    (
+                        {weights.lexical} * lexical_score +
+                        {weights.category} * category_score +
+                        {weights.recency} * recency_score
+                    ) as combined_score
+                FROM normalized
+            )
+            SELECT COUNT(*) as count FROM scored
+            WHERE combined_score >= {min_score}
+        """
+
+    try:
+        # Execute search query
+        # Dynamic SQL is safe here - all user inputs are parameterized ($1, $2, etc.)
+        results = await client.query_raw(sql_query, *params)  # type: ignore[arg-type]
+
+        # Execute count query (without pagination params)
+        count_params = params[:-2]  # Remove LIMIT and OFFSET params
+        count_result = await client.query_raw(count_query, *count_params)  # type: ignore[arg-type]
+        total = count_result[0]["count"] if count_result else 0
+
+        logger.info(
+            f"Hybrid search for '{query}': {len(results)} results, {total} total "
+            f"(hybrid={use_hybrid})"
+        )
+
+        return results, total
+
+    except Exception as e:
+        logger.error(f"Hybrid search failed: {e}")
+        raise
+
+
+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/util/settings.py

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

autogpt_platform/backend/migrations/20251216153446_add_chat_tables/migration.sql

@@ -1,6 +1,3 @@
--- DropIndex
-DROP INDEX "StoreListingVersion_storeListingId_version_key";
-
 -- CreateTable
 CREATE TABLE "UserBusinessUnderstanding" (
     "id" TEXT NOT NULL,

autogpt_platform/backend/migrations/20251216181700_add_store_embeddings/migration.sql

@@ -0,0 +1,41 @@
+-- Migration: Add pgvector extension and StoreListingEmbedding table
+-- This enables hybrid search combining semantic (embedding) and lexical (tsvector) search
+
+-- Enable pgvector extension for vector similarity search
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Create table to store embeddings for store listing versions
+CREATE TABLE "StoreListingEmbedding" (
+    "id" TEXT NOT NULL DEFAULT gen_random_uuid(),
+    "storeListingVersionId" TEXT NOT NULL,
+    "embedding" vector(1536),  -- OpenAI text-embedding-3-small produces 1536 dimensions
+    "searchableText" TEXT,     -- The text that was embedded (for debugging/recomputation)
+    "contentHash" TEXT,        -- MD5 hash of searchable text for change detection
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "StoreListingEmbedding_pkey" PRIMARY KEY ("id")
+);
+
+-- Unique constraint: one embedding per listing version
+CREATE UNIQUE INDEX "StoreListingEmbedding_storeListingVersionId_key"
+    ON "StoreListingEmbedding"("storeListingVersionId");
+
+-- HNSW index for fast approximate nearest neighbor search
+-- Using cosine distance (vector_cosine_ops) which is standard for text embeddings
+CREATE INDEX "StoreListingEmbedding_embedding_idx"
+    ON "StoreListingEmbedding"
+    USING hnsw ("embedding" vector_cosine_ops);
+
+-- Index on content hash for fast lookup during change detection
+CREATE INDEX "StoreListingEmbedding_contentHash_idx"
+    ON "StoreListingEmbedding"("contentHash");
+
+-- Foreign key to StoreListingVersion with CASCADE delete
+-- When a listing version is deleted, its embedding is automatically removed
+ALTER TABLE "StoreListingEmbedding"
+    ADD CONSTRAINT "StoreListingEmbedding_storeListingVersionId_fkey"
+    FOREIGN KEY ("storeListingVersionId")
+    REFERENCES "StoreListingVersion"("id")
+    ON DELETE CASCADE
+    ON UPDATE CASCADE;

autogpt_platform/backend/migrations/20251216181803_enhance_search/migration.sql

@@ -0,0 +1,5 @@
+-- DropIndex
+DROP INDEX "StoreListingEmbedding_embedding_idx";
+
+-- AlterTable
+ALTER TABLE "StoreListingEmbedding" ALTER COLUMN "id" DROP DEFAULT;

autogpt_platform/backend/poetry.lock

@@ -2777,6 +2777,33 @@ enabler = ["pytest-enabler (>=2.2)"]
 test = ["pyfakefs", "pytest (>=6,!=8.1.*)"]
 type = ["pygobject-stubs", "pytest-mypy", "shtab", "types-pywin32"]
 
+[[package]]
+name = "langfuse"
+version = "2.60.10"
+description = "A client library for accessing langfuse"
+optional = false
+python-versions = "<4.0,>=3.9"
+groups = ["main"]
+files = [
+    {file = "langfuse-2.60.10-py3-none-any.whl", hash = "sha256:815c6369194aa5b2a24f88eb9952f7c3fc863272c41e90642a71f3bc76f4a11f"},
+    {file = "langfuse-2.60.10.tar.gz", hash = "sha256:a26d0d927a28ee01b2d12bb5b862590b643cc4e60a28de6e2b0c2cfff5dbfc6a"},
+]
+
+[package.dependencies]
+anyio = ">=4.4.0,<5.0.0"
+backoff = ">=1.10.0"
+httpx = ">=0.15.4,<1.0"
+idna = ">=3.7,<4.0"
+packaging = ">=23.2,<25.0"
+pydantic = ">=1.10.7,<3.0"
+requests = ">=2,<3"
+wrapt = ">=1.14,<2.0"
+
+[package.extras]
+langchain = ["langchain (>=0.0.309)"]
+llama-index = ["llama-index (>=0.10.12,<2.0.0)"]
+openai = ["openai (>=0.27.8)"]
+
 [[package]]
 name = "launchdarkly-eventsource"
 version = "1.3.0"
@@ -6922,6 +6949,97 @@ files = [
     {file = "websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee"},
 ]
 
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+description = "Module for decorators, wrappers and monkey patching."
+optional = false
+python-versions = ">=3.8"
+groups = ["main"]
+files = [
+    {file = "wrapt-1.17.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88bbae4d40d5a46142e70d58bf664a89b6b4befaea7b2ecc14e03cedb8e06c04"},
+    {file = "wrapt-1.17.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b13af258d6a9ad602d57d889f83b9d5543acd471eee12eb51f5b01f8eb1bc2"},
+    {file = "wrapt-1.17.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd341868a4b6714a5962c1af0bd44f7c404ef78720c7de4892901e540417111c"},
+    {file = "wrapt-1.17.3-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f9b2601381be482f70e5d1051a5965c25fb3625455a2bf520b5a077b22afb775"},
+    {file = "wrapt-1.17.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:343e44b2a8e60e06a7e0d29c1671a0d9951f59174f3709962b5143f60a2a98bd"},
+    {file = "wrapt-1.17.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:33486899acd2d7d3066156b03465b949da3fd41a5da6e394ec49d271baefcf05"},
+    {file = "wrapt-1.17.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e6f40a8aa5a92f150bdb3e1c44b7e98fb7113955b2e5394122fa5532fec4b418"},
+    {file = "wrapt-1.17.3-cp310-cp310-win32.whl", hash = "sha256:a36692b8491d30a8c75f1dfee65bef119d6f39ea84ee04d9f9311f83c5ad9390"},
+    {file = "wrapt-1.17.3-cp310-cp310-win_amd64.whl", hash = "sha256:afd964fd43b10c12213574db492cb8f73b2f0826c8df07a68288f8f19af2ebe6"},
+    {file = "wrapt-1.17.3-cp310-cp310-win_arm64.whl", hash = "sha256:af338aa93554be859173c39c85243970dc6a289fa907402289eeae7543e1ae18"},
+    {file = "wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7"},
+    {file = "wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85"},
+    {file = "wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f"},
+    {file = "wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311"},
+    {file = "wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1"},
+    {file = "wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5"},
+    {file = "wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2"},
+    {file = "wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89"},
+    {file = "wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77"},
+    {file = "wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a"},
+    {file = "wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0"},
+    {file = "wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba"},
+    {file = "wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd"},
+    {file = "wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828"},
+    {file = "wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9"},
+    {file = "wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396"},
+    {file = "wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc"},
+    {file = "wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe"},
+    {file = "wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c"},
+    {file = "wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6"},
+    {file = "wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0"},
+    {file = "wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77"},
+    {file = "wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7"},
+    {file = "wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277"},
+    {file = "wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d"},
+    {file = "wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa"},
+    {file = "wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050"},
+    {file = "wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8"},
+    {file = "wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb"},
+    {file = "wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16"},
+    {file = "wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39"},
+    {file = "wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235"},
+    {file = "wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c"},
+    {file = "wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b"},
+    {file = "wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa"},
+    {file = "wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7"},
+    {file = "wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4"},
+    {file = "wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10"},
+    {file = "wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6"},
+    {file = "wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58"},
+    {file = "wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a"},
+    {file = "wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067"},
+    {file = "wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454"},
+    {file = "wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e"},
+    {file = "wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f"},
+    {file = "wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056"},
+    {file = "wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804"},
+    {file = "wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977"},
+    {file = "wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116"},
+    {file = "wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6"},
+    {file = "wrapt-1.17.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:70d86fa5197b8947a2fa70260b48e400bf2ccacdcab97bb7de47e3d1e6312225"},
+    {file = "wrapt-1.17.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:df7d30371a2accfe4013e90445f6388c570f103d61019b6b7c57e0265250072a"},
+    {file = "wrapt-1.17.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:caea3e9c79d5f0d2c6d9ab96111601797ea5da8e6d0723f77eabb0d4068d2b2f"},
+    {file = "wrapt-1.17.3-cp38-cp38-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:758895b01d546812d1f42204bd443b8c433c44d090248bf22689df673ccafe00"},
+    {file = "wrapt-1.17.3-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02b551d101f31694fc785e58e0720ef7d9a10c4e62c1c9358ce6f63f23e30a56"},
+    {file = "wrapt-1.17.3-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:656873859b3b50eeebe6db8b1455e99d90c26ab058db8e427046dbc35c3140a5"},
+    {file = "wrapt-1.17.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:a9a2203361a6e6404f80b99234fe7fb37d1fc73487b5a78dc1aa5b97201e0f22"},
+    {file = "wrapt-1.17.3-cp38-cp38-win32.whl", hash = "sha256:55cbbc356c2842f39bcc553cf695932e8b30e30e797f961860afb308e6b1bb7c"},
+    {file = "wrapt-1.17.3-cp38-cp38-win_amd64.whl", hash = "sha256:ad85e269fe54d506b240d2d7b9f5f2057c2aa9a2ea5b32c66f8902f768117ed2"},
+    {file = "wrapt-1.17.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:30ce38e66630599e1193798285706903110d4f057aab3168a34b7fdc85569afc"},
+    {file = "wrapt-1.17.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:65d1d00fbfb3ea5f20add88bbc0f815150dbbde3b026e6c24759466c8b5a9ef9"},
+    {file = "wrapt-1.17.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a7c06742645f914f26c7f1fa47b8bc4c91d222f76ee20116c43d5ef0912bba2d"},
+    {file = "wrapt-1.17.3-cp39-cp39-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7e18f01b0c3e4a07fe6dfdb00e29049ba17eadbc5e7609a2a3a4af83ab7d710a"},
+    {file = "wrapt-1.17.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f5f51a6466667a5a356e6381d362d259125b57f059103dd9fdc8c0cf1d14139"},
+    {file = "wrapt-1.17.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:59923aa12d0157f6b82d686c3fd8e1166fa8cdfb3e17b42ce3b6147ff81528df"},
+    {file = "wrapt-1.17.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:46acc57b331e0b3bcb3e1ca3b421d65637915cfcd65eb783cb2f78a511193f9b"},
+    {file = "wrapt-1.17.3-cp39-cp39-win32.whl", hash = "sha256:3e62d15d3cfa26e3d0788094de7b64efa75f3a53875cdbccdf78547aed547a81"},
+    {file = "wrapt-1.17.3-cp39-cp39-win_amd64.whl", hash = "sha256:1f23fa283f51c890eda8e34e4937079114c74b4c81d2b2f1f1d94948f5cc3d7f"},
+    {file = "wrapt-1.17.3-cp39-cp39-win_arm64.whl", hash = "sha256:24c2ed34dc222ed754247a2702b1e1e89fdbaa4016f324b4b8f1a802d4ffe87f"},
+    {file = "wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22"},
+    {file = "wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0"},
+]
+
 [[package]]
 name = "xattr"
 version = "1.2.0"
@@ -7295,4 +7413,4 @@ cffi = ["cffi (>=1.11)"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<3.14"
-content-hash = "a93ba0cea3b465cb6ec3e3f258b383b09f84ea352ccfdbfa112902cde5653fc6"
+content-hash = "e5a35435ea318a13aa53df4124a4151bc8a3dd7dfc8f9738e3da24d7906d555e"

autogpt_platform/backend/pyproject.toml

@@ -33,6 +33,7 @@ html2text = "^2024.2.26"
 jinja2 = "^3.1.6"
 jsonref = "^1.1.0"
 jsonschema = "^4.25.0"
+langfuse = "^2.0.0"
 launchdarkly-server-sdk = "^9.12.0"
 mem0ai = "^0.1.115"
 moviepy = "^2.1.2"

autogpt_platform/backend/schema.prisma

@@ -1,14 +1,15 @@
 datasource db {
-  provider  = "postgresql"
-  url       = env("DATABASE_URL")
-  directUrl = env("DIRECT_URL")
+  provider   = "postgresql"
+  url        = env("DATABASE_URL")
+  directUrl  = env("DIRECT_URL")
+  extensions = [pgvector(map: "vector", schema: "public")]
 }
 
 generator client {
   provider               = "prisma-client-py"
   recursive_type_depth   = -1
   interface              = "asyncio"
-  previewFeatures        = ["views", "fullTextSearch"]
+  previewFeatures        = ["views", "fullTextSearch", "postgresqlExtensions"]
   partial_type_generator = "backend/data/partial_types.py"
 }
 
@@ -990,6 +991,10 @@ model StoreListingVersion {
   // Reviews for this specific version
   Reviews StoreListingReview[]
 
+  // Embedding for semantic search (one-to-one)
+  Embedding StoreListingEmbedding?
+
+  @@unique([storeListingId, version])
   @@index([storeListingId, submissionStatus, isAvailable])
   @@index([submissionStatus])
   @@index([reviewerId])
@@ -1014,6 +1019,24 @@ model StoreListingReview {
   @@index([reviewByUserId])
 }
 
+// Stores vector embeddings for semantic search of store listings
+// Uses pgvector extension for efficient similarity search
+model StoreListingEmbedding {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
+
+  storeListingVersionId String              @unique
+  StoreListingVersion   StoreListingVersion @relation(fields: [storeListingVersionId], references: [id], onDelete: Cascade)
+
+  // pgvector embedding - stored as Unsupported type since Prisma doesn't natively support vector
+  embedding      Unsupported("vector(1536)")?
+  searchableText String? // The text that was embedded (for debugging/recomputation)
+  contentHash    String? // MD5 hash for change detection
+
+  @@index([contentHash])
+}
+
 enum SubmissionStatus {
   DRAFT // Being prepared, not yet submitted
   PENDING // Submitted, awaiting review

autogpt_platform/frontend/package.json

@@ -54,7 +54,7 @@
     "@radix-ui/react-tooltip": "1.2.8",
     "@rjsf/core": "6.1.2",
     "@rjsf/utils": "6.1.2",
-    "@rjsf/validator-ajv8": "6.1.2",
+    "@rjsf/validator-ajv8": "5.24.13",
     "@sentry/nextjs": "10.27.0",
     "@supabase/ssr": "0.7.0",
     "@supabase/supabase-js": "2.78.0",

autogpt_platform/frontend/src/app/(no-navbar)/onboarding/5-run/components/AgentOnboardingCredentials/AgentOnboardingCredentials.tsx

@@ -1,6 +1,6 @@
-import { CredentialsInput } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs";
 import { CredentialsMetaInput } from "@/app/api/__generated__/models/credentialsMetaInput";
 import { GraphMeta } from "@/app/api/__generated__/models/graphMeta";
+import { CredentialsInput } from "@/components/contextual/CredentialsInputs/CredentialsInputs";
 import { useState } from "react";
 import { getSchemaDefaultCredentials } from "../../helpers";
 import { areAllCredentialsSet, getCredentialFields } from "./helpers";

autogpt_platform/frontend/src/app/(no-navbar)/onboarding/5-run/page.tsx

@@ -1,12 +1,12 @@
 "use client";
 
-import { RunAgentInputs } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentInputs/RunAgentInputs";
 import {
   Card,
   CardContent,
   CardHeader,
   CardTitle,
 } from "@/components/__legacy__/ui/card";
+import { RunAgentInputs } from "@/components/contextual/RunAgentInputs/RunAgentInputs";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
 import { CircleNotchIcon } from "@phosphor-icons/react/dist/ssr";
 import { Play } from "lucide-react";

autogpt_platform/frontend/src/app/(platform)/PlatformLayoutContent.tsx

@@ -0,0 +1,48 @@
+"use client";
+
+import { ChatDrawer } from "@/components/contextual/Chat/ChatDrawer";
+import { usePathname } from "next/navigation";
+import { Children, ReactNode } from "react";
+
+interface PlatformLayoutContentProps {
+  children: ReactNode;
+}
+
+export function PlatformLayoutContent({
+  children,
+}: PlatformLayoutContentProps) {
+  const pathname = usePathname();
+  const isAuthPage =
+    pathname?.includes("/login") || pathname?.includes("/signup");
+
+  // Extract Navbar, AdminImpersonationBanner, and page content from children
+  const childrenArray = Children.toArray(children);
+  const navbar = childrenArray[0];
+  const adminBanner = childrenArray[1];
+  const pageContent = childrenArray.slice(2);
+
+  // For login/signup pages, use a simpler layout that doesn't interfere with centering
+  if (isAuthPage) {
+    return (
+      <main className="flex min-h-screen w-full flex-col">
+        {navbar}
+        {adminBanner}
+        <section className="flex-1">{pageContent}</section>
+        {/* ChatDrawer must always be rendered to maintain consistent hook count */}
+        <ChatDrawer />
+      </main>
+    );
+  }
+
+  // For logged-in pages, use the drawer layout
+  return (
+    <main className="flex h-screen w-full flex-col overflow-hidden">
+      {navbar}
+      {adminBanner}
+      <section className="flex min-h-0 flex-1 overflow-auto">
+        {pageContent}
+      </section>
+      <ChatDrawer />
+    </main>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/auth/integrations/setup-wizard/page.tsx

@@ -8,7 +8,7 @@ import { AuthCard } from "@/components/auth/AuthCard";
 import { Text } from "@/components/atoms/Text/Text";
 import { Button } from "@/components/atoms/Button/Button";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
-import { CredentialsInput } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs";
+import { CredentialsInput } from "@/components/contextual/CredentialsInputs/CredentialsInputs";
 import type {
   BlockIOCredentialsSubSchema,
   CredentialsMetaInput,

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

@@ -1,11 +1,6 @@
 import { BlockUIType } from "@/app/(platform)/build/components/types";
 import { useGraphStore } from "@/app/(platform)/build/stores/graphStore";
 import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
-import {
-  globalRegistry,
-  OutputActions,
-  OutputItem,
-} from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
 import { Label } from "@/components/__legacy__/ui/label";
 import { ScrollArea } from "@/components/__legacy__/ui/scroll-area";
 import {
@@ -23,6 +18,11 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from "@/components/atoms/Tooltip/BaseTooltip";
+import {
+  globalRegistry,
+  OutputActions,
+  OutputItem,
+} from "@/components/contextual/OutputRenderers";
 import { BookOpenIcon } from "@phosphor-icons/react";
 import { useMemo } from "react";
 import { useShallow } from "zustand/react/shallow";

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

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

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

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

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

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

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

@@ -1,24 +1,25 @@
-import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
 import { Text } from "@/components/atoms/Text/Text";
+import { beautifyString, cn } from "@/lib/utils";
+import { NodeCost } from "./NodeCost";
+import { NodeBadges } from "./NodeBadges";
+import { NodeContextMenu } from "./NodeContextMenu";
+import { CustomNodeData } from "../CustomNode";
+import { useNodeStore } from "@/app/(platform)/build/stores/nodeStore";
+import { useState } from "react";
 import {
   Tooltip,
   TooltipContent,
   TooltipProvider,
   TooltipTrigger,
 } from "@/components/atoms/Tooltip/BaseTooltip";
-import { beautifyString, cn } from "@/lib/utils";
-import { useState } from "react";
-import { CustomNodeData } from "../CustomNode";
-import { NodeBadges } from "./NodeBadges";
-import { NodeContextMenu } from "./NodeContextMenu";
-import { NodeCost } from "./NodeCost";
 
-type Props = {
+export const NodeHeader = ({
+  data,
+  nodeId,
+}: {
   data: CustomNodeData;
   nodeId: string;
-};
-
-export const NodeHeader = ({ data, nodeId }: Props) => {
+}) => {
   const updateNodeData = useNodeStore((state) => state.updateNodeData);
   const title = (data.metadata?.customized_name as string) || data.title;
   const [isEditingTitle, setIsEditingTitle] = useState(false);

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

@@ -1,7 +1,7 @@
 "use client";
 
-import type { OutputMetadata } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
-import { globalRegistry } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
+import type { OutputMetadata } from "@/components/contextual/OutputRenderers";
+import { globalRegistry } from "@/components/contextual/OutputRenderers";
 
 export const TextRenderer: React.FC<{
   value: any;

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

@@ -1,7 +1,3 @@
-import {
-  OutputActions,
-  OutputItem,
-} from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
 import { ScrollArea } from "@/components/__legacy__/ui/scroll-area";
 import { Button } from "@/components/atoms/Button/Button";
 import { Text } from "@/components/atoms/Text/Text";
@@ -11,6 +7,10 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from "@/components/atoms/Tooltip/BaseTooltip";
+import {
+  OutputActions,
+  OutputItem,
+} from "@/components/contextual/OutputRenderers";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { beautifyString } from "@/lib/utils";
 import {

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

@@ -1,6 +1,6 @@
-import type { OutputMetadata } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
-import { globalRegistry } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
-import { downloadOutputs } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers/utils/download";
+import type { OutputMetadata } from "@/components/contextual/OutputRenderers";
+import { globalRegistry } from "@/components/contextual/OutputRenderers";
+import { downloadOutputs } from "@/components/contextual/OutputRenderers/utils/download";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { beautifyString } from "@/lib/utils";
 import React, { useMemo, useState } from "react";

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

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

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

@@ -1,10 +1,10 @@
-import { Alert, AlertDescription } from "@/components/molecules/Alert/Alert";
-import { Text } from "@/components/atoms/Text/Text";
-import Link from "next/link";
 import { useGetV2GetLibraryAgentByGraphId } from "@/app/api/__generated__/endpoints/library/library";
 import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
-import { useQueryStates, parseAsString } from "nuqs";
-import { isValidUUID } from "@/app/(platform)/chat/helpers";
+import { Text } from "@/components/atoms/Text/Text";
+import { isValidUUID } from "@/components/contextual/Chat/helpers";
+import { Alert, AlertDescription } from "@/components/molecules/Alert/Alert";
+import Link from "next/link";
+import { parseAsString, useQueryStates } from "nuqs";
 
 export const WebhookDisclaimer = ({ nodeId }: { nodeId: string }) => {
   const [{ flowID }] = useQueryStates({

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

autogpt_platform/frontend/src/app/(platform)/build/components/legacy-builder/ExpandableOutputDialog.tsx

@@ -1,9 +1,9 @@
-import type { OutputMetadata } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
+import type { OutputMetadata } from "@/components/contextual/OutputRenderers";
 import {
   globalRegistry,
   OutputActions,
   OutputItem,
-} from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
+} from "@/components/contextual/OutputRenderers";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { beautifyString } from "@/lib/utils";
 import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";

autogpt_platform/frontend/src/app/(platform)/build/components/legacy-builder/NodeInputs.tsx

@@ -3,7 +3,6 @@ import {
   CustomNodeData,
 } from "@/app/(platform)/build/components/legacy-builder/CustomNode/CustomNode";
 import { NodeTableInput } from "@/app/(platform)/build/components/legacy-builder/NodeTableInput";
-import { CredentialsInput } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs";
 import { Button } from "@/components/__legacy__/ui/button";
 import { Calendar } from "@/components/__legacy__/ui/calendar";
 import { LocalValuedInput } from "@/components/__legacy__/ui/input";
@@ -28,6 +27,7 @@ import {
   SelectValue,
 } from "@/components/__legacy__/ui/select";
 import { Switch } from "@/components/atoms/Switch/Switch";
+import { CredentialsInput } from "@/components/contextual/CredentialsInputs/CredentialsInputs";
 import { GoogleDrivePickerInput } from "@/components/contextual/GoogleDrivePicker/GoogleDrivePickerInput";
 import {
   BlockIOArraySubSchema,

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

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

autogpt_platform/frontend/src/app/(platform)/chat/components/ChatContainer/useChatContainer.ts

@@ -1,130 +0,0 @@
-import { useState, useCallback, useRef, useMemo } from "react";
-import { toast } from "sonner";
-import { useChatStream } from "@/app/(platform)/chat/useChatStream";
-import type { SessionDetailResponse } from "@/app/api/__generated__/models/sessionDetailResponse";
-import type { ChatMessageData } from "@/app/(platform)/chat/components/ChatMessage/useChatMessage";
-import {
-  parseToolResponse,
-  isValidMessage,
-  isToolCallArray,
-  createUserMessage,
-  filterAuthMessages,
-} from "./helpers";
-import { createStreamEventDispatcher } from "./createStreamEventDispatcher";
-
-interface UseChatContainerArgs {
-  sessionId: string | null;
-  initialMessages: SessionDetailResponse["messages"];
-  onRefreshSession: () => Promise<void>;
-}
-
-export function useChatContainer({
-  sessionId,
-  initialMessages,
-}: UseChatContainerArgs) {
-  const [messages, setMessages] = useState<ChatMessageData[]>([]);
-  const [streamingChunks, setStreamingChunks] = useState<string[]>([]);
-  const [hasTextChunks, setHasTextChunks] = useState(false);
-  const streamingChunksRef = useRef<string[]>([]);
-  const { error, sendMessage: sendStreamMessage } = useChatStream();
-  const isStreaming = hasTextChunks;
-
-  const allMessages = useMemo(() => {
-    const processedInitialMessages = initialMessages
-      .filter((msg: Record<string, unknown>) => {
-        if (!isValidMessage(msg)) {
-          console.warn("Invalid message structure from backend:", msg);
-          return false;
-        }
-        const content = String(msg.content || "").trim();
-        const toolCalls = msg.tool_calls;
-        return (
-          content.length > 0 ||
-          (toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0)
-        );
-      })
-      .map((msg: Record<string, unknown>) => {
-        const content = String(msg.content || "");
-        const role = String(msg.role || "assistant").toLowerCase();
-        const toolCalls = msg.tool_calls;
-        if (
-          role === "assistant" &&
-          toolCalls &&
-          isToolCallArray(toolCalls) &&
-          toolCalls.length > 0
-        ) {
-          return null;
-        }
-        if (role === "tool") {
-          const timestamp = msg.timestamp
-            ? new Date(msg.timestamp as string)
-            : undefined;
-          const toolResponse = parseToolResponse(
-            content,
-            (msg.tool_call_id as string) || "",
-            "unknown",
-            timestamp,
-          );
-          if (!toolResponse) {
-            return null;
-          }
-          return toolResponse;
-        }
-        return {
-          type: "message",
-          role: role as "user" | "assistant" | "system",
-          content,
-          timestamp: msg.timestamp
-            ? new Date(msg.timestamp as string)
-            : undefined,
-        };
-      })
-      .filter((msg): msg is ChatMessageData => msg !== null);
-
-    return [...processedInitialMessages, ...messages];
-  }, [initialMessages, messages]);
-
-  const sendMessage = useCallback(
-    async function sendMessage(content: string, isUserMessage: boolean = true) {
-      if (!sessionId) {
-        console.error("Cannot send message: no session ID");
-        return;
-      }
-      if (isUserMessage) {
-        const userMessage = createUserMessage(content);
-        setMessages((prev) => [...filterAuthMessages(prev), userMessage]);
-      } else {
-        setMessages((prev) => filterAuthMessages(prev));
-      }
-      setStreamingChunks([]);
-      streamingChunksRef.current = [];
-      setHasTextChunks(false);
-      const dispatcher = createStreamEventDispatcher({
-        setHasTextChunks,
-        setStreamingChunks,
-        streamingChunksRef,
-        setMessages,
-        sessionId,
-      });
-      try {
-        await sendStreamMessage(sessionId, content, dispatcher, isUserMessage);
-      } catch (err) {
-        console.error("Failed to send message:", err);
-        const errorMessage =
-          err instanceof Error ? err.message : "Failed to send message";
-        toast.error("Failed to send message", {
-          description: errorMessage,
-        });
-      }
-    },
-    [sessionId, sendStreamMessage],
-  );
-
-  return {
-    messages: allMessages,
-    streamingChunks,
-    isStreaming,
-    error,
-    sendMessage,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/ChatCredentialsSetup/ChatCredentialsSetup.tsx

@@ -1,153 +0,0 @@
-import { CredentialsInput } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs";
-import { Card } from "@/components/atoms/Card/Card";
-import { Text } from "@/components/atoms/Text/Text";
-import type { BlockIOCredentialsSubSchema } from "@/lib/autogpt-server-api";
-import { cn } from "@/lib/utils";
-import { CheckIcon, KeyIcon, WarningIcon } from "@phosphor-icons/react";
-import { useEffect, useRef } from "react";
-import { useChatCredentialsSetup } from "./useChatCredentialsSetup";
-
-export interface CredentialInfo {
-  provider: string;
-  providerName: string;
-  credentialType: "api_key" | "oauth2" | "user_password" | "host_scoped";
-  title: string;
-  scopes?: string[];
-}
-
-interface Props {
-  credentials: CredentialInfo[];
-  agentName?: string;
-  message: string;
-  onAllCredentialsComplete: () => void;
-  onCancel: () => void;
-  className?: string;
-}
-
-function createSchemaFromCredentialInfo(
-  credential: CredentialInfo,
-): BlockIOCredentialsSubSchema {
-  return {
-    type: "object",
-    properties: {},
-    credentials_provider: [credential.provider],
-    credentials_types: [credential.credentialType],
-    credentials_scopes: credential.scopes,
-    discriminator: undefined,
-    discriminator_mapping: undefined,
-    discriminator_values: undefined,
-  };
-}
-
-export function ChatCredentialsSetup({
-  credentials,
-  agentName: _agentName,
-  message,
-  onAllCredentialsComplete,
-  onCancel: _onCancel,
-  className,
-}: Props) {
-  const { selectedCredentials, isAllComplete, handleCredentialSelect } =
-    useChatCredentialsSetup(credentials);
-
-  // Track if we've already called completion to prevent double calls
-  const hasCalledCompleteRef = useRef(false);
-
-  // Reset the completion flag when credentials change (new credential setup flow)
-  useEffect(
-    function resetCompletionFlag() {
-      hasCalledCompleteRef.current = false;
-    },
-    [credentials],
-  );
-
-  // Auto-call completion when all credentials are configured
-  useEffect(
-    function autoCompleteWhenReady() {
-      if (isAllComplete && !hasCalledCompleteRef.current) {
-        hasCalledCompleteRef.current = true;
-        onAllCredentialsComplete();
-      }
-    },
-    [isAllComplete, onAllCredentialsComplete],
-  );
-
-  return (
-    <Card
-      className={cn(
-        "mx-4 my-2 overflow-hidden border-orange-200 bg-orange-50 dark:border-orange-900 dark:bg-orange-950",
-        className,
-      )}
-    >
-      <div className="flex items-start gap-4 p-6">
-        <div className="flex h-12 w-12 flex-shrink-0 items-center justify-center rounded-full bg-orange-500">
-          <KeyIcon size={24} weight="bold" className="text-white" />
-        </div>
-        <div className="flex-1">
-          <Text
-            variant="h3"
-            className="mb-2 text-orange-900 dark:text-orange-100"
-          >
-            Credentials Required
-          </Text>
-          <Text
-            variant="body"
-            className="mb-4 text-orange-700 dark:text-orange-300"
-          >
-            {message}
-          </Text>
-
-          <div className="space-y-3">
-            {credentials.map((cred, index) => {
-              const schema = createSchemaFromCredentialInfo(cred);
-              const isSelected = !!selectedCredentials[cred.provider];
-
-              return (
-                <div
-                  key={`${cred.provider}-${index}`}
-                  className={cn(
-                    "relative rounded-lg border border-orange-200 bg-white p-4 dark:border-orange-800 dark:bg-orange-900/20",
-                    isSelected &&
-                      "border-green-500 bg-green-50 dark:border-green-700 dark:bg-green-950/30",
-                  )}
-                >
-                  <div className="mb-2 flex items-center justify-between">
-                    <div className="flex items-center gap-2">
-                      {isSelected ? (
-                        <CheckIcon
-                          size={20}
-                          className="text-green-500"
-                          weight="bold"
-                        />
-                      ) : (
-                        <WarningIcon
-                          size={20}
-                          className="text-orange-500"
-                          weight="bold"
-                        />
-                      )}
-                      <Text
-                        variant="body"
-                        className="font-semibold text-orange-900 dark:text-orange-100"
-                      >
-                        {cred.providerName}
-                      </Text>
-                    </div>
-                  </div>
-
-                  <CredentialsInput
-                    schema={schema}
-                    selectedCredentials={selectedCredentials[cred.provider]}
-                    onSelectCredentials={(credMeta) =>
-                      handleCredentialSelect(cred.provider, credMeta)
-                    }
-                  />
-                </div>
-              );
-            })}
-          </div>
-        </div>
-      </div>
-    </Card>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/ChatInput/ChatInput.tsx

@@ -1,63 +0,0 @@
-import { cn } from "@/lib/utils";
-import { PaperPlaneRightIcon } from "@phosphor-icons/react";
-import { Button } from "@/components/atoms/Button/Button";
-import { useChatInput } from "./useChatInput";
-
-export interface ChatInputProps {
-  onSend: (message: string) => void;
-  disabled?: boolean;
-  placeholder?: string;
-  className?: string;
-}
-
-export function ChatInput({
-  onSend,
-  disabled = false,
-  placeholder = "Type your message...",
-  className,
-}: ChatInputProps) {
-  const { value, setValue, handleKeyDown, handleSend, textareaRef } =
-    useChatInput({
-      onSend,
-      disabled,
-      maxRows: 5,
-    });
-
-  return (
-    <div className={cn("flex gap-2", className)}>
-      <textarea
-        ref={textareaRef}
-        value={value}
-        onChange={(e) => setValue(e.target.value)}
-        onKeyDown={handleKeyDown}
-        placeholder={placeholder}
-        disabled={disabled}
-        rows={1}
-        autoComplete="off"
-        aria-label="Chat message input"
-        aria-describedby="chat-input-hint"
-        className={cn(
-          "flex-1 resize-none rounded-lg border border-neutral-200 bg-white px-4 py-2 text-sm",
-          "placeholder:text-neutral-400",
-          "focus:border-violet-600 focus:outline-none focus:ring-2 focus:ring-violet-600/20",
-          "dark:border-neutral-800 dark:bg-neutral-900 dark:text-neutral-100 dark:placeholder:text-neutral-500",
-          "disabled:cursor-not-allowed disabled:opacity-50",
-        )}
-      />
-      <span id="chat-input-hint" className="sr-only">
-        Press Enter to send, Shift+Enter for new line
-      </span>
-
-      <Button
-        variant="primary"
-        size="small"
-        onClick={handleSend}
-        disabled={disabled || !value.trim()}
-        className="self-end"
-        aria-label="Send message"
-      >
-        <PaperPlaneRightIcon className="h-4 w-4" weight="fill" />
-      </Button>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/ChatLoadingState/ChatLoadingState.tsx

@@ -1,31 +0,0 @@
-import React from "react";
-import { Text } from "@/components/atoms/Text/Text";
-import { ArrowClockwiseIcon } from "@phosphor-icons/react";
-import { cn } from "@/lib/utils";
-
-export interface ChatLoadingStateProps {
-  message?: string;
-  className?: string;
-}
-
-export function ChatLoadingState({
-  message = "Loading...",
-  className,
-}: ChatLoadingStateProps) {
-  return (
-    <div
-      className={cn("flex flex-1 items-center justify-center p-6", className)}
-    >
-      <div className="flex flex-col items-center gap-4 text-center">
-        <ArrowClockwiseIcon
-          size={32}
-          weight="bold"
-          className="animate-spin text-purple-500"
-        />
-        <Text variant="body" className="text-zinc-600 dark:text-zinc-400">
-          {message}
-        </Text>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/ChatMessage/ChatMessage.tsx

@@ -1,194 +0,0 @@
-"use client";
-
-import { cn } from "@/lib/utils";
-import { RobotIcon, UserIcon, CheckCircleIcon } from "@phosphor-icons/react";
-import { useCallback } from "react";
-import { MessageBubble } from "@/app/(platform)/chat/components/MessageBubble/MessageBubble";
-import { MarkdownContent } from "@/app/(platform)/chat/components/MarkdownContent/MarkdownContent";
-import { ToolCallMessage } from "@/app/(platform)/chat/components/ToolCallMessage/ToolCallMessage";
-import { ToolResponseMessage } from "@/app/(platform)/chat/components/ToolResponseMessage/ToolResponseMessage";
-import { AuthPromptWidget } from "@/app/(platform)/chat/components/AuthPromptWidget/AuthPromptWidget";
-import { ChatCredentialsSetup } from "@/app/(platform)/chat/components/ChatCredentialsSetup/ChatCredentialsSetup";
-import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
-import { useChatMessage, type ChatMessageData } from "./useChatMessage";
-import { getToolActionPhrase } from "@/app/(platform)/chat/helpers";
-export interface ChatMessageProps {
-  message: ChatMessageData;
-  className?: string;
-  onDismissLogin?: () => void;
-  onDismissCredentials?: () => void;
-  onSendMessage?: (content: string, isUserMessage?: boolean) => void;
-}
-
-export function ChatMessage({
-  message,
-  className,
-  onDismissCredentials,
-  onSendMessage,
-}: ChatMessageProps) {
-  const { user } = useSupabase();
-  const {
-    formattedTimestamp,
-    isUser,
-    isAssistant,
-    isToolCall,
-    isToolResponse,
-    isLoginNeeded,
-    isCredentialsNeeded,
-  } = useChatMessage(message);
-
-  const handleAllCredentialsComplete = useCallback(
-    function handleAllCredentialsComplete() {
-      // Send a user message that explicitly asks to retry the setup
-      // This ensures the LLM calls get_required_setup_info again and proceeds with execution
-      if (onSendMessage) {
-        onSendMessage(
-          "I've configured the required credentials. Please check if everything is ready and proceed with setting up the agent.",
-        );
-      }
-      // Optionally dismiss the credentials prompt
-      if (onDismissCredentials) {
-        onDismissCredentials();
-      }
-    },
-    [onSendMessage, onDismissCredentials],
-  );
-
-  function handleCancelCredentials() {
-    // Dismiss the credentials prompt
-    if (onDismissCredentials) {
-      onDismissCredentials();
-    }
-  }
-
-  // Render credentials needed messages
-  if (isCredentialsNeeded && message.type === "credentials_needed") {
-    return (
-      <ChatCredentialsSetup
-        credentials={message.credentials}
-        agentName={message.agentName}
-        message={message.message}
-        onAllCredentialsComplete={handleAllCredentialsComplete}
-        onCancel={handleCancelCredentials}
-        className={className}
-      />
-    );
-  }
-
-  // Render login needed messages
-  if (isLoginNeeded && message.type === "login_needed") {
-    // If user is already logged in, show success message instead of auth prompt
-    if (user) {
-      return (
-        <div className={cn("px-4 py-2", className)}>
-          <div className="my-4 overflow-hidden rounded-lg border border-green-200 bg-gradient-to-br from-green-50 to-emerald-50 dark:border-green-800 dark:from-green-950/30 dark:to-emerald-950/30">
-            <div className="px-6 py-4">
-              <div className="flex items-center gap-3">
-                <div className="flex h-10 w-10 items-center justify-center rounded-full bg-green-600">
-                  <CheckCircleIcon
-                    size={20}
-                    weight="fill"
-                    className="text-white"
-                  />
-                </div>
-                <div>
-                  <h3 className="text-lg font-semibold text-neutral-900 dark:text-neutral-100">
-                    Successfully Authenticated
-                  </h3>
-                  <p className="text-sm text-neutral-600 dark:text-neutral-400">
-                    You&apos;re now signed in and ready to continue
-                  </p>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      );
-    }
-
-    // Show auth prompt if not logged in
-    return (
-      <div className={cn("px-4 py-2", className)}>
-        <AuthPromptWidget
-          message={message.message}
-          sessionId={message.sessionId}
-          agentInfo={message.agentInfo}
-          returnUrl="/chat"
-        />
-      </div>
-    );
-  }
-
-  // Render tool call messages
-  if (isToolCall && message.type === "tool_call") {
-    return (
-      <div className={cn("px-4 py-2", className)}>
-        <ToolCallMessage toolName={message.toolName} />
-      </div>
-    );
-  }
-
-  // Render tool response messages
-  if (
-    (isToolResponse && message.type === "tool_response") ||
-    message.type === "no_results" ||
-    message.type === "agent_carousel" ||
-    message.type === "execution_started"
-  ) {
-    return (
-      <div className={cn("px-4 py-2", className)}>
-        <ToolResponseMessage toolName={getToolActionPhrase(message.toolName)} />
-      </div>
-    );
-  }
-
-  // Render regular chat messages
-  if (message.type === "message") {
-    return (
-      <div
-        className={cn(
-          "flex gap-3 px-4 py-4",
-          isUser && "flex-row-reverse",
-          className,
-        )}
-      >
-        {/* Avatar */}
-        <div className="flex-shrink-0">
-          <div
-            className={cn(
-              "flex h-8 w-8 items-center justify-center rounded-full",
-              isUser && "bg-zinc-200 dark:bg-zinc-700",
-              isAssistant && "bg-purple-600 dark:bg-purple-500",
-            )}
-          >
-            {isUser ? (
-              <UserIcon className="h-5 w-5 text-zinc-700 dark:text-zinc-200" />
-            ) : (
-              <RobotIcon className="h-5 w-5 text-white" />
-            )}
-          </div>
-        </div>
-
-        {/* Message Content */}
-        <div className={cn("flex max-w-[70%] flex-col", isUser && "items-end")}>
-          <MessageBubble variant={isUser ? "user" : "assistant"}>
-            <MarkdownContent content={message.content} />
-          </MessageBubble>
-
-          {/* Timestamp */}
-          <span
-            className={cn(
-              "mt-1 text-xs text-zinc-500 dark:text-zinc-400",
-              isUser && "text-right",
-            )}
-          >
-            {formattedTimestamp}
-          </span>
-        </div>
-      </div>
-    );
-  }
-
-  // Fallback for unknown message types
-  return null;
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/MessageBubble/MessageBubble.tsx

@@ -1,28 +0,0 @@
-import { cn } from "@/lib/utils";
-import { ReactNode } from "react";
-
-export interface MessageBubbleProps {
-  children: ReactNode;
-  variant: "user" | "assistant";
-  className?: string;
-}
-
-export function MessageBubble({
-  children,
-  variant,
-  className,
-}: MessageBubbleProps) {
-  return (
-    <div
-      className={cn(
-        "rounded-lg px-4 py-3 text-sm",
-        variant === "user" && "bg-violet-600 text-white dark:bg-violet-500",
-        variant === "assistant" &&
-          "border border-neutral-200 bg-white dark:border-neutral-700 dark:bg-neutral-900 dark:text-neutral-100",
-        className,
-      )}
-    >
-      {children}
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/MessageList/MessageList.tsx

@@ -1,61 +0,0 @@
-import { cn } from "@/lib/utils";
-import { ChatMessage } from "../ChatMessage/ChatMessage";
-import type { ChatMessageData } from "../ChatMessage/useChatMessage";
-import { StreamingMessage } from "../StreamingMessage/StreamingMessage";
-import { useMessageList } from "./useMessageList";
-
-export interface MessageListProps {
-  messages: ChatMessageData[];
-  streamingChunks?: string[];
-  isStreaming?: boolean;
-  className?: string;
-  onStreamComplete?: () => void;
-  onSendMessage?: (content: string) => void;
-}
-
-export function MessageList({
-  messages,
-  streamingChunks = [],
-  isStreaming = false,
-  className,
-  onStreamComplete,
-  onSendMessage,
-}: MessageListProps) {
-  const { messagesEndRef, messagesContainerRef } = useMessageList({
-    messageCount: messages.length,
-    isStreaming,
-  });
-
-  return (
-    <div
-      ref={messagesContainerRef}
-      className={cn(
-        "flex-1 overflow-y-auto",
-        "scrollbar-thin scrollbar-track-transparent scrollbar-thumb-zinc-300 dark:scrollbar-thumb-zinc-700",
-        className,
-      )}
-    >
-      <div className="space-y-0">
-        {/* Render all persisted messages */}
-        {messages.map((message, index) => (
-          <ChatMessage
-            key={index}
-            message={message}
-            onSendMessage={onSendMessage}
-          />
-        ))}
-
-        {/* Render streaming message if active */}
-        {isStreaming && streamingChunks.length > 0 && (
-          <StreamingMessage
-            chunks={streamingChunks}
-            onComplete={onStreamComplete}
-          />
-        )}
-
-        {/* Invisible div to scroll to */}
-        <div ref={messagesEndRef} />
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/QuickActionsWelcome/QuickActionsWelcome.tsx

@@ -1,51 +0,0 @@
-import React from "react";
-import { Text } from "@/components/atoms/Text/Text";
-import { cn } from "@/lib/utils";
-
-export interface QuickActionsWelcomeProps {
-  title: string;
-  description: string;
-  actions: string[];
-  onActionClick: (action: string) => void;
-  disabled?: boolean;
-  className?: string;
-}
-
-export function QuickActionsWelcome({
-  title,
-  description,
-  actions,
-  onActionClick,
-  disabled = false,
-  className,
-}: QuickActionsWelcomeProps) {
-  return (
-    <div
-      className={cn("flex flex-1 items-center justify-center p-4", className)}
-    >
-      <div className="max-w-2xl text-center">
-        <Text
-          variant="h2"
-          className="mb-4 text-3xl font-bold text-zinc-900 dark:text-zinc-100"
-        >
-          {title}
-        </Text>
-        <Text variant="body" className="mb-8 text-zinc-600 dark:text-zinc-400">
-          {description}
-        </Text>
-        <div className="grid gap-2 sm:grid-cols-2">
-          {actions.map((action) => (
-            <button
-              key={action}
-              onClick={() => onActionClick(action)}
-              disabled={disabled}
-              className="rounded-lg border border-zinc-200 bg-white p-4 text-left text-sm hover:bg-zinc-50 disabled:cursor-not-allowed disabled:opacity-50 dark:border-zinc-800 dark:bg-zinc-900 dark:hover:bg-zinc-800"
-            >
-              {action}
-            </button>
-          ))}
-        </div>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/StreamingMessage/StreamingMessage.tsx

@@ -1,42 +0,0 @@
-import { cn } from "@/lib/utils";
-import { Robot } from "@phosphor-icons/react";
-import { MessageBubble } from "@/app/(platform)/chat/components/MessageBubble/MessageBubble";
-import { MarkdownContent } from "@/app/(platform)/chat/components/MarkdownContent/MarkdownContent";
-import { useStreamingMessage } from "./useStreamingMessage";
-
-export interface StreamingMessageProps {
-  chunks: string[];
-  className?: string;
-  onComplete?: () => void;
-}
-
-export function StreamingMessage({
-  chunks,
-  className,
-  onComplete,
-}: StreamingMessageProps) {
-  const { displayText } = useStreamingMessage({ chunks, onComplete });
-
-  return (
-    <div className={cn("flex gap-3 px-4 py-4", className)}>
-      {/* Avatar */}
-      <div className="flex-shrink-0">
-        <div className="flex h-8 w-8 items-center justify-center rounded-full bg-purple-600 dark:bg-purple-500">
-          <Robot className="h-5 w-5 text-white" />
-        </div>
-      </div>
-
-      {/* Message Content */}
-      <div className="flex max-w-[70%] flex-col">
-        <MessageBubble variant="assistant">
-          <MarkdownContent content={displayText} />
-        </MessageBubble>
-
-        {/* Timestamp */}
-        <span className="mt-1 text-xs text-neutral-500 dark:text-neutral-400">
-          Typing...
-        </span>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/ToolCallMessage/ToolCallMessage.tsx

@@ -1,49 +0,0 @@
-import React from "react";
-import { WrenchIcon } from "@phosphor-icons/react";
-import { cn } from "@/lib/utils";
-import { getToolActionPhrase } from "@/app/(platform)/chat/helpers";
-
-export interface ToolCallMessageProps {
-  toolName: string;
-  className?: string;
-}
-
-export function ToolCallMessage({ toolName, className }: ToolCallMessageProps) {
-  return (
-    <div
-      className={cn(
-        "mx-10 max-w-[70%] overflow-hidden rounded-lg border transition-all duration-200",
-        "border-neutral-200 dark:border-neutral-700",
-        "bg-white dark:bg-neutral-900",
-        "animate-in fade-in-50 slide-in-from-top-1",
-        className,
-      )}
-    >
-      {/* Header */}
-      <div
-        className={cn(
-          "flex items-center justify-between px-3 py-2",
-          "bg-gradient-to-r from-neutral-50 to-neutral-100 dark:from-neutral-800/20 dark:to-neutral-700/20",
-        )}
-      >
-        <div className="flex items-center gap-2 overflow-hidden">
-          <WrenchIcon
-            size={16}
-            weight="bold"
-            className="flex-shrink-0 text-neutral-500 dark:text-neutral-400"
-          />
-          <span className="relative inline-block overflow-hidden text-sm font-medium text-neutral-700 dark:text-neutral-300">
-            {getToolActionPhrase(toolName)}...
-            <span
-              className={cn(
-                "absolute inset-0 bg-gradient-to-r from-transparent via-white/50 to-transparent",
-                "dark:via-white/20",
-                "animate-shimmer",
-              )}
-            />
-          </span>
-        </div>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/components/ToolResponseMessage/ToolResponseMessage.tsx

@@ -1,52 +0,0 @@
-import React from "react";
-import { WrenchIcon } from "@phosphor-icons/react";
-import { cn } from "@/lib/utils";
-import { getToolActionPhrase } from "@/app/(platform)/chat/helpers";
-
-export interface ToolResponseMessageProps {
-  toolName: string;
-  success?: boolean;
-  className?: string;
-}
-
-export function ToolResponseMessage({
-  toolName,
-  success = true,
-  className,
-}: ToolResponseMessageProps) {
-  return (
-    <div
-      className={cn(
-        "mx-10 max-w-[70%] overflow-hidden rounded-lg border transition-all duration-200",
-        success
-          ? "border-neutral-200 dark:border-neutral-700"
-          : "border-red-200 dark:border-red-800",
-        "bg-white dark:bg-neutral-900",
-        "animate-in fade-in-50 slide-in-from-top-1",
-        className,
-      )}
-    >
-      {/* Header */}
-      <div
-        className={cn(
-          "flex items-center justify-between px-3 py-2",
-          "bg-gradient-to-r",
-          success
-            ? "from-neutral-50 to-neutral-100 dark:from-neutral-800/20 dark:to-neutral-700/20"
-            : "from-red-50 to-red-100 dark:from-red-900/20 dark:to-red-800/20",
-        )}
-      >
-        <div className="flex items-center gap-2">
-          <WrenchIcon
-            size={16}
-            weight="bold"
-            className="text-neutral-500 dark:text-neutral-400"
-          />
-          <span className="text-sm font-medium text-neutral-700 dark:text-neutral-300">
-            {getToolActionPhrase(toolName)}...
-          </span>
-        </div>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/chat/page.tsx

@@ -1,16 +1,24 @@
 "use client";
 
-import { useChatPage } from "./useChatPage";
-import { ChatContainer } from "./components/ChatContainer/ChatContainer";
-import { ChatErrorState } from "./components/ChatErrorState/ChatErrorState";
-import { ChatLoadingState } from "./components/ChatLoadingState/ChatLoadingState";
-import { useGetFlag, Flag } from "@/services/feature-flags/use-get-flag";
-import { useRouter } from "next/navigation";
+import { Button } from "@/components/__legacy__/ui/button";
+import { scrollbarStyles } from "@/components/styles/scrollbars";
+import { cn } from "@/lib/utils";
+import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
+import { X } from "@phosphor-icons/react";
+import { usePathname, useRouter } from "next/navigation";
 import { useEffect } from "react";
+import { Drawer } from "vaul";
+
+import { ChatContainer } from "@/components/contextual/Chat/components/ChatContainer/ChatContainer";
+import { ChatErrorState } from "@/components/contextual/Chat/components/ChatErrorState/ChatErrorState";
+import { ChatLoadingState } from "@/components/contextual/Chat/components/ChatLoadingState/ChatLoadingState";
+import { useChatPage } from "./useChatPage";
 
 export default function ChatPage() {
   const isChatEnabled = useGetFlag(Flag.CHAT);
   const router = useRouter();
+  const pathname = usePathname();
+  const isOpen = pathname === "/chat";
   const {
     messages,
     isLoading,
@@ -28,56 +36,88 @@ export default function ChatPage() {
     }
   }, [isChatEnabled, router]);
 
+  function handleOpenChange(open: boolean) {
+    if (!open) {
+      router.replace("/marketplace");
+    }
+  }
+
   if (isChatEnabled === null || isChatEnabled === false) {
     return null;
   }
 
   return (
-    <div className="flex h-full flex-col">
-      {/* Header */}
-      <header className="border-b border-zinc-200 bg-white p-4 dark:border-zinc-800 dark:bg-zinc-900">
-        <div className="container mx-auto flex items-center justify-between">
-          <h1 className="text-xl font-semibold">Chat</h1>
-          {sessionId && (
-            <div className="flex items-center gap-4">
-              <span className="text-sm text-zinc-600 dark:text-zinc-400">
-                Session: {sessionId.slice(0, 8)}...
-              </span>
-              <button
-                onClick={clearSession}
-                className="text-sm text-zinc-600 hover:text-zinc-900 dark:text-zinc-400 dark:hover:text-zinc-100"
-              >
-                New Chat
-              </button>
-            </div>
+    <Drawer.Root
+      open={isOpen}
+      onOpenChange={handleOpenChange}
+      direction="right"
+      modal={false}
+    >
+      <Drawer.Portal>
+        <Drawer.Content
+          className={cn(
+            "fixed right-0 top-0 z-50 flex h-full w-1/2 flex-col border-l border-zinc-200 bg-white dark:border-zinc-800 dark:bg-zinc-900",
+            scrollbarStyles,
           )}
-        </div>
-      </header>
+        >
+          {/* Header */}
+          <header className="shrink-0 border-b border-zinc-200 bg-white p-4 dark:border-zinc-800 dark:bg-zinc-900">
+            <div className="flex items-center justify-between">
+              <Drawer.Title className="text-xl font-semibold">
+                Chat
+              </Drawer.Title>
+              <div className="flex items-center gap-4">
+                {sessionId && (
+                  <>
+                    <span className="text-sm text-zinc-600 dark:text-zinc-400">
+                      Session: {sessionId.slice(0, 8)}...
+                    </span>
+                    <button
+                      onClick={clearSession}
+                      className="text-sm text-zinc-600 hover:text-zinc-900 dark:text-zinc-400 dark:hover:text-zinc-100"
+                    >
+                      New Chat
+                    </button>
+                  </>
+                )}
+                <Button
+                  variant="link"
+                  aria-label="Close"
+                  onClick={() => handleOpenChange(false)}
+                  className="!focus-visible:ring-0 p-0"
+                >
+                  <X width="1.5rem" />
+                </Button>
+              </div>
+            </div>
+          </header>
 
-      {/* Main Content */}
-      <main className="container mx-auto flex flex-1 flex-col overflow-hidden">
-        {/* Loading State - show when explicitly loading/creating OR when we don't have a session yet and no error */}
-        {(isLoading || isCreating || (!sessionId && !error)) && (
-          <ChatLoadingState
-            message={isCreating ? "Creating session..." : "Loading..."}
-          />
-        )}
+          {/* Main Content */}
+          <main className="flex min-h-0 flex-1 flex-col overflow-hidden">
+            {/* Loading State - show when explicitly loading/creating OR when we don't have a session yet and no error */}
+            {(isLoading || isCreating || (!sessionId && !error)) && (
+              <ChatLoadingState
+                message={isCreating ? "Creating session..." : "Loading..."}
+              />
+            )}
 
-        {/* Error State */}
-        {error && !isLoading && (
-          <ChatErrorState error={error} onRetry={createSession} />
-        )}
+            {/* Error State */}
+            {error && !isLoading && (
+              <ChatErrorState error={error} onRetry={createSession} />
+            )}
 
-        {/* Session Content */}
-        {sessionId && !isLoading && !error && (
-          <ChatContainer
-            sessionId={sessionId}
-            initialMessages={messages}
-            onRefreshSession={refreshSession}
-            className="flex-1"
-          />
-        )}
-      </main>
-    </div>
+            {/* Session Content */}
+            {sessionId && !isLoading && !error && (
+              <ChatContainer
+                sessionId={sessionId}
+                initialMessages={messages}
+                onRefreshSession={refreshSession}
+                className="flex-1"
+              />
+            )}
+          </main>
+        </Drawer.Content>
+      </Drawer.Portal>
+    </Drawer.Root>
   );
 }

autogpt_platform/frontend/src/app/(platform)/chat/useChatPage.ts

@@ -1,11 +1,11 @@
 "use client";
 
-import { useEffect, useRef } from "react";
-import { useRouter, useSearchParams } from "next/navigation";
-import { toast } from "sonner";
-import { useChatSession } from "@/app/(platform)/chat/useChatSession";
+import { useChatSession } from "@/components/contextual/Chat/useChatSession";
+import { useChatStream } from "@/components/contextual/Chat/useChatStream";
 import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
-import { useChatStream } from "@/app/(platform)/chat/useChatStream";
+import { useRouter, useSearchParams } from "next/navigation";
+import { useEffect, useRef } from "react";
+import { toast } from "sonner";
 
 export function useChatPage() {
   const router = useRouter();

autogpt_platform/frontend/src/app/(platform)/chat/useChatStream.ts

@@ -1,204 +0,0 @@
-import { useState, useCallback, useRef, useEffect } from "react";
-import { toast } from "sonner";
-import type { ToolArguments, ToolResult } from "@/types/chat";
-
-const MAX_RETRIES = 3;
-const INITIAL_RETRY_DELAY = 1000;
-
-export interface StreamChunk {
-  type:
-    | "text_chunk"
-    | "text_ended"
-    | "tool_call"
-    | "tool_call_start"
-    | "tool_response"
-    | "login_needed"
-    | "need_login"
-    | "credentials_needed"
-    | "error"
-    | "usage"
-    | "stream_end";
-  timestamp?: string;
-  content?: string;
-  message?: string;
-  tool_id?: string;
-  tool_name?: string;
-  arguments?: ToolArguments;
-  result?: ToolResult;
-  success?: boolean;
-  idx?: number;
-  session_id?: string;
-  agent_info?: {
-    graph_id: string;
-    name: string;
-    trigger_type: string;
-  };
-  provider?: string;
-  provider_name?: string;
-  credential_type?: string;
-  scopes?: string[];
-  title?: string;
-  [key: string]: unknown;
-}
-
-export function useChatStream() {
-  const [isStreaming, setIsStreaming] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-  const eventSourceRef = useRef<EventSource | null>(null);
-  const retryCountRef = useRef<number>(0);
-  const retryTimeoutRef = useRef<NodeJS.Timeout | null>(null);
-  const abortControllerRef = useRef<AbortController | null>(null);
-
-  const stopStreaming = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      abortControllerRef.current = null;
-    }
-    if (eventSourceRef.current) {
-      eventSourceRef.current.close();
-      eventSourceRef.current = null;
-    }
-    if (retryTimeoutRef.current) {
-      clearTimeout(retryTimeoutRef.current);
-      retryTimeoutRef.current = null;
-    }
-    retryCountRef.current = 0;
-    setIsStreaming(false);
-  }, []);
-
-  useEffect(() => {
-    return () => {
-      stopStreaming();
-    };
-  }, [stopStreaming]);
-
-  const sendMessage = useCallback(
-    async (
-      sessionId: string,
-      message: string,
-      onChunk: (chunk: StreamChunk) => void,
-      isUserMessage: boolean = true,
-    ) => {
-      stopStreaming();
-
-      const abortController = new AbortController();
-      abortControllerRef.current = abortController;
-
-      if (abortController.signal.aborted) {
-        return Promise.reject(new Error("Request aborted"));
-      }
-
-      retryCountRef.current = 0;
-      setIsStreaming(true);
-      setError(null);
-
-      try {
-        const url = `/api/chat/sessions/${sessionId}/stream?message=${encodeURIComponent(
-          message,
-        )}&is_user_message=${isUserMessage}`;
-
-        const eventSource = new EventSource(url);
-        eventSourceRef.current = eventSource;
-
-        abortController.signal.addEventListener("abort", () => {
-          eventSource.close();
-          eventSourceRef.current = null;
-        });
-
-        return new Promise<void>((resolve, reject) => {
-          const cleanup = () => {
-            eventSource.removeEventListener("message", messageHandler);
-            eventSource.removeEventListener("error", errorHandler);
-          };
-
-          const messageHandler = (event: MessageEvent) => {
-            try {
-              const chunk = JSON.parse(event.data) as StreamChunk;
-
-              if (retryCountRef.current > 0) {
-                retryCountRef.current = 0;
-              }
-
-              // Call the chunk handler
-              onChunk(chunk);
-
-              // Handle stream lifecycle
-              if (chunk.type === "stream_end") {
-                cleanup();
-                stopStreaming();
-                resolve();
-              } else if (chunk.type === "error") {
-                cleanup();
-                reject(
-                  new Error(chunk.message || chunk.content || "Stream error"),
-                );
-              }
-            } catch (err) {
-              const parseError =
-                err instanceof Error
-                  ? err
-                  : new Error("Failed to parse stream chunk");
-              setError(parseError);
-              cleanup();
-              reject(parseError);
-            }
-          };
-
-          const errorHandler = () => {
-            if (eventSourceRef.current) {
-              eventSourceRef.current.close();
-              eventSourceRef.current = null;
-            }
-
-            if (retryCountRef.current < MAX_RETRIES) {
-              retryCountRef.current += 1;
-              const retryDelay =
-                INITIAL_RETRY_DELAY * Math.pow(2, retryCountRef.current - 1);
-
-              toast.info("Connection interrupted", {
-                description: `Retrying in ${retryDelay / 1000} seconds...`,
-              });
-
-              retryTimeoutRef.current = setTimeout(() => {
-                sendMessage(sessionId, message, onChunk, isUserMessage).catch(
-                  (_err) => {
-                    // Retry failed
-                  },
-                );
-              }, retryDelay);
-            } else {
-              const streamError = new Error(
-                "Stream connection failed after multiple retries",
-              );
-              setError(streamError);
-              toast.error("Connection Failed", {
-                description:
-                  "Unable to connect to chat service. Please try again.",
-              });
-              cleanup();
-              stopStreaming();
-              reject(streamError);
-            }
-          };
-
-          eventSource.addEventListener("message", messageHandler);
-          eventSource.addEventListener("error", errorHandler);
-        });
-      } catch (err) {
-        const streamError =
-          err instanceof Error ? err : new Error("Failed to start stream");
-        setError(streamError);
-        setIsStreaming(false);
-        throw streamError;
-      }
-    },
-    [stopStreaming],
-  );
-
-  return {
-    isStreaming,
-    error,
-    sendMessage,
-    stopStreaming,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/layout.tsx

@@ -1,13 +1,14 @@
 import { Navbar } from "@/components/layout/Navbar/Navbar";
-import { AdminImpersonationBanner } from "./admin/components/AdminImpersonationBanner";
 import { ReactNode } from "react";
+import { AdminImpersonationBanner } from "./admin/components/AdminImpersonationBanner";
+import { PlatformLayoutContent } from "./PlatformLayoutContent";
 
 export default function PlatformLayout({ children }: { children: ReactNode }) {
   return (
-    <main className="flex h-screen w-full flex-col">
+    <PlatformLayoutContent>
       <Navbar />
       <AdminImpersonationBanner />
-      <section className="flex-1">{children}</section>
-    </main>
+      {children}
+    </PlatformLayoutContent>
   );
 }

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

@@ -3,8 +3,8 @@
 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 { RunAgentInputs } from "../RunAgentInputs/RunAgentInputs";
+import { CredentialsInput } from "../../../../../../../../../../components/contextual/CredentialsInputs/CredentialsInputs";
+import { RunAgentInputs } from "../../../../../../../../../../components/contextual/RunAgentInputs/RunAgentInputs";
 import { getAgentCredentialsFields, getAgentInputFields } from "./helpers";
 
 type Props = {

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

@@ -1,7 +1,7 @@
-import { CredentialsInput } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs";
 import { Input } from "@/components/atoms/Input/Input";
+import { CredentialsInput } from "@/components/contextual/CredentialsInputs/CredentialsInputs";
 import { InformationTooltip } from "@/components/molecules/InformationTooltip/InformationTooltip";
-import { RunAgentInputs } from "../../../RunAgentInputs/RunAgentInputs";
+import { RunAgentInputs } from "../../../../../../../../../../../../components/contextual/RunAgentInputs/RunAgentInputs";
 import { useRunAgentModalContext } from "../../context";
 import { ModalSection } from "../ModalSection/ModalSection";
 import { WebhookTriggerBanner } from "../WebhookTriggerBanner/WebhookTriggerBanner";

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

@@ -3,12 +3,12 @@
 import type {
   OutputMetadata,
   OutputRenderer,
-} from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
+} from "@/components/contextual/OutputRenderers";
 import {
   globalRegistry,
   OutputActions,
   OutputItem,
-} from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/OutputRenderers";
+} from "@/components/contextual/OutputRenderers";
 import React, { useMemo } from "react";
 
 type OutputsRecord = Record<string, Array<unknown>>;

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

@@ -4,12 +4,12 @@ import type { GraphExecutionMeta } from "@/app/api/__generated__/models/graphExe
 import type { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { Input } from "@/components/atoms/Input/Input";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
+import { CredentialsInput } from "../../../../../../../../../../components/contextual/CredentialsInputs/CredentialsInputs";
+import { RunAgentInputs } from "../../../../../../../../../../components/contextual/RunAgentInputs/RunAgentInputs";
 import {
   getAgentCredentialsFields,
   getAgentInputFields,
 } from "../../modals/AgentInputsReadOnly/helpers";
-import { CredentialsInput } from "../../modals/CredentialsInputs/CredentialsInputs";
-import { RunAgentInputs } from "../../modals/RunAgentInputs/RunAgentInputs";
 import { LoadingSelectedContent } from "../LoadingSelectedContent";
 import { RunDetailCard } from "../RunDetailCard/RunDetailCard";
 import { RunDetailHeader } from "../RunDetailHeader/RunDetailHeader";

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

@@ -3,12 +3,12 @@
 import type { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { Input } from "@/components/atoms/Input/Input";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
+import { CredentialsInput } from "../../../../../../../../../../components/contextual/CredentialsInputs/CredentialsInputs";
+import { RunAgentInputs } from "../../../../../../../../../../components/contextual/RunAgentInputs/RunAgentInputs";
 import {
   getAgentCredentialsFields,
   getAgentInputFields,
 } from "../../modals/AgentInputsReadOnly/helpers";
-import { CredentialsInput } from "../../modals/CredentialsInputs/CredentialsInputs";
-import { RunAgentInputs } from "../../modals/RunAgentInputs/RunAgentInputs";
 import { LoadingSelectedContent } from "../LoadingSelectedContent";
 import { RunDetailCard } from "../RunDetailCard/RunDetailCard";
 import { RunDetailHeader } from "../RunDetailHeader/RunDetailHeader";

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-run-draft-view.tsx

@@ -12,8 +12,6 @@ import {
 } from "@/lib/autogpt-server-api";
 import { useBackendAPI } from "@/lib/autogpt-server-api/context";
 
-import { CredentialsInput } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/CredentialsInputs/CredentialsInputs";
-import { RunAgentInputs } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentInputs/RunAgentInputs";
 import { ScheduleTaskDialog } from "@/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/cron-scheduler-dialog";
 import ActionButtonGroup from "@/components/__legacy__/action-button-group";
 import type { ButtonAction } from "@/components/__legacy__/types";
@@ -30,6 +28,8 @@ import {
 } from "@/components/__legacy__/ui/icons";
 import { Input } from "@/components/__legacy__/ui/input";
 import { Button } from "@/components/atoms/Button/Button";
+import { CredentialsInput } from "@/components/contextual/CredentialsInputs/CredentialsInputs";
+import { RunAgentInputs } from "@/components/contextual/RunAgentInputs/RunAgentInputs";
 import { InformationTooltip } from "@/components/molecules/InformationTooltip/InformationTooltip";
 import {
   useToast,

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-run-output-view.tsx

@@ -11,12 +11,12 @@ import {
 } from "@/components/__legacy__/ui/card";
 
 import LoadingBox from "@/components/__legacy__/ui/loading";
-import type { OutputMetadata } from "../../NewAgentLibraryView/components/selected-views/OutputRenderers";
+import type { OutputMetadata } from "../../../../../../../../components/contextual/OutputRenderers";
 import {
   globalRegistry,
   OutputActions,
   OutputItem,
-} from "../../NewAgentLibraryView/components/selected-views/OutputRenderers";
+} from "../../../../../../../../components/contextual/OutputRenderers";
 
 export function AgentRunOutputView({
   agentRunOutputs,

autogpt_platform/frontend/src/app/api/chat/sessions/[sessionId]/stream/route.ts

@@ -4,8 +4,91 @@ import { NextRequest } from "next/server";
 
 /**
  * SSE Proxy for chat streaming.
- * EventSource doesn't support custom headers, so we need a server-side proxy
- * that adds authentication and forwards the SSE stream to the client.
+ * Supports POST with context (page content + URL) in the request body.
+ */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ sessionId: string }> },
+) {
+  const { sessionId } = await params;
+
+  try {
+    const body = await request.json();
+    const { message, is_user_message, context } = body;
+
+    if (!message) {
+      return new Response(
+        JSON.stringify({ error: "Missing message parameter" }),
+        { status: 400, headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    // Get auth token from server-side session
+    const token = await getServerAuthToken();
+
+    // Build backend URL
+    const backendUrl = environment.getAGPTServerBaseUrl();
+    const streamUrl = new URL(
+      `/api/chat/sessions/${sessionId}/stream`,
+      backendUrl,
+    );
+
+    // Forward request to backend with auth header
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    };
+
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+
+    const response = await fetch(streamUrl.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        message,
+        is_user_message: is_user_message ?? true,
+        context: context || null,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      return new Response(error, {
+        status: response.status,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Return the SSE stream directly
+    return new Response(response.body, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+      },
+    });
+  } catch (error) {
+    console.error("SSE proxy error:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to connect to chat service",
+        detail: error instanceof Error ? error.message : String(error),
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  }
+}
+
+/**
+ * Legacy GET endpoint for backward compatibility
  */
 export async function GET(
   request: NextRequest,

autogpt_platform/frontend/src/app/api/mutators/custom-mutator.ts

@@ -41,9 +41,11 @@ export const customMutator = async <
   T extends { data: any; status: number; headers: Headers },
 >(
   url: string,
-  options: RequestInit,
+  options: RequestInit & {
+    params?: any;
+  } = {},
 ): Promise<T> => {
-  const requestOptions = options;
+  const { params, ...requestOptions } = options;
   const method = (requestOptions.method || "GET") as
     | "GET"
     | "POST"
@@ -85,11 +87,14 @@ export const customMutator = async <
     headers["Content-Type"] = "application/json";
   }
 
+  const queryString = params
+    ? "?" + new URLSearchParams(params).toString()
+    : "";
+
   const baseUrl = getBaseUrl();
 
   // The caching in React Query in our system depends on the url, so the base_url could be different for the server and client sides.
-  // here url also contains encoded query params
-  const fullUrl = `${baseUrl}${url}`;
+  const fullUrl = `${baseUrl}${url}${queryString}`;
 
   if (environment.isServerSide()) {
     try {

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

@@ -5012,6 +5012,78 @@
         }
       }
     },
+    "/api/store/admin/embeddings/backfill": {
+      "post": {
+        "tags": ["v2", "admin", "store", "admin"],
+        "summary": "Backfill Missing Embeddings",
+        "description": "Trigger backfill of embeddings for approved listings that don't have them.\n\nArgs:\n    batch_size: Number of embeddings to generate in one call (default 10)\n\nReturns:\n    Dict with processed count, success count, failure count, and message",
+        "operationId": "postV2Backfill missing embeddings",
+        "security": [{ "HTTPBearerJWT": [] }],
+        "parameters": [
+          {
+            "name": "batch_size",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "integer",
+              "default": 10,
+              "title": "Batch Size"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "additionalProperties": true,
+                  "title": "Response Postv2Backfill Missing Embeddings"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/store/admin/embeddings/stats": {
+      "get": {
+        "tags": ["v2", "admin", "store", "admin"],
+        "summary": "Get Embedding Statistics",
+        "description": "Get statistics about embedding coverage for store listings.\n\nReturns counts of total approved listings, listings with embeddings,\nlistings without embeddings, and coverage percentage.",
+        "operationId": "getV2Get embedding statistics",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "additionalProperties": true,
+                  "type": "object",
+                  "title": "Response Getv2Get Embedding Statistics"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          }
+        },
+        "security": [{ "HTTPBearerJWT": [] }]
+      }
+    },
     "/api/store/admin/listings": {
       "get": {
         "tags": ["v2", "admin", "store", "admin"],

autogpt_platform/frontend/src/app/globals.css

@@ -141,6 +141,52 @@
   }
 }
 
+@keyframes shimmer {
+  0% {
+    background-position: -200% 0;
+  }
+  100% {
+    background-position: 200% 0;
+  }
+}
+
+@keyframes l3 {
+  25% {
+    background-position:
+      0 0,
+      100% 100%,
+      100% calc(100% - 5px);
+  }
+  50% {
+    background-position:
+      0 100%,
+      100% 100%,
+      0 calc(100% - 5px);
+  }
+  75% {
+    background-position:
+      0 100%,
+      100% 0,
+      100% 5px;
+  }
+}
+
+.loader {
+  width: 80px;
+  height: 70px;
+  border: 5px solid rgb(241 245 249);
+  padding: 0 8px;
+  box-sizing: border-box;
+  background:
+    linear-gradient(rgb(15 23 42) 0 0) 0 0/8px 20px,
+    linear-gradient(rgb(15 23 42) 0 0) 100% 0/8px 20px,
+    radial-gradient(farthest-side, rgb(15 23 42) 90%, #0000) 0 5px/8px 8px
+      content-box,
+    transparent;
+  background-repeat: no-repeat;
+  animation: l3 2s infinite linear;
+}
+
 input[type="number"]::-webkit-outer-spin-button,
 input[type="number"]::-webkit-inner-spin-button {
   -webkit-appearance: none;

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

@@ -92,7 +92,7 @@ export function Input({
           className={cn(
             baseStyles,
             errorStyles,
-            "-mb-1 h-auto min-h-[2.875rem] rounded-medium",
+            "-mb-1 h-auto min-h-[2.875rem] rounded-full",
             // Size variants for textarea
             size === "small" && [
               "min-h-[2.25rem]", // 36px minimum
@@ -107,6 +107,11 @@ export function Input({
           )}
           placeholder={placeholder || label}
           onChange={handleTextareaChange}
+          onKeyDown={
+            props.onKeyDown as
+              | React.KeyboardEventHandler<HTMLTextAreaElement>
+              | undefined
+          }
           rows={props.rows || 3}
           {...(hideLabel ? { "aria-label": label } : {})}
           id={props.id}

autogpt_platform/frontend/src/components/contextual/Chat/Chat.tsx

@@ -0,0 +1,136 @@
+"use client";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { Text } from "@/components/atoms/Text/Text";
+import { cn } from "@/lib/utils";
+import { List } from "@phosphor-icons/react";
+import React, { useState } from "react";
+import { ChatContainer } from "./components/ChatContainer/ChatContainer";
+import { ChatErrorState } from "./components/ChatErrorState/ChatErrorState";
+import { ChatLoadingState } from "./components/ChatLoadingState/ChatLoadingState";
+import { SessionsDrawer } from "./components/SessionsDrawer/SessionsDrawer";
+import { useChat } from "./useChat";
+
+export interface ChatProps {
+  className?: string;
+  headerTitle?: React.ReactNode;
+  showHeader?: boolean;
+  showSessionInfo?: boolean;
+  showNewChatButton?: boolean;
+  onNewChat?: () => void;
+  headerActions?: React.ReactNode;
+}
+
+export function Chat({
+  className,
+  headerTitle = "AutoGPT Copilot",
+  showHeader = true,
+  showSessionInfo = true,
+  showNewChatButton = true,
+  onNewChat,
+  headerActions,
+}: ChatProps) {
+  const {
+    messages,
+    isLoading,
+    isCreating,
+    error,
+    sessionId,
+    createSession,
+    clearSession,
+    refreshSession,
+    loadSession,
+  } = useChat();
+
+  const [isSessionsDrawerOpen, setIsSessionsDrawerOpen] = useState(false);
+
+  const handleNewChat = () => {
+    clearSession();
+    onNewChat?.();
+  };
+
+  const handleSelectSession = async (sessionId: string) => {
+    try {
+      await loadSession(sessionId);
+    } catch (err) {
+      console.error("Failed to load session:", err);
+    }
+  };
+
+  return (
+    <div className={cn("flex h-full flex-col", className)}>
+      {/* Header */}
+      {showHeader && (
+        <header className="shrink-0 border-t border-zinc-200 bg-white p-3">
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-3">
+              <button
+                aria-label="View sessions"
+                onClick={() => setIsSessionsDrawerOpen(true)}
+                className="flex size-8 items-center justify-center rounded hover:bg-zinc-100"
+              >
+                <List width="1.25rem" height="1.25rem" />
+              </button>
+              {typeof headerTitle === "string" ? (
+                <Text variant="h2" className="text-lg font-semibold">
+                  {headerTitle}
+                </Text>
+              ) : (
+                headerTitle
+              )}
+            </div>
+            <div className="flex items-center gap-3">
+              {showSessionInfo && sessionId && (
+                <>
+                  {showNewChatButton && (
+                    <Button
+                      variant="outline"
+                      size="small"
+                      onClick={handleNewChat}
+                    >
+                      New Chat
+                    </Button>
+                  )}
+                </>
+              )}
+              {headerActions}
+            </div>
+          </div>
+        </header>
+      )}
+
+      {/* Main Content */}
+      <main className="flex min-h-0 flex-1 flex-col overflow-hidden">
+        {/* Loading State - show when explicitly loading/creating OR when we don't have a session yet and no error */}
+        {(isLoading || isCreating || (!sessionId && !error)) && (
+          <ChatLoadingState
+            message={isCreating ? "Creating session..." : "Loading..."}
+          />
+        )}
+
+        {/* Error State */}
+        {error && !isLoading && (
+          <ChatErrorState error={error} onRetry={createSession} />
+        )}
+
+        {/* Session Content */}
+        {sessionId && !isLoading && !error && (
+          <ChatContainer
+            sessionId={sessionId}
+            initialMessages={messages}
+            onRefreshSession={refreshSession}
+            className="flex-1"
+          />
+        )}
+      </main>
+
+      {/* Sessions Drawer */}
+      <SessionsDrawer
+        isOpen={isSessionsDrawerOpen}
+        onClose={() => setIsSessionsDrawerOpen(false)}
+        onSelectSession={handleSelectSession}
+        currentSessionId={sessionId}
+      />
+    </div>
+  );
+}

autogpt_platform/frontend/src/components/contextual/Chat/ChatDrawer.tsx

@@ -0,0 +1,77 @@
+"use client";
+
+import { scrollbarStyles } from "@/components/styles/scrollbars";
+import { cn } from "@/lib/utils";
+import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
+import { X } from "@phosphor-icons/react";
+import { useEffect, useState } from "react";
+import { Drawer } from "vaul";
+import { Chat } from "./Chat";
+import { useChatDrawer } from "./useChatDrawer";
+
+interface ChatDrawerProps {
+  blurBackground?: boolean;
+}
+
+export function ChatDrawer({ blurBackground = true }: ChatDrawerProps) {
+  const [isMounted, setIsMounted] = useState(false);
+  const isChatEnabled = useGetFlag(Flag.CHAT);
+  const { isOpen, close } = useChatDrawer();
+
+  useEffect(() => {
+    setIsMounted(true);
+  }, []);
+
+  useEffect(() => {
+    if (isChatEnabled === false && isOpen) {
+      close();
+    }
+  }, [isChatEnabled, isOpen, close]);
+
+  // Don't render on server - vaul drawer accesses document during SSR
+  if (!isMounted || isChatEnabled === null || isChatEnabled === false) {
+    return null;
+  }
+
+  return (
+    <Drawer.Root
+      open={isOpen}
+      onOpenChange={(open) => {
+        if (!open) {
+          close();
+        }
+      }}
+      direction="right"
+      modal={false}
+    >
+      {blurBackground && isOpen && (
+        <div
+          onClick={close}
+          className="fixed inset-0 z-[45] cursor-pointer animate-in fade-in-0"
+          style={{ pointerEvents: "auto" }}
+        />
+      )}
+      <Drawer.Content
+        onClick={(e) => e.stopPropagation()}
+        onInteractOutside={blurBackground ? close : undefined}
+        className={cn(
+          "fixed right-0 top-[60px] z-50 flex h-[calc(100vh-60px)] w-1/2 flex-col border-l border-zinc-200 bg-white",
+          scrollbarStyles,
+        )}
+      >
+        <Chat
+          headerTitle={
+            <Drawer.Title className="text-lg font-semibold">
+              AutoGPT Copilot
+            </Drawer.Title>
+          }
+          headerActions={
+            <button aria-label="Close" onClick={close} className="size-8">
+              <X width="1.25rem" height="1.25rem" />
+            </button>
+          }
+        />
+      </Drawer.Content>
+    </Drawer.Root>
+  );
+}

autogpt_platform/frontend/src/components/contextual/Chat/components/AgentCarouselMessage/AgentCarouselMessage.tsx

@@ -1,15 +1,16 @@
-import React from "react";
-import { Text } from "@/components/atoms/Text/Text";
 import { Button } from "@/components/atoms/Button/Button";
 import { Card } from "@/components/atoms/Card/Card";
-import { List, Robot, ArrowRight } from "@phosphor-icons/react";
+import { Text } from "@/components/atoms/Text/Text";
 import { cn } from "@/lib/utils";
+import { ArrowRight, List, Robot } from "@phosphor-icons/react";
+import Image from "next/image";
 
 export interface Agent {
   id: string;
   name: string;
   description: string;
   version?: number;
+  image_url?: string;
 }
 
 export interface AgentCarouselMessageProps {
@@ -30,7 +31,7 @@ export function AgentCarouselMessage({
   return (
     <div
       className={cn(
-        "mx-4 my-2 flex flex-col gap-4 rounded-lg border border-purple-200 bg-purple-50 p-6 dark:border-purple-900 dark:bg-purple-950",
+        "mx-4 my-2 flex flex-col gap-4 rounded-lg border border-purple-200 bg-purple-50 p-6",
         className,
       )}
     >
@@ -40,13 +41,10 @@ export function AgentCarouselMessage({
           <List size={24} weight="bold" className="text-white" />
         </div>
         <div>
-          <Text variant="h3" className="text-purple-900 dark:text-purple-100">
+          <Text variant="h3" className="text-purple-900">
             Found {displayCount} {displayCount === 1 ? "Agent" : "Agents"}
           </Text>
-          <Text
-            variant="small"
-            className="text-purple-700 dark:text-purple-300"
-          >
+          <Text variant="small" className="text-purple-700">
             Select an agent to view details or run it
           </Text>
         </div>
@@ -57,40 +55,49 @@ export function AgentCarouselMessage({
         {agents.map((agent) => (
           <Card
             key={agent.id}
-            className="border border-purple-200 bg-white p-4 dark:border-purple-800 dark:bg-purple-900"
+            className="border border-purple-200 bg-white p-4"
           >
             <div className="flex gap-3">
-              <div className="flex h-10 w-10 flex-shrink-0 items-center justify-center rounded-lg bg-purple-100 dark:bg-purple-800">
-                <Robot size={20} weight="bold" className="text-purple-600" />
+              <div className="relative h-10 w-10 flex-shrink-0 overflow-hidden rounded-lg bg-purple-100">
+                {agent.image_url ? (
+                  <Image
+                    src={agent.image_url}
+                    alt={`${agent.name} preview image`}
+                    fill
+                    className="object-cover"
+                  />
+                ) : (
+                  <div className="flex h-full w-full items-center justify-center">
+                    <Robot
+                      size={20}
+                      weight="bold"
+                      className="text-purple-600"
+                    />
+                  </div>
+                )}
               </div>
               <div className="flex-1 space-y-2">
                 <div>
                   <Text
                     variant="body"
-                    className="font-semibold text-purple-900 dark:text-purple-100"
+                    className="font-semibold text-purple-900"
                   >
                     {agent.name}
                   </Text>
                   {agent.version && (
-                    <Text
-                      variant="small"
-                      className="text-purple-600 dark:text-purple-400"
-                    >
+                    <Text variant="small" className="text-purple-600">
                       v{agent.version}
                     </Text>
                   )}
                 </div>
-                <Text
-                  variant="small"
-                  className="line-clamp-2 text-purple-700 dark:text-purple-300"
-                >
+                <Text variant="small" className="line-clamp-2 text-purple-700">
                   {agent.description}
                 </Text>
                 {onSelectAgent && (
                   <Button
                     onClick={() => onSelectAgent(agent.id)}
                     variant="ghost"
-                    className="mt-2 flex items-center gap-1 p-0 text-sm text-purple-600 hover:text-purple-800 dark:text-purple-400 dark:hover:text-purple-200"
+                    className="mt-2 flex items-center gap-1 p-0 text-sm text-purple-600 hover:text-purple-800"
                   >
                     View details
                     <ArrowRight size={16} weight="bold" />
@@ -103,10 +110,7 @@ export function AgentCarouselMessage({
       </div>
 
       {totalCount && totalCount > agents.length && (
-        <Text
-          variant="small"
-          className="text-center text-purple-600 dark:text-purple-400"
-        >
+        <Text variant="small" className="text-center text-purple-600">
           Showing {agents.length} of {totalCount} results
         </Text>
       )}

autogpt_platform/frontend/src/components/contextual/Chat/components/AgentInputsSetup/AgentInputsSetup.tsx

@@ -0,0 +1,145 @@
+"use client";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { Card } from "@/components/atoms/Card/Card";
+import { Text } from "@/components/atoms/Text/Text";
+import { CredentialsInput } from "@/components/contextual/CredentialsInputs/CredentialsInputs";
+import { RunAgentInputs } from "@/components/contextual/RunAgentInputs/RunAgentInputs";
+import type {
+  BlockIOCredentialsSubSchema,
+  BlockIOSubSchema,
+} from "@/lib/autogpt-server-api/types";
+import { cn } from "@/lib/utils";
+import { PlayIcon, WarningIcon } from "@phosphor-icons/react";
+import { useMemo } from "react";
+import { useAgentInputsSetup } from "./useAgentInputsSetup";
+
+interface Props {
+  agentName?: string;
+  inputSchema: Record<string, BlockIOSubSchema>;
+  credentialsSchema?: Record<string, BlockIOCredentialsSubSchema>;
+  message: string;
+  onRun: (
+    inputs: Record<string, any>,
+    credentials: Record<string, any>,
+  ) => void;
+  onCancel?: () => void;
+  className?: string;
+}
+
+export function AgentInputsSetup({
+  agentName,
+  inputSchema,
+  credentialsSchema,
+  message,
+  onRun,
+  onCancel,
+  className,
+}: Props) {
+  const { inputValues, setInputValue, credentialsValues, setCredentialsValue } =
+    useAgentInputsSetup();
+
+  const inputFields = Object.entries(inputSchema || {});
+  const credentialFields = Object.entries(credentialsSchema || {});
+
+  const allRequiredInputsAreSet = useMemo(() => {
+    const requiredFields = Object.entries(inputSchema || {}).filter(
+      ([_, schema]) => !schema.hidden,
+    );
+    return requiredFields.every(([key]) => {
+      const value = inputValues[key];
+      return value !== undefined && value !== null && value !== "";
+    });
+  }, [inputSchema, inputValues]);
+
+  const allCredentialsAreSet = useMemo(() => {
+    if (!credentialsSchema || Object.keys(credentialsSchema).length === 0) {
+      return true;
+    }
+    return Object.keys(credentialsSchema).every(
+      (key) => credentialsValues[key] !== undefined,
+    );
+  }, [credentialsSchema, credentialsValues]);
+
+  const canRun = allRequiredInputsAreSet && allCredentialsAreSet;
+
+  function handleRun() {
+    if (canRun) {
+      onRun(inputValues, credentialsValues);
+    }
+  }
+
+  return (
+    <Card
+      className={cn(
+        "mx-4 my-2 overflow-hidden border-blue-200 bg-blue-50",
+        className,
+      )}
+    >
+      <div className="flex items-start gap-4 p-6">
+        <div className="flex h-12 w-12 flex-shrink-0 items-center justify-center rounded-full bg-blue-500">
+          <WarningIcon size={24} weight="bold" className="text-white" />
+        </div>
+        <div className="flex-1">
+          <Text variant="h3" className="mb-2 text-blue-900">
+            {agentName ? `Configure ${agentName}` : "Agent Configuration"}
+          </Text>
+          <Text variant="body" className="mb-4 text-blue-700">
+            {message}
+          </Text>
+
+          {inputFields.length > 0 && (
+            <div className="mb-4 space-y-4">
+              {inputFields.map(([key, schema]) => {
+                if (schema.hidden) return null;
+                const defaultValue = (schema as any).default;
+                return (
+                  <RunAgentInputs
+                    key={key}
+                    schema={schema}
+                    value={inputValues[key] ?? defaultValue}
+                    placeholder={schema.description}
+                    onChange={(value) => setInputValue(key, value)}
+                  />
+                );
+              })}
+            </div>
+          )}
+
+          {credentialFields.length > 0 && (
+            <div className="mb-4 space-y-4">
+              {credentialFields.map(([key, schema]) => (
+                <CredentialsInput
+                  key={key}
+                  schema={schema}
+                  selectedCredentials={credentialsValues[key]}
+                  onSelectCredentials={(value) =>
+                    setCredentialsValue(key, value)
+                  }
+                  siblingInputs={inputValues}
+                />
+              ))}
+            </div>
+          )}
+
+          <div className="flex gap-2">
+            <Button
+              variant="primary"
+              size="small"
+              onClick={handleRun}
+              disabled={!canRun}
+            >
+              <PlayIcon className="mr-2 h-4 w-4" weight="bold" />
+              Run Agent
+            </Button>
+            {onCancel && (
+              <Button variant="outline" size="small" onClick={onCancel}>
+                Cancel
+              </Button>
+            )}
+          </div>
+        </div>
+      </div>
+    </Card>
+  );
+}

autogpt_platform/frontend/src/components/contextual/Chat/components/AgentInputsSetup/useAgentInputsSetup.ts

@@ -0,0 +1,38 @@
+import type { CredentialsMetaInput } from "@/lib/autogpt-server-api/types";
+import { useState } from "react";
+
+export function useAgentInputsSetup() {
+  const [inputValues, setInputValues] = useState<Record<string, any>>({});
+  const [credentialsValues, setCredentialsValues] = useState<
+    Record<string, CredentialsMetaInput>
+  >({});
+
+  function setInputValue(key: string, value: any) {
+    setInputValues((prev) => ({
+      ...prev,
+      [key]: value,
+    }));
+  }
+
+  function setCredentialsValue(key: string, value?: CredentialsMetaInput) {
+    if (value) {
+      setCredentialsValues((prev) => ({
+        ...prev,
+        [key]: value,
+      }));
+    } else {
+      setCredentialsValues((prev) => {
+        const next = { ...prev };
+        delete next[key];
+        return next;
+      });
+    }
+  }
+
+  return {
+    inputValues,
+    setInputValue,
+    credentialsValues,
+    setCredentialsValue,
+  };
+}