fix(backend): add missing metadata attribute to mock nodes in SmartDecisionMaker tests (#11750)

This PR fixes failing SmartDecisionMaker tests by adding missing
`metadata` attribute to mock nodes.

### Changes 🏗️

Mock nodes in SmartDecisionMaker tests were missing the `metadata = {}`
attribute, which was introduced in commit 4a52b7eca for the
customized_name feature. This caused tests to fail with:

```
TypeError: expected string or bytes-like object, got 'Mock'
```

**Files fixed**:
- `backend/blocks/test/test_smart_decision_maker_dict.py`: Added
`metadata = {}` to mock nodes in all 3 tests
- `backend/blocks/test/test_smart_decision_maker_dynamic_fields.py`:
Added `metadata = {}` to mock nodes in all 8 tests

**Root cause**: The `_create_block_function_signature` method calls
`sink_node.metadata.get("customized_name")`, but mock nodes in tests
didn't have the metadata attribute initialized.

### Checklist 📋

#### For code changes:
- [x] I have clearly listed my changes in the PR description
- [x] I have made a test plan
- [x] I have tested my changes according to the test plan:
- [x] Run `poetry run pytest
backend/blocks/test/test_smart_decision_maker_dict.py -xvs` - 3 passed
- [x] Run `poetry run pytest
backend/blocks/test/test_smart_decision_maker_dynamic_fields.py -xvs` -
8 passed
  - [x] All tests pass successfully

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

## Release Notes

* **Tests**
* Updated test infrastructure to enhance mock object configuration for
improved test reliability and consistency across test suites.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

.branchlet.json

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

autogpt_platform/Makefile

@@ -6,10 +6,9 @@ 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
@@ -61,4 +60,4 @@ help:
 	@echo "  run-backend - Run the backend FastAPI server"
 	@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 "  load-store-agents - Load store agents from agents/ folder into test database"

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

@@ -12,11 +12,7 @@ class ChatConfig(BaseSettings):
 
     # OpenAI API Configuration
     model: str = Field(
-        default="anthropic/claude-opus-4.5", description="Default model to use"
-    )
-    title_model: str = Field(
-        default="openai/gpt-4o-mini",
-        description="Model to use for generating session titles (should be fast/cheap)",
+        default="qwen/qwen3-235b-a22b-2507", description="Default model to use"
     )
     api_key: str | None = Field(default=None, description="OpenAI API key")
     base_url: str | None = Field(
@@ -76,31 +72,8 @@ class ChatConfig(BaseSettings):
                 v = "https://openrouter.ai/api/v1"
         return v
 
-    # Prompt paths for different contexts
-    PROMPT_PATHS: dict[str, str] = {
-        "default": "prompts/chat_system.md",
-        "onboarding": "prompts/onboarding_system.md",
-    }
-
-    def get_system_prompt_for_type(
-        self, prompt_type: str = "default", **template_vars
-    ) -> str:
-        """Load and render a system prompt by type.
-
-        Args:
-            prompt_type: The type of prompt to load ("default" or "onboarding")
-            **template_vars: Variables to substitute in the template
-
-        Returns:
-            Rendered system prompt string
-        """
-        prompt_path_str = self.PROMPT_PATHS.get(
-            prompt_type, self.PROMPT_PATHS["default"]
-        )
-        return self._load_prompt_from_path(prompt_path_str, **template_vars)
-
     def get_system_prompt(self, **template_vars) -> str:
-        """Load and render the default system prompt from file.
+        """Load and render the system prompt from file.
 
         Args:
             **template_vars: Variables to substitute in the template
@@ -109,21 +82,9 @@ class ChatConfig(BaseSettings):
             Rendered system prompt string
 
         """
-        return self._load_prompt_from_path(self.system_prompt_path, **template_vars)
-
-    def _load_prompt_from_path(self, prompt_path_str: str, **template_vars) -> str:
-        """Load and render a system prompt from a given path.
-
-        Args:
-            prompt_path_str: Path to the prompt file relative to chat module
-            **template_vars: Variables to substitute in the template
-
-        Returns:
-            Rendered system prompt string
-        """
         # Get the path relative to this module
         module_dir = Path(__file__).parent
-        prompt_path = module_dir / prompt_path_str
+        prompt_path = module_dir / self.system_prompt_path
 
         # Check for .j2 extension first (Jinja2 template)
         j2_path = Path(str(prompt_path) + ".j2")

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

@@ -1,215 +0,0 @@
-"""Database operations for chat sessions."""
-
-import logging
-from datetime import UTC, datetime
-from typing import Any, cast
-
-from prisma.models import ChatMessage as PrismaChatMessage
-from prisma.models import ChatSession as PrismaChatSession
-from prisma.types import (
-    ChatMessageCreateInput,
-    ChatSessionCreateInput,
-    ChatSessionUpdateInput,
-)
-
-from backend.util.json import SafeJson
-
-logger = logging.getLogger(__name__)
-
-
-async def get_chat_session(session_id: str) -> PrismaChatSession | None:
-    """Get a chat session by ID from the database."""
-    session = await PrismaChatSession.prisma().find_unique(
-        where={"id": session_id},
-        include={"Messages": True},
-    )
-    if session and session.Messages:
-        # Sort messages by sequence in Python since Prisma doesn't support order_by in include
-        session.Messages.sort(key=lambda m: m.sequence)
-    return session
-
-
-async def create_chat_session(
-    session_id: str,
-    user_id: str | None,
-) -> PrismaChatSession:
-    """Create a new chat session in the database."""
-    data = ChatSessionCreateInput(
-        id=session_id,
-        userId=user_id,
-        credentials=SafeJson({}),
-        successfulAgentRuns=SafeJson({}),
-        successfulAgentSchedules=SafeJson({}),
-    )
-    return await PrismaChatSession.prisma().create(
-        data=data,
-        include={"Messages": True},
-    )
-
-
-async def update_chat_session(
-    session_id: str,
-    credentials: dict[str, Any] | None = None,
-    successful_agent_runs: dict[str, Any] | None = None,
-    successful_agent_schedules: dict[str, Any] | None = None,
-    total_prompt_tokens: int | None = None,
-    total_completion_tokens: int | None = None,
-    title: str | None = None,
-) -> PrismaChatSession | None:
-    """Update a chat session's metadata."""
-    data: ChatSessionUpdateInput = {"updatedAt": datetime.now(UTC)}
-
-    if credentials is not None:
-        data["credentials"] = SafeJson(credentials)
-    if successful_agent_runs is not None:
-        data["successfulAgentRuns"] = SafeJson(successful_agent_runs)
-    if successful_agent_schedules is not None:
-        data["successfulAgentSchedules"] = SafeJson(successful_agent_schedules)
-    if total_prompt_tokens is not None:
-        data["totalPromptTokens"] = total_prompt_tokens
-    if total_completion_tokens is not None:
-        data["totalCompletionTokens"] = total_completion_tokens
-    if title is not None:
-        data["title"] = title
-
-    session = await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data=data,
-        include={"Messages": True},
-    )
-    if session and session.Messages:
-        session.Messages.sort(key=lambda m: m.sequence)
-    return session
-
-
-async def add_chat_message(
-    session_id: str,
-    role: str,
-    sequence: int,
-    content: str | None = None,
-    name: str | None = None,
-    tool_call_id: str | None = None,
-    refusal: str | None = None,
-    tool_calls: list[dict[str, Any]] | None = None,
-    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:
-        data["name"] = name
-    if tool_call_id is not None:
-        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:
-        data["functionCall"] = SafeJson(function_call)
-
-    # Update session's updatedAt timestamp
-    await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data={"updatedAt": datetime.now(UTC)},
-    )
-
-    return await PrismaChatMessage.prisma().create(
-        data=cast(ChatMessageCreateInput, data)
-    )
-
-
-async def add_chat_messages_batch(
-    session_id: str,
-    messages: list[dict[str, Any]],
-    start_sequence: int,
-) -> list[PrismaChatMessage]:
-    """Add multiple messages to a chat session in a batch."""
-    if not messages:
-        return []
-
-    created_messages = []
-    for i, msg in enumerate(messages):
-        # Build the input dict dynamically - only include optional JSON fields
-        # when they have values, as Prisma TypedDict validation fails when
-        # optional fields are explicitly set to None
-        data: dict[str, Any] = {
-            "Session": {"connect": {"id": session_id}},
-            "role": msg["role"],
-            "sequence": start_sequence + i,
-        }
-
-        # Add optional string fields
-        if msg.get("content") is not None:
-            data["content"] = msg["content"]
-        if msg.get("name") is not None:
-            data["name"] = msg["name"]
-        if msg.get("tool_call_id") is not None:
-            data["toolCallId"] = msg["tool_call_id"]
-        if msg.get("refusal") is not None:
-            data["refusal"] = msg["refusal"]
-
-        # Add optional JSON fields only when they have values
-        if msg.get("tool_calls") is not None:
-            data["toolCalls"] = SafeJson(msg["tool_calls"])
-        if msg.get("function_call") is not None:
-            data["functionCall"] = SafeJson(msg["function_call"])
-
-        created = await PrismaChatMessage.prisma().create(
-            data=cast(ChatMessageCreateInput, data)
-        )
-        created_messages.append(created)
-
-    # Update session's updatedAt timestamp
-    await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data={"updatedAt": datetime.now(UTC)},
-    )
-
-    return created_messages
-
-
-async def get_user_chat_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[PrismaChatSession]:
-    """Get chat sessions for a user, ordered by most recent."""
-    return await PrismaChatSession.prisma().find_many(
-        where={"userId": user_id},
-        order={"updatedAt": "desc"},
-        take=limit,
-        skip=offset,
-    )
-
-
-async def get_user_session_count(user_id: str) -> int:
-    """Get the total number of chat sessions for a user."""
-    return await PrismaChatSession.prisma().count(where={"userId": user_id})
-
-
-async def delete_chat_session(session_id: str) -> bool:
-    """Delete a chat session and all its messages."""
-    try:
-        await PrismaChatSession.prisma().delete(where={"id": session_id})
-        return True
-    except Exception as e:
-        logger.error(f"Failed to delete chat session {session_id}: {e}")
-        return False
-
-
-async def get_chat_session_message_count(session_id: str) -> int:
-    """Get the number of messages in a chat session."""
-    count = await PrismaChatMessage.prisma().count(where={"sessionId": session_id})
-    return count

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

@@ -16,15 +16,11 @@ from openai.types.chat.chat_completion_message_tool_call_param import (
     ChatCompletionMessageToolCallParam,
     Function,
 )
-from prisma.models import ChatMessage as PrismaChatMessage
-from prisma.models import ChatSession as PrismaChatSession
 from pydantic import BaseModel
 
 from backend.data.redis_client import get_redis_async
-from backend.util import json
 from backend.util.exceptions import RedisError
 
-from . import db as chat_db
 from .config import ChatConfig
 
 logger = logging.getLogger(__name__)
@@ -50,7 +46,6 @@ class Usage(BaseModel):
 class ChatSession(BaseModel):
     session_id: str
     user_id: str | None
-    title: str | None = None
     messages: list[ChatMessage]
     usage: list[Usage]
     credentials: dict[str, dict] = {}  # Map of provider -> credential metadata
@@ -64,7 +59,6 @@ class ChatSession(BaseModel):
         return ChatSession(
             session_id=str(uuid.uuid4()),
             user_id=user_id,
-            title=None,
             messages=[],
             usage=[],
             credentials={},
@@ -72,85 +66,6 @@ class ChatSession(BaseModel):
             updated_at=datetime.now(UTC),
         )
 
-    @staticmethod
-    def from_prisma(
-        prisma_session: PrismaChatSession,
-        prisma_messages: list[PrismaChatMessage] | None = None,
-    ) -> "ChatSession":
-        """Convert Prisma models to Pydantic ChatSession."""
-        messages = []
-        if prisma_messages:
-            for msg in prisma_messages:
-                tool_calls = None
-                if msg.toolCalls:
-                    tool_calls = (
-                        json.loads(msg.toolCalls)
-                        if isinstance(msg.toolCalls, str)
-                        else msg.toolCalls
-                    )
-
-                function_call = None
-                if msg.functionCall:
-                    function_call = (
-                        json.loads(msg.functionCall)
-                        if isinstance(msg.functionCall, str)
-                        else msg.functionCall
-                    )
-
-                messages.append(
-                    ChatMessage(
-                        role=msg.role,
-                        content=msg.content,
-                        name=msg.name,
-                        tool_call_id=msg.toolCallId,
-                        refusal=msg.refusal,
-                        tool_calls=tool_calls,
-                        function_call=function_call,
-                    )
-                )
-
-        # Parse JSON fields from Prisma
-        credentials = (
-            json.loads(prisma_session.credentials)
-            if isinstance(prisma_session.credentials, str)
-            else prisma_session.credentials or {}
-        )
-        successful_agent_runs = (
-            json.loads(prisma_session.successfulAgentRuns)
-            if isinstance(prisma_session.successfulAgentRuns, str)
-            else prisma_session.successfulAgentRuns or {}
-        )
-        successful_agent_schedules = (
-            json.loads(prisma_session.successfulAgentSchedules)
-            if isinstance(prisma_session.successfulAgentSchedules, str)
-            else prisma_session.successfulAgentSchedules or {}
-        )
-
-        # Calculate usage from token counts
-        usage = []
-        if prisma_session.totalPromptTokens or prisma_session.totalCompletionTokens:
-            usage.append(
-                Usage(
-                    prompt_tokens=prisma_session.totalPromptTokens or 0,
-                    completion_tokens=prisma_session.totalCompletionTokens or 0,
-                    total_tokens=(prisma_session.totalPromptTokens or 0)
-                    + (prisma_session.totalCompletionTokens or 0),
-                )
-            )
-
-        return ChatSession(
-            session_id=prisma_session.id,
-            user_id=prisma_session.userId,
-            title=prisma_session.title,
-            messages=messages,
-            usage=usage,
-            credentials=credentials,
-            started_at=prisma_session.createdAt,
-            updated_at=prisma_session.updatedAt,
-            successful_agent_runs=successful_agent_runs,
-            successful_agent_schedules=successful_agent_schedules,
-        )
-
     def to_openai_messages(self) -> list[ChatCompletionMessageParam]:
         messages = []
         for message in self.messages:
@@ -240,234 +155,50 @@ class ChatSession(BaseModel):
         return messages
 
 
-async def _get_session_from_cache(session_id: str) -> ChatSession | None:
-    """Get a chat session from Redis cache."""
-    redis_key = f"chat:session:{session_id}"
-    async_redis = await get_redis_async()
-    raw_session: bytes | None = await async_redis.get(redis_key)
-
-    if raw_session is None:
-        return None
-
-    try:
-        session = ChatSession.model_validate_json(raw_session)
-        logger.info(
-            f"Loading session {session_id} from cache: "
-            f"message_count={len(session.messages)}, "
-            f"roles={[m.role for m in session.messages]}"
-        )
-        return session
-    except Exception as e:
-        logger.error(f"Failed to deserialize session {session_id}: {e}", exc_info=True)
-        raise RedisError(f"Corrupted session data for {session_id}") from e
-
-
-async def _cache_session(session: ChatSession) -> None:
-    """Cache a chat session in Redis."""
-    redis_key = f"chat:session:{session.session_id}"
-    async_redis = await get_redis_async()
-    await async_redis.setex(redis_key, config.session_ttl, session.model_dump_json())
-
-
-async def _get_session_from_db(session_id: str) -> ChatSession | None:
-    """Get a chat session from the database."""
-    prisma_session = await chat_db.get_chat_session(session_id)
-    if not prisma_session:
-        return None
-
-    messages = prisma_session.Messages
-    logger.info(
-        f"Loading session {session_id} from DB: "
-        f"has_messages={messages is not None}, "
-        f"message_count={len(messages) if messages else 0}, "
-        f"roles={[m.role for m in messages] if messages else []}"
-    )
-
-    return ChatSession.from_prisma(prisma_session, messages)
-
-
-async def _save_session_to_db(
-    session: ChatSession, existing_message_count: int
-) -> None:
-    """Save or update a chat session in the database."""
-    # Check if session exists in DB
-    existing = await chat_db.get_chat_session(session.session_id)
-
-    if not existing:
-        # Create new session
-        await chat_db.create_chat_session(
-            session_id=session.session_id,
-            user_id=session.user_id,
-        )
-        existing_message_count = 0
-
-    # Calculate total tokens from usage
-    total_prompt = sum(u.prompt_tokens for u in session.usage)
-    total_completion = sum(u.completion_tokens for u in session.usage)
-
-    # Update session metadata
-    await chat_db.update_chat_session(
-        session_id=session.session_id,
-        credentials=session.credentials,
-        successful_agent_runs=session.successful_agent_runs,
-        successful_agent_schedules=session.successful_agent_schedules,
-        total_prompt_tokens=total_prompt,
-        total_completion_tokens=total_completion,
-    )
-
-    # Add new messages (only those after existing count)
-    new_messages = session.messages[existing_message_count:]
-    if new_messages:
-        messages_data = []
-        for msg in new_messages:
-            messages_data.append(
-                {
-                    "role": msg.role,
-                    "content": msg.content,
-                    "name": msg.name,
-                    "tool_call_id": msg.tool_call_id,
-                    "refusal": msg.refusal,
-                    "tool_calls": msg.tool_calls,
-                    "function_call": msg.function_call,
-                }
-            )
-        logger.info(
-            f"Saving {len(new_messages)} new messages to DB for session {session.session_id}: "
-            f"roles={[m['role'] for m in messages_data]}, "
-            f"start_sequence={existing_message_count}"
-        )
-        await chat_db.add_chat_messages_batch(
-            session_id=session.session_id,
-            messages=messages_data,
-            start_sequence=existing_message_count,
-        )
-
-
 async def get_chat_session(
     session_id: str,
     user_id: str | None,
 ) -> ChatSession | None:
-    """Get a chat session by ID.
+    """Get a chat session by ID."""
+    redis_key = f"chat:session:{session_id}"
+    async_redis = await get_redis_async()
 
-    Checks Redis cache first, falls back to database if not found.
-    Caches database results back to Redis.
-    """
-    # Try cache first
-    try:
-        session = await _get_session_from_cache(session_id)
-        if session:
-            # Verify user ownership
-            if session.user_id is not None and session.user_id != user_id:
-                logger.warning(
-                    f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
-                )
-                return None
-            return session
-    except RedisError:
-        logger.warning(f"Cache error for session {session_id}, trying database")
-    except Exception as e:
-        logger.warning(f"Unexpected cache error for session {session_id}: {e}")
+    raw_session: bytes | None = await async_redis.get(redis_key)
 
-    # Fall back to database
-    logger.info(f"Session {session_id} not in cache, checking database")
-    session = await _get_session_from_db(session_id)
-
-    if session is None:
-        logger.warning(f"Session {session_id} not found in cache or database")
+    if raw_session is None:
+        logger.warning(f"Session {session_id} not found in Redis")
         return None
 
-    # Verify user ownership
+    try:
+        session = ChatSession.model_validate_json(raw_session)
+    except Exception as e:
+        logger.error(f"Failed to deserialize session {session_id}: {e}", exc_info=True)
+        raise RedisError(f"Corrupted session data for {session_id}") from e
+
     if session.user_id is not None and session.user_id != user_id:
         logger.warning(
             f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
         )
         return None
 
-    # Cache the session from DB
-    try:
-        await _cache_session(session)
-        logger.info(f"Cached session {session_id} from database")
-    except Exception as e:
-        logger.warning(f"Failed to cache session {session_id}: {e}")
-
     return session
 
 
 async def upsert_chat_session(
     session: ChatSession,
 ) -> ChatSession:
-    """Update a chat session in both cache and database."""
-    # Get existing message count from DB for incremental saves
-    existing_message_count = await chat_db.get_chat_session_message_count(
-        session.session_id
+    """Update a chat session with the given messages."""
+
+    redis_key = f"chat:session:{session.session_id}"
+
+    async_redis = await get_redis_async()
+    resp = await async_redis.setex(
+        redis_key, config.session_ttl, session.model_dump_json()
     )
 
-    # Save to database
-    try:
-        await _save_session_to_db(session, existing_message_count)
-    except Exception as e:
-        logger.error(f"Failed to save session {session.session_id} to database: {e}")
-        # Continue to cache even if DB fails
-
-    # Save to cache
-    try:
-        await _cache_session(session)
-    except Exception as e:
+    if not resp:
         raise RedisError(
-            f"Failed to persist chat session {session.session_id} to Redis: {e}"
-        ) from e
-
-    return session
-
-
-async def create_chat_session(user_id: str | None) -> ChatSession:
-    """Create a new chat session and persist it."""
-    session = ChatSession.new(user_id)
-
-    # Create in database first
-    try:
-        await chat_db.create_chat_session(
-            session_id=session.session_id,
-            user_id=user_id,
+            f"Failed to persist chat session {session.session_id} to Redis: {resp}"
         )
-    except Exception as e:
-        logger.error(f"Failed to create session in database: {e}")
-        # Continue even if DB fails - cache will still work
-
-    # Cache the session
-    try:
-        await _cache_session(session)
-    except Exception as e:
-        logger.warning(f"Failed to cache new session: {e}")
 
     return session
-
-
-async def get_user_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[ChatSession]:
-    """Get all chat sessions for a user from the database."""
-    prisma_sessions = await chat_db.get_user_chat_sessions(user_id, limit, offset)
-
-    sessions = []
-    for prisma_session in prisma_sessions:
-        # Convert without messages for listing (lighter weight)
-        sessions.append(ChatSession.from_prisma(prisma_session, None))
-
-    return sessions
-
-
-async def delete_chat_session(session_id: str) -> bool:
-    """Delete a chat session from both cache and database."""
-    # Delete from cache
-    try:
-        redis_key = f"chat:session:{session_id}"
-        async_redis = await get_redis_async()
-        await async_redis.delete(redis_key)
-    except Exception as e:
-        logger.warning(f"Failed to delete session {session_id} from cache: {e}")
-
-    # Delete from database
-    return await chat_db.delete_chat_session(session_id)

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

@@ -68,50 +68,3 @@ async def test_chatsession_redis_storage_user_id_mismatch():
     s2 = await get_chat_session(s.session_id, None)
 
     assert s2 is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_db_storage():
-    """Test that messages are correctly saved to and loaded from DB (not cache)."""
-    from backend.data.redis_client import get_redis_async
-
-    # Create session with messages including assistant message
-    s = ChatSession.new(user_id=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)
-
-    # Clear the Redis cache to force DB load
-    redis_key = f"chat:session:{s.session_id}"
-    async_redis = await get_redis_async()
-    await async_redis.delete(redis_key)
-
-    # Load from DB (cache was cleared)
-    s2 = await get_chat_session(
-        session_id=s.session_id,
-        user_id=s.user_id,
-    )
-
-    assert s2 is not None, "Session not found after loading from DB"
-    assert len(s2.messages) == len(
-        s.messages
-    ), f"Message count mismatch: expected {len(s.messages)}, got {len(s2.messages)}"
-
-    # Verify all roles are present
-    roles = [m.role for m in s2.messages]
-    assert "user" in roles, f"User message missing. Roles found: {roles}"
-    assert "assistant" in roles, f"Assistant message missing. Roles found: {roles}"
-    assert "tool" in roles, f"Tool message missing. Roles found: {roles}"
-
-    # Verify message content
-    for orig, loaded in zip(s.messages, s2.messages):
-        assert orig.role == loaded.role, f"Role mismatch: {orig.role} != {loaded.role}"
-        assert (
-            orig.content == loaded.content
-        ), f"Content mismatch for {orig.role}: {orig.content} != {loaded.content}"
-        if orig.tool_calls:
-            assert (
-                loaded.tool_calls is not None
-            ), f"Tool calls missing for {orig.role} message"
-            assert len(orig.tool_calls) == len(loaded.tool_calls)

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

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

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

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

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

@@ -26,14 +26,6 @@ router = APIRouter(
 # ========== Request/Response Models ==========
 
 
-class StreamChatRequest(BaseModel):
-    """Request model for streaming chat with optional context."""
-
-    message: str
-    is_user_message: bool = True
-    context: dict[str, str] | None = None  # {url: str, content: str}
-
-
 class CreateSessionResponse(BaseModel):
     """Response model containing information on a newly created chat session."""
 
@@ -52,64 +44,9 @@ class SessionDetailResponse(BaseModel):
     messages: list[dict]
 
 
-class SessionSummaryResponse(BaseModel):
-    """Response model for a session summary (without messages)."""
-
-    id: str
-    created_at: str
-    updated_at: str
-    title: str | None = None
-
-
-class ListSessionsResponse(BaseModel):
-    """Response model for listing chat sessions."""
-
-    sessions: list[SessionSummaryResponse]
-    total: int
-
-
 # ========== Routes ==========
 
 
-@router.get(
-    "/sessions",
-    dependencies=[Security(auth.requires_user)],
-)
-async def list_sessions(
-    user_id: Annotated[str, Security(auth.get_user_id)],
-    limit: int = Query(default=50, ge=1, le=100),
-    offset: int = Query(default=0, ge=0),
-) -> ListSessionsResponse:
-    """
-    List chat sessions for the authenticated user.
-
-    Returns a paginated list of chat sessions belonging to the current user,
-    ordered by most recently updated.
-
-    Args:
-        user_id: The authenticated user's ID.
-        limit: Maximum number of sessions to return (1-100).
-        offset: Number of sessions to skip for pagination.
-
-    Returns:
-        ListSessionsResponse: List of session summaries and total count.
-    """
-    sessions = await chat_service.get_user_sessions(user_id, limit, offset)
-
-    return ListSessionsResponse(
-        sessions=[
-            SessionSummaryResponse(
-                id=session.session_id,
-                created_at=session.started_at.isoformat(),
-                updated_at=session.updated_at.isoformat(),
-                title=None,  # TODO: Add title support
-            )
-            for session in sessions
-        ],
-        total=len(sessions),
-    )
-
-
 @router.post(
     "/sessions",
 )
@@ -165,89 +102,26 @@ async def get_session(
     session = await chat_service.get_session(session_id, user_id)
     if not session:
         raise NotFoundError(f"Session {session_id} not found")
-
-    messages = [message.model_dump() for message in session.messages]
-    logger.info(
-        f"Returning session {session_id}: "
-        f"message_count={len(messages)}, "
-        f"roles={[m.get('role') for m in messages]}"
-    )
-
     return SessionDetailResponse(
         id=session.session_id,
         created_at=session.started_at.isoformat(),
         updated_at=session.updated_at.isoformat(),
         user_id=session.user_id or None,
-        messages=messages,
-    )
-
-
-@router.post(
-    "/sessions/{session_id}/stream",
-)
-async def stream_chat_post(
-    session_id: str,
-    request: StreamChatRequest,
-    user_id: str | None = Depends(auth.get_user_id),
-):
-    """
-    Stream chat responses for a session (POST with context support).
-
-    Streams the AI/completion responses in real time over Server-Sent Events (SSE), including:
-      - Text fragments as they are generated
-      - Tool call UI elements (if invoked)
-      - Tool execution results
-
-    Args:
-        session_id: The chat session identifier to associate with the streamed messages.
-        request: Request body containing message, is_user_message, and optional context.
-        user_id: Optional authenticated user ID.
-    Returns:
-        StreamingResponse: SSE-formatted response chunks.
-
-    """
-    # Validate session exists before starting the stream
-    # This prevents errors after the response has already started
-    session = await chat_service.get_session(session_id, user_id)
-
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found. ")
-    if session.user_id is None and user_id is not None:
-        session = await chat_service.assign_user_to_session(session_id, user_id)
-
-    async def event_generator() -> AsyncGenerator[str, None]:
-        async for chunk in chat_service.stream_chat_completion(
-            session_id,
-            request.message,
-            is_user_message=request.is_user_message,
-            user_id=user_id,
-            session=session,  # Pass pre-fetched session to avoid double-fetch
-            context=request.context,
-        ):
-            yield chunk.to_sse()
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",  # Disable nginx buffering
-        },
+        messages=[message.model_dump() for message in session.messages],
     )
 
 
 @router.get(
     "/sessions/{session_id}/stream",
 )
-async def stream_chat_get(
+async def stream_chat(
     session_id: str,
     message: Annotated[str, Query(min_length=1, max_length=10000)],
     user_id: str | None = Depends(auth.get_user_id),
     is_user_message: bool = Query(default=True),
 ):
     """
-    Stream chat responses for a session (GET - legacy endpoint).
+    Stream chat responses for a session.
 
     Streams the AI/completion responses in real time over Server-Sent Events (SSE), including:
       - Text fragments as they are generated
@@ -319,133 +193,6 @@ async def session_assign_user(
     return {"status": "ok"}
 
 
-# ========== Onboarding Routes ==========
-# These routes use a specialized onboarding system prompt
-
-
-@router.post(
-    "/onboarding/sessions",
-)
-async def create_onboarding_session(
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> CreateSessionResponse:
-    """
-    Create a new onboarding chat session.
-
-    Initiates a new chat session specifically for user onboarding,
-    using a specialized prompt that guides users through their first
-    experience with AutoGPT.
-
-    Args:
-        user_id: The optional authenticated user ID parsed from the JWT.
-
-    Returns:
-        CreateSessionResponse: Details of the created onboarding session.
-    """
-    logger.info(
-        f"Creating onboarding session with user_id: "
-        f"...{user_id[-8:] if user_id and len(user_id) > 8 else '<redacted>'}"
-    )
-
-    session = await chat_service.create_chat_session(user_id)
-
-    return CreateSessionResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        user_id=session.user_id or None,
-    )
-
-
-@router.get(
-    "/onboarding/sessions/{session_id}",
-)
-async def get_onboarding_session(
-    session_id: str,
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> SessionDetailResponse:
-    """
-    Retrieve the details of an onboarding chat session.
-
-    Args:
-        session_id: The unique identifier for the onboarding session.
-        user_id: The optional authenticated user ID.
-
-    Returns:
-        SessionDetailResponse: Details for the requested session.
-    """
-    session = await chat_service.get_session(session_id, user_id)
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found")
-
-    messages = [message.model_dump() for message in session.messages]
-    logger.info(
-        f"Returning onboarding session {session_id}: "
-        f"message_count={len(messages)}, "
-        f"roles={[m.get('role') for m in messages]}"
-    )
-
-    return SessionDetailResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        updated_at=session.updated_at.isoformat(),
-        user_id=session.user_id or None,
-        messages=messages,
-    )
-
-
-@router.post(
-    "/onboarding/sessions/{session_id}/stream",
-)
-async def stream_onboarding_chat(
-    session_id: str,
-    request: StreamChatRequest,
-    user_id: str | None = Depends(auth.get_user_id),
-):
-    """
-    Stream onboarding chat responses for a session.
-
-    Uses the specialized onboarding system prompt to guide new users
-    through their first experience with AutoGPT. Streams AI responses
-    in real time over Server-Sent Events (SSE).
-
-    Args:
-        session_id: The onboarding session identifier.
-        request: Request body containing message and optional context.
-        user_id: Optional authenticated user ID.
-
-    Returns:
-        StreamingResponse: SSE-formatted response chunks.
-    """
-    session = await chat_service.get_session(session_id, user_id)
-
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found.")
-    if session.user_id is None and user_id is not None:
-        session = await chat_service.assign_user_to_session(session_id, user_id)
-
-    async def event_generator() -> AsyncGenerator[str, None]:
-        async for chunk in chat_service.stream_chat_completion(
-            session_id,
-            request.message,
-            is_user_message=request.is_user_message,
-            user_id=user_id,
-            session=session,
-            context=request.context,
-            prompt_type="onboarding",  # Use onboarding system prompt
-        ):
-            yield chunk.to_sse()
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
-
-
 # ========== Health Check ==========
 
 

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

@@ -7,17 +7,16 @@ import orjson
 from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletionChunk, ChatCompletionToolParam
 
-from backend.data.understanding import (
-    format_understanding_for_prompt,
-    get_business_understanding,
-)
 from backend.util.exceptions import NotFoundError
 
-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 .response_model import (
     StreamBaseResponse,
     StreamEnd,
@@ -37,109 +36,15 @@ config = ChatConfig()
 client = AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
 
 
-async def _is_first_session(user_id: str) -> bool:
-    """Check if this is the user's first chat session.
-
-    Returns True if the user has 1 or fewer sessions (meaning this is their first).
-    """
-    try:
-        session_count = await chat_db.get_user_session_count(user_id)
-        return session_count <= 1
-    except Exception as e:
-        logger.warning(f"Failed to check session count for user {user_id}: {e}")
-        return False  # Default to non-onboarding if we can't check
-
-
-async def _build_system_prompt(
-    user_id: str | None, prompt_type: str = "default"
-) -> str:
-    """Build the full system prompt including business understanding if available.
-
-    Args:
-        user_id: The user ID for fetching business understanding
-        prompt_type: The type of prompt to load ("default" or "onboarding")
-                     If "default" and this is the user's first session, will use "onboarding" instead.
-
-    Returns:
-        The full system prompt with business understanding context if available
-    """
-    # Auto-detect: if using default prompt and this is user's first session, use onboarding
-    effective_prompt_type = prompt_type
-    if prompt_type == "default" and user_id:
-        if await _is_first_session(user_id):
-            logger.info("First session detected for user, using onboarding 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 user is authenticated, try to fetch their business understanding
-    if user_id:
-        try:
-            understanding = await get_business_understanding(user_id)
-            if understanding:
-                context = format_understanding_for_prompt(understanding)
-                if context:
-                    return (
-                        f"{base_prompt}\n\n---\n\n"
-                        f"{context}\n\n"
-                        "Use this context to provide more personalized recommendations "
-                        "and to better understand the user's business needs when "
-                        "suggesting agents and automations."
-                    )
-        except Exception as e:
-            logger.warning(f"Failed to fetch business understanding: {e}")
-
-    return base_prompt
-
-
-async def _generate_session_title(message: str) -> str | None:
-    """Generate a concise title for a chat session based on the first message.
-
-    Args:
-        message: The first user message in the session
-
-    Returns:
-        A short title (3-6 words) or None if generation fails
-    """
-    try:
-        response = await client.chat.completions.create(
-            model=config.title_model,
-            messages=[
-                {
-                    "role": "system",
-                    "content": (
-                        "Generate a very short title (3-6 words) for a chat conversation "
-                        "based on the user's first message. The title should capture the "
-                        "main topic or intent. Return ONLY the title, no quotes or punctuation."
-                    ),
-                },
-                {"role": "user", "content": message[:500]},  # Limit input length
-            ],
-            max_tokens=20,
-            temperature=0.7,
-        )
-        title = response.choices[0].message.content
-        if title:
-            # Clean up the title
-            title = title.strip().strip("\"'")
-            # Limit length
-            if len(title) > 50:
-                title = title[:47] + "..."
-            return title
-        return None
-    except Exception as e:
-        logger.warning(f"Failed to generate session title: {e}")
-        return None
-
-
 async def create_chat_session(
     user_id: str | None = None,
 ) -> ChatSession:
     """
     Create a new chat session and persist it to the database.
     """
-    return await model_create_chat_session(user_id)
+    session = ChatSession.new(user_id)
+    # Persist the session immediately so it can be used for streaming
+    return await upsert_chat_session(session)
 
 
 async def get_session(
@@ -152,19 +57,6 @@ async def get_session(
     return await get_chat_session(session_id, user_id)
 
 
-async def get_user_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[ChatSession]:
-    """
-    Get all chat sessions for a user.
-    """
-    from .model import get_user_sessions as model_get_user_sessions
-
-    return await model_get_user_sessions(user_id, limit, offset)
-
-
 async def assign_user_to_session(
     session_id: str,
     user_id: str,
@@ -186,8 +78,6 @@ async def stream_chat_completion(
     user_id: str | None = None,
     retry_count: int = 0,
     session: ChatSession | None = None,
-    context: dict[str, str] | None = None,  # {url: str, content: str}
-    prompt_type: str = "default",
 ) -> AsyncGenerator[StreamBaseResponse, None]:
     """Main entry point for streaming chat completions with database handling.
 
@@ -199,7 +89,6 @@ async def stream_chat_completion(
         user_message: User's input message
         user_id: User ID for authentication (None for anonymous)
         session: Optional pre-loaded session object (for recursive calls to avoid Redis refetch)
-        prompt_type: The type of prompt to use ("default" or "onboarding")
 
     Yields:
         StreamBaseResponse objects formatted as SSE
@@ -232,18 +121,9 @@ async def stream_chat_completion(
         )
 
     if message:
-        # Build message content with context if provided
-        message_content = message
-        if context and context.get("url") and context.get("content"):
-            context_text = f"Page URL: {context['url']}\n\nPage Content:\n{context['content']}\n\n---\n\nUser Message: {message}"
-            message_content = context_text
-            logger.info(
-                f"Including page context: URL={context['url']}, content_length={len(context['content'])}"
-            )
-
         session.messages.append(
             ChatMessage(
-                role="user" if is_user_message else "assistant", content=message_content
+                role="user" if is_user_message else "assistant", content=message
             )
         )
         logger.info(
@@ -261,32 +141,6 @@ async def stream_chat_completion(
     session = await upsert_chat_session(session)
     assert session, "Session not found"
 
-    # Generate title for new sessions on first user message (non-blocking)
-    # Check: is_user_message, no title yet, and this is the first user message
-    if is_user_message and message and not session.title:
-        user_messages = [m for m in session.messages if m.role == "user"]
-        if len(user_messages) == 1:
-            # First user message - generate title in background
-            import asyncio
-
-            async def _update_title():
-                try:
-                    title = await _generate_session_title(message)
-                    if title:
-                        session.title = title
-                        await upsert_chat_session(session)
-                        logger.info(
-                            f"Generated title for session {session_id}: {title}"
-                        )
-                except Exception as e:
-                    logger.warning(f"Failed to update session title: {e}")
-
-            # Fire and forget - don't block the chat response
-            asyncio.create_task(_update_title())
-
-    # Build system prompt with business understanding
-    system_prompt = await _build_system_prompt(user_id, prompt_type)
-
     assistant_response = ChatMessage(
         role="assistant",
         content="",
@@ -305,7 +159,6 @@ async def stream_chat_completion(
         async for chunk in _stream_chat_chunks(
             session=session,
             tools=tools,
-            system_prompt=system_prompt,
         ):
 
             if isinstance(chunk, StreamTextChunk):
@@ -426,7 +279,6 @@ async def stream_chat_completion(
             user_id=user_id,
             retry_count=retry_count + 1,
             session=session,
-            prompt_type=prompt_type,
         ):
             yield chunk
         return  # Exit after retry to avoid double-saving in finally block
@@ -472,7 +324,6 @@ async def stream_chat_completion(
             session_id=session.session_id,
             user_id=user_id,
             session=session,  # Pass session object to avoid Redis refetch
-            prompt_type=prompt_type,
         ):
             yield chunk
 
@@ -480,7 +331,6 @@ async def stream_chat_completion(
 async def _stream_chat_chunks(
     session: ChatSession,
     tools: list[ChatCompletionToolParam],
-    system_prompt: str | None = None,
 ) -> AsyncGenerator[StreamBaseResponse, None]:
     """
     Pure streaming function for OpenAI chat completions with tool calling.
@@ -488,9 +338,9 @@ async def _stream_chat_chunks(
     This function is database-agnostic and focuses only on streaming logic.
 
     Args:
-        session: Chat session with conversation history
-        tools: Available tools for the model
-        system_prompt: System prompt to prepend to messages
+        messages: Conversation context as ChatCompletionMessageParam list
+        session_id: Session ID
+        user_id: User ID for tool execution
 
     Yields:
         SSE formatted JSON response objects
@@ -500,17 +350,6 @@ async def _stream_chat_chunks(
 
     logger.info("Starting pure chat stream")
 
-    # Build messages with system prompt prepended
-    messages = session.to_openai_messages()
-    if system_prompt:
-        from openai.types.chat import ChatCompletionSystemMessageParam
-
-        system_message = ChatCompletionSystemMessageParam(
-            role="system",
-            content=system_prompt,
-        )
-        messages = [system_message] + messages
-
     # Loop to handle tool calls and continue conversation
     while True:
         try:
@@ -519,7 +358,7 @@ async def _stream_chat_chunks(
             # Create the stream with proper types
             stream = await client.chat.completions.create(
                 model=model,
-                messages=messages,
+                messages=session.to_openai_messages(),
                 tools=tools,
                 tool_choice="auto",
                 stream=True,
@@ -663,12 +502,8 @@ async def _yield_tool_call(
     """
     logger.info(f"Yielding tool call: {tool_calls[yield_idx]}")
 
-    # Parse tool call arguments - handle empty arguments gracefully
-    raw_arguments = tool_calls[yield_idx]["function"]["arguments"]
-    if raw_arguments:
-        arguments = orjson.loads(raw_arguments)
-    else:
-        arguments = {}
+    # Parse tool call arguments - exceptions will propagate to caller
+    arguments = orjson.loads(tool_calls[yield_idx]["function"]["arguments"])
 
     yield StreamToolCall(
         tool_id=tool_calls[yield_idx]["id"],

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

@@ -4,30 +4,21 @@ from openai.types.chat import ChatCompletionToolParam
 
 from backend.api.features.chat.model import ChatSession
 
-from .add_understanding import AddUnderstandingTool
-from .agent_output import AgentOutputTool
 from .base import BaseTool
 from .find_agent import FindAgentTool
-from .find_library_agent import FindLibraryAgentTool
 from .run_agent import RunAgentTool
 
 if TYPE_CHECKING:
     from backend.api.features.chat.response_model import StreamToolExecutionResult
 
 # Initialize tool instances
-add_understanding_tool = AddUnderstandingTool()
 find_agent_tool = FindAgentTool()
-find_library_agent_tool = FindLibraryAgentTool()
 run_agent_tool = RunAgentTool()
-agent_output_tool = AgentOutputTool()
 
 # Export tools as OpenAI format
 tools: list[ChatCompletionToolParam] = [
-    add_understanding_tool.as_openai_tool(),
     find_agent_tool.as_openai_tool(),
-    find_library_agent_tool.as_openai_tool(),
     run_agent_tool.as_openai_tool(),
-    agent_output_tool.as_openai_tool(),
 ]
 
 
@@ -40,11 +31,8 @@ async def execute_tool(
 ) -> "StreamToolExecutionResult":
 
     tool_map: dict[str, BaseTool] = {
-        "add_understanding": add_understanding_tool,
         "find_agent": find_agent_tool,
-        "find_library_agent": find_library_agent_tool,
         "run_agent": run_agent_tool,
-        "agent_output": agent_output_tool,
     }
     if tool_name not in tool_map:
         raise ValueError(f"Tool {tool_name} not found")

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

@@ -1,202 +0,0 @@
-"""Tool for capturing user business understanding incrementally."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.data.understanding import (
-    BusinessUnderstandingInput,
-    upsert_business_understanding,
-)
-
-from .base import BaseTool
-from .models import ErrorResponse, ToolResponseBase, UnderstandingUpdatedResponse
-
-logger = logging.getLogger(__name__)
-
-
-class AddUnderstandingTool(BaseTool):
-    """Tool for capturing user's business understanding incrementally."""
-
-    @property
-    def name(self) -> str:
-        return "add_understanding"
-
-    @property
-    def description(self) -> str:
-        return """Capture and store information about the user's business context,
-workflows, pain points, and automation goals. Call this tool whenever the user
-shares information about their business. Each call incrementally adds to the
-existing understanding - you don't need to provide all fields at once.
-
-Use this to build a comprehensive profile that helps recommend better agents
-and automations for the user's specific needs."""
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "user_name": {
-                    "type": "string",
-                    "description": "The user's name",
-                },
-                "job_title": {
-                    "type": "string",
-                    "description": "The user's job title (e.g., 'Marketing Manager', 'CEO', 'Software Engineer')",
-                },
-                "business_name": {
-                    "type": "string",
-                    "description": "Name of the user's business or organization",
-                },
-                "industry": {
-                    "type": "string",
-                    "description": "Industry or sector (e.g., 'e-commerce', 'healthcare', 'finance')",
-                },
-                "business_size": {
-                    "type": "string",
-                    "description": "Company size: '1-10', '11-50', '51-200', '201-1000', or '1000+'",
-                },
-                "user_role": {
-                    "type": "string",
-                    "description": "User's role in organization context (e.g., 'decision maker', 'implementer', 'end user')",
-                },
-                "key_workflows": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Key business workflows (e.g., 'lead qualification', 'content publishing')",
-                },
-                "daily_activities": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Regular daily activities the user performs",
-                },
-                "pain_points": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Current pain points or challenges",
-                },
-                "bottlenecks": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Process bottlenecks slowing things down",
-                },
-                "manual_tasks": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Manual or repetitive tasks that could be automated",
-                },
-                "automation_goals": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Desired automation outcomes or goals",
-                },
-                "current_software": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Software and tools currently in use",
-                },
-                "existing_automation": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Any existing automations or integrations",
-                },
-                "additional_notes": {
-                    "type": "string",
-                    "description": "Any other relevant context or notes",
-                },
-            },
-            "required": [],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        """Requires authentication to store user-specific data."""
-        return True
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """
-        Capture and store business understanding incrementally.
-
-        Each call merges new data with existing understanding:
-        - String fields are overwritten if provided
-        - List fields are appended (with deduplication)
-        """
-        session_id = session.session_id
-
-        if not user_id:
-            return ErrorResponse(
-                message="Authentication required to save business understanding.",
-                session_id=session_id,
-            )
-
-        # Check if any data was provided
-        if not any(v is not None for v in kwargs.values()):
-            return ErrorResponse(
-                message="Please provide at least one field to update.",
-                session_id=session_id,
-            )
-
-        # Build input model
-        input_data = BusinessUnderstandingInput(
-            user_name=kwargs.get("user_name"),
-            job_title=kwargs.get("job_title"),
-            business_name=kwargs.get("business_name"),
-            industry=kwargs.get("industry"),
-            business_size=kwargs.get("business_size"),
-            user_role=kwargs.get("user_role"),
-            key_workflows=kwargs.get("key_workflows"),
-            daily_activities=kwargs.get("daily_activities"),
-            pain_points=kwargs.get("pain_points"),
-            bottlenecks=kwargs.get("bottlenecks"),
-            manual_tasks=kwargs.get("manual_tasks"),
-            automation_goals=kwargs.get("automation_goals"),
-            current_software=kwargs.get("current_software"),
-            existing_automation=kwargs.get("existing_automation"),
-            additional_notes=kwargs.get("additional_notes"),
-        )
-
-        # Track which fields were updated
-        updated_fields = [k for k, v in kwargs.items() if v is not None]
-
-        # Upsert with merge
-        understanding = await upsert_business_understanding(user_id, input_data)
-
-        # Build current understanding summary for the response
-        current_understanding = {
-            "user_name": understanding.user_name,
-            "job_title": understanding.job_title,
-            "business_name": understanding.business_name,
-            "industry": understanding.industry,
-            "business_size": understanding.business_size,
-            "user_role": understanding.user_role,
-            "key_workflows": understanding.key_workflows,
-            "daily_activities": understanding.daily_activities,
-            "pain_points": understanding.pain_points,
-            "bottlenecks": understanding.bottlenecks,
-            "manual_tasks": understanding.manual_tasks,
-            "automation_goals": understanding.automation_goals,
-            "current_software": understanding.current_software,
-            "existing_automation": understanding.existing_automation,
-            "additional_notes": understanding.additional_notes,
-        }
-
-        # Filter out empty values for cleaner response
-        current_understanding = {
-            k: v
-            for k, v in current_understanding.items()
-            if v is not None and v != [] and v != ""
-        }
-
-        return UnderstandingUpdatedResponse(
-            message=f"Updated understanding with: {', '.join(updated_fields)}. "
-            "I now have a better picture of your business context.",
-            session_id=session_id,
-            updated_fields=updated_fields,
-            current_understanding=current_understanding,
-        )

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

@@ -1,455 +0,0 @@
-"""Tool for retrieving agent execution outputs from user's library."""
-
-import logging
-import re
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-from pydantic import BaseModel, field_validator
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
-from backend.api.features.library.model import LibraryAgent
-from backend.data import execution as execution_db
-from backend.data.execution import ExecutionStatus, GraphExecution, GraphExecutionMeta
-
-from .base import BaseTool
-from .models import (
-    AgentOutputResponse,
-    ErrorResponse,
-    ExecutionOutputInfo,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-from .utils import fetch_graph_from_store_slug
-
-logger = logging.getLogger(__name__)
-
-
-class AgentOutputInput(BaseModel):
-    """Input parameters for the agent_output tool."""
-
-    agent_name: str = ""
-    library_agent_id: str = ""
-    store_slug: str = ""
-    execution_id: str = ""
-    run_time: str = "latest"
-
-    @field_validator(
-        "agent_name",
-        "library_agent_id",
-        "store_slug",
-        "execution_id",
-        "run_time",
-        mode="before",
-    )
-    @classmethod
-    def strip_strings(cls, v: Any) -> Any:
-        """Strip whitespace from string fields."""
-        return v.strip() if isinstance(v, str) else v
-
-
-def parse_time_expression(
-    time_expr: str | None,
-) -> tuple[datetime | None, datetime | None]:
-    """
-    Parse time expression into datetime range (start, end).
-
-    Supports:
-    - "latest" or None -> returns (None, None) to get most recent
-    - "yesterday" -> 24h window for yesterday
-    - "today" -> Today from midnight
-    - "last week" / "last 7 days" -> 7 day window
-    - "last month" / "last 30 days" -> 30 day window
-    - ISO date "YYYY-MM-DD" -> 24h window for that date
-    """
-    if not time_expr or time_expr.lower() == "latest":
-        return None, None
-
-    now = datetime.now(timezone.utc)
-    expr = time_expr.lower().strip()
-
-    # Relative expressions
-    if expr == "yesterday":
-        end = now.replace(hour=0, minute=0, second=0, microsecond=0)
-        start = end - timedelta(days=1)
-        return start, end
-
-    if expr in ("last week", "last 7 days"):
-        return now - timedelta(days=7), now
-
-    if expr in ("last month", "last 30 days"):
-        return now - timedelta(days=30), now
-
-    if expr == "today":
-        start = now.replace(hour=0, minute=0, second=0, microsecond=0)
-        return start, now
-
-    # Try ISO date format (YYYY-MM-DD)
-    date_match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", expr)
-    if date_match:
-        year, month, day = map(int, date_match.groups())
-        start = datetime(year, month, day, 0, 0, 0, tzinfo=timezone.utc)
-        end = start + timedelta(days=1)
-        return start, end
-
-    # Try ISO datetime
-    try:
-        parsed = datetime.fromisoformat(expr.replace("Z", "+00:00"))
-        if parsed.tzinfo is None:
-            parsed = parsed.replace(tzinfo=timezone.utc)
-        # Return +/- 1 hour window around the specified time
-        return parsed - timedelta(hours=1), parsed + timedelta(hours=1)
-    except ValueError:
-        pass
-
-    # Fallback: treat as "latest"
-    return None, None
-
-
-class AgentOutputTool(BaseTool):
-    """Tool for retrieving execution outputs from user's library agents."""
-
-    @property
-    def name(self) -> str:
-        return "agent_output"
-
-    @property
-    def description(self) -> str:
-        return """Retrieve execution outputs from agents in the user's library.
-
-        Identify the agent using one of:
-        - agent_name: Fuzzy search in user's library
-        - library_agent_id: Exact library agent ID
-        - store_slug: Marketplace format 'username/agent-name'
-
-        Select which run to retrieve using:
-        - execution_id: Specific execution ID
-        - run_time: 'latest' (default), 'yesterday', 'last week', or ISO date 'YYYY-MM-DD'
-        """
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "agent_name": {
-                    "type": "string",
-                    "description": "Agent name to search for in user's library (fuzzy match)",
-                },
-                "library_agent_id": {
-                    "type": "string",
-                    "description": "Exact library agent ID",
-                },
-                "store_slug": {
-                    "type": "string",
-                    "description": "Marketplace identifier: 'username/agent-slug'",
-                },
-                "execution_id": {
-                    "type": "string",
-                    "description": "Specific execution ID to retrieve",
-                },
-                "run_time": {
-                    "type": "string",
-                    "description": (
-                        "Time filter: 'latest', 'yesterday', 'last week', or 'YYYY-MM-DD'"
-                    ),
-                },
-            },
-            "required": [],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    async def _resolve_agent(
-        self,
-        user_id: str,
-        agent_name: str | None,
-        library_agent_id: str | None,
-        store_slug: str | None,
-    ) -> tuple[LibraryAgent | None, str | None]:
-        """
-        Resolve agent from provided identifiers.
-        Returns (library_agent, error_message).
-        """
-        # Priority 1: Exact library agent ID
-        if library_agent_id:
-            try:
-                agent = await library_db.get_library_agent(library_agent_id, user_id)
-                return agent, None
-            except Exception as e:
-                logger.warning(f"Failed to get library agent by ID: {e}")
-                return None, f"Library agent '{library_agent_id}' not found"
-
-        # Priority 2: Store slug (username/agent-name)
-        if store_slug and "/" in store_slug:
-            username, agent_slug = store_slug.split("/", 1)
-            graph, _ = await fetch_graph_from_store_slug(username, agent_slug)
-            if not graph:
-                return None, f"Agent '{store_slug}' not found in marketplace"
-
-            # Find in user's library by graph_id
-            agent = await library_db.get_library_agent_by_graph_id(user_id, graph.id)
-            if not agent:
-                return (
-                    None,
-                    f"Agent '{store_slug}' is not in your library. "
-                    "Add it first to see outputs.",
-                )
-            return agent, None
-
-        # Priority 3: Fuzzy name search in library
-        if agent_name:
-            try:
-                response = await library_db.list_library_agents(
-                    user_id=user_id,
-                    search_term=agent_name,
-                    page_size=5,
-                )
-                if not response.agents:
-                    return (
-                        None,
-                        f"No agents matching '{agent_name}' found in your library",
-                    )
-
-                # Return best match (first result from search)
-                return response.agents[0], None
-            except Exception as e:
-                logger.error(f"Error searching library agents: {e}")
-                return None, f"Error searching for agent: {e}"
-
-        return (
-            None,
-            "Please specify an agent name, library_agent_id, or store_slug",
-        )
-
-    async def _get_execution(
-        self,
-        user_id: str,
-        graph_id: str,
-        execution_id: str | None,
-        time_start: datetime | None,
-        time_end: datetime | None,
-    ) -> tuple[GraphExecution | None, list[GraphExecutionMeta], str | None]:
-        """
-        Fetch execution(s) based on filters.
-        Returns (single_execution, available_executions_meta, error_message).
-        """
-        # If specific execution_id provided, fetch it directly
-        if execution_id:
-            execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=execution_id,
-                include_node_executions=False,
-            )
-            if not execution:
-                return None, [], f"Execution '{execution_id}' not found"
-            return execution, [], None
-
-        # Get completed executions with time filters
-        executions = await execution_db.get_graph_executions(
-            graph_id=graph_id,
-            user_id=user_id,
-            statuses=[ExecutionStatus.COMPLETED],
-            created_time_gte=time_start,
-            created_time_lte=time_end,
-            limit=10,
-        )
-
-        if not executions:
-            return None, [], None  # No error, just no executions
-
-        # If only one execution, fetch full details
-        if len(executions) == 1:
-            full_execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=executions[0].id,
-                include_node_executions=False,
-            )
-            return full_execution, [], None
-
-        # Multiple executions - return latest with full details, plus list of available
-        full_execution = await execution_db.get_graph_execution(
-            user_id=user_id,
-            execution_id=executions[0].id,
-            include_node_executions=False,
-        )
-        return full_execution, executions, None
-
-    def _build_response(
-        self,
-        agent: LibraryAgent,
-        execution: GraphExecution | None,
-        available_executions: list[GraphExecutionMeta],
-        session_id: str | None,
-    ) -> AgentOutputResponse:
-        """Build the response based on execution data."""
-        library_agent_link = f"/library/agents/{agent.id}"
-
-        if not execution:
-            return AgentOutputResponse(
-                message=f"No completed executions found for agent '{agent.name}'",
-                session_id=session_id,
-                agent_name=agent.name,
-                agent_id=agent.graph_id,
-                library_agent_id=agent.id,
-                library_agent_link=library_agent_link,
-                total_executions=0,
-            )
-
-        execution_info = ExecutionOutputInfo(
-            execution_id=execution.id,
-            status=execution.status.value,
-            started_at=execution.started_at,
-            ended_at=execution.ended_at,
-            outputs=dict(execution.outputs),
-            inputs_summary=execution.inputs if execution.inputs else None,
-        )
-
-        available_list = None
-        if len(available_executions) > 1:
-            available_list = [
-                {
-                    "id": e.id,
-                    "status": e.status.value,
-                    "started_at": e.started_at.isoformat() if e.started_at else None,
-                }
-                for e in available_executions[:5]
-            ]
-
-        message = f"Found execution outputs for agent '{agent.name}'"
-        if len(available_executions) > 1:
-            message += (
-                f". Showing latest of {len(available_executions)} matching executions."
-            )
-
-        return AgentOutputResponse(
-            message=message,
-            session_id=session_id,
-            agent_name=agent.name,
-            agent_id=agent.graph_id,
-            library_agent_id=agent.id,
-            library_agent_link=library_agent_link,
-            execution=execution_info,
-            available_executions=available_list,
-            total_executions=len(available_executions) if available_executions else 1,
-        )
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Execute the agent_output tool."""
-        session_id = session.session_id
-
-        # Parse and validate input
-        try:
-            input_data = AgentOutputInput(**kwargs)
-        except Exception as e:
-            logger.error(f"Invalid input: {e}")
-            return ErrorResponse(
-                message="Invalid input parameters",
-                error=str(e),
-                session_id=session_id,
-            )
-
-        # Ensure user_id is present (should be guaranteed by requires_auth)
-        if not user_id:
-            return ErrorResponse(
-                message="User authentication required",
-                session_id=session_id,
-            )
-
-        # Check if at least one identifier is provided
-        if not any(
-            [
-                input_data.agent_name,
-                input_data.library_agent_id,
-                input_data.store_slug,
-                input_data.execution_id,
-            ]
-        ):
-            return ErrorResponse(
-                message=(
-                    "Please specify at least one of: agent_name, "
-                    "library_agent_id, store_slug, or execution_id"
-                ),
-                session_id=session_id,
-            )
-
-        # If only execution_id provided, we need to find the agent differently
-        if (
-            input_data.execution_id
-            and not input_data.agent_name
-            and not input_data.library_agent_id
-            and not input_data.store_slug
-        ):
-            # Fetch execution directly to get graph_id
-            execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=input_data.execution_id,
-                include_node_executions=False,
-            )
-            if not execution:
-                return ErrorResponse(
-                    message=f"Execution '{input_data.execution_id}' not found",
-                    session_id=session_id,
-                )
-
-            # Find library agent by graph_id
-            agent = await library_db.get_library_agent_by_graph_id(
-                user_id, execution.graph_id
-            )
-            if not agent:
-                return NoResultsResponse(
-                    message=(
-                        f"Execution found but agent not in your library. "
-                        f"Graph ID: {execution.graph_id}"
-                    ),
-                    session_id=session_id,
-                    suggestions=["Add the agent to your library to see more details"],
-                )
-
-            return self._build_response(agent, execution, [], session_id)
-
-        # Resolve agent from identifiers
-        agent, error = await self._resolve_agent(
-            user_id=user_id,
-            agent_name=input_data.agent_name or None,
-            library_agent_id=input_data.library_agent_id or None,
-            store_slug=input_data.store_slug or None,
-        )
-
-        if error or not agent:
-            return NoResultsResponse(
-                message=error or "Agent not found",
-                session_id=session_id,
-                suggestions=[
-                    "Check the agent name or ID",
-                    "Make sure the agent is in your library",
-                ],
-            )
-
-        # Parse time expression
-        time_start, time_end = parse_time_expression(input_data.run_time)
-
-        # Fetch execution(s)
-        execution, available_executions, exec_error = await self._get_execution(
-            user_id=user_id,
-            graph_id=agent.graph_id,
-            execution_id=input_data.execution_id or None,
-            time_start=time_start,
-            time_end=time_end,
-        )
-
-        if exec_error:
-            return ErrorResponse(
-                message=exec_error,
-                session_id=session_id,
-            )
-
-        return self._build_response(agent, execution, available_executions, session_id)

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

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

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

@@ -1,6 +1,5 @@
 """Pydantic models for tool responses."""
 
-from datetime import datetime
 from enum import Enum
 from typing import Any
 
@@ -20,15 +19,6 @@ class ResponseType(str, Enum):
     ERROR = "error"
     NO_RESULTS = "no_results"
     SUCCESS = "success"
-    DOC_SEARCH_RESULTS = "doc_search_results"
-    AGENT_OUTPUT = "agent_output"
-    BLOCK_LIST = "block_list"
-    BLOCK_OUTPUT = "block_output"
-    UNDERSTANDING_UPDATED = "understanding_updated"
-    # Agent generation responses
-    AGENT_PREVIEW = "agent_preview"
-    AGENT_SAVED = "agent_saved"
-    CLARIFICATION_NEEDED = "clarification_needed"
 
 
 # Base response model
@@ -183,128 +173,3 @@ class ErrorResponse(ToolResponseBase):
     type: ResponseType = ResponseType.ERROR
     error: str | None = None
     details: dict[str, Any] | None = None
-
-
-# Documentation search models
-class DocSearchResult(BaseModel):
-    """A single documentation search result."""
-
-    title: str
-    path: str
-    section: str
-    snippet: str  # Short excerpt for UI display
-    content: str  # Full text content for LLM to read and understand
-    score: float
-    doc_url: str | None = None
-
-
-class DocSearchResultsResponse(ToolResponseBase):
-    """Response for search_docs tool."""
-
-    type: ResponseType = ResponseType.DOC_SEARCH_RESULTS
-    results: list[DocSearchResult]
-    count: int
-    query: str
-
-
-# Agent output models
-class ExecutionOutputInfo(BaseModel):
-    """Summary of a single execution's outputs."""
-
-    execution_id: str
-    status: str
-    started_at: datetime | None = None
-    ended_at: datetime | None = None
-    outputs: dict[str, list[Any]]
-    inputs_summary: dict[str, Any] | None = None
-
-
-class AgentOutputResponse(ToolResponseBase):
-    """Response for agent_output tool."""
-
-    type: ResponseType = ResponseType.AGENT_OUTPUT
-    agent_name: str
-    agent_id: str
-    library_agent_id: str | None = None
-    library_agent_link: str | None = None
-    execution: ExecutionOutputInfo | None = None
-    available_executions: list[dict[str, Any]] | None = None
-    total_executions: int = 0
-
-
-# Block models
-class BlockInfoSummary(BaseModel):
-    """Summary of a block for search results."""
-
-    id: str
-    name: str
-    description: str
-    categories: list[str]
-    input_schema: dict[str, Any]
-    output_schema: dict[str, Any]
-
-
-class BlockListResponse(ToolResponseBase):
-    """Response for find_block tool."""
-
-    type: ResponseType = ResponseType.BLOCK_LIST
-    blocks: list[BlockInfoSummary]
-    count: int
-    query: str
-
-
-class BlockOutputResponse(ToolResponseBase):
-    """Response for run_block tool."""
-
-    type: ResponseType = ResponseType.BLOCK_OUTPUT
-    block_id: str
-    block_name: str
-    outputs: dict[str, list[Any]]
-    success: bool = True
-
-
-# Business understanding models
-class UnderstandingUpdatedResponse(ToolResponseBase):
-    """Response for add_understanding tool."""
-
-    type: ResponseType = ResponseType.UNDERSTANDING_UPDATED
-    updated_fields: list[str] = Field(default_factory=list)
-    current_understanding: dict[str, Any] = Field(default_factory=dict)
-
-
-# Agent generation models
-class ClarifyingQuestion(BaseModel):
-    """A question that needs user clarification."""
-
-    question: str
-    keyword: str
-    example: str | None = None
-
-
-class AgentPreviewResponse(ToolResponseBase):
-    """Response for previewing a generated agent before saving."""
-
-    type: ResponseType = ResponseType.AGENT_PREVIEW
-    agent_json: dict[str, Any]
-    agent_name: str
-    description: str
-    node_count: int
-    link_count: int = 0
-
-
-class AgentSavedResponse(ToolResponseBase):
-    """Response when an agent is saved to the library."""
-
-    type: ResponseType = ResponseType.AGENT_SAVED
-    agent_id: str
-    agent_name: str
-    library_agent_id: str
-    library_agent_link: str
-    agent_page_link: str  # Link to the agent builder/editor page
-
-
-class ClarificationNeededResponse(ToolResponseBase):
-    """Response when the LLM needs more information from the user."""
-
-    type: ResponseType = ResponseType.CLARIFICATION_NEEDED
-    questions: list[ClarifyingQuestion] = Field(default_factory=list)

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

@@ -7,7 +7,6 @@ from pydantic import BaseModel, Field, field_validator
 
 from backend.api.features.chat.config import ChatConfig
 from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
 from backend.data.graph import GraphModel
 from backend.data.model import CredentialsMetaInput
 from backend.data.user import get_user_by_id
@@ -58,7 +57,6 @@ class RunAgentInput(BaseModel):
     """Input parameters for the run_agent tool."""
 
     username_agent_slug: str = ""
-    library_agent_id: str = ""
     inputs: dict[str, Any] = Field(default_factory=dict)
     use_defaults: bool = False
     schedule_name: str = ""
@@ -66,12 +64,7 @@ class RunAgentInput(BaseModel):
     timezone: str = "UTC"
 
     @field_validator(
-        "username_agent_slug",
-        "library_agent_id",
-        "schedule_name",
-        "cron",
-        "timezone",
-        mode="before",
+        "username_agent_slug", "schedule_name", "cron", "timezone", mode="before"
     )
     @classmethod
     def strip_strings(cls, v: Any) -> Any:
@@ -97,7 +90,7 @@ class RunAgentTool(BaseTool):
 
     @property
     def description(self) -> str:
-        return """Run or schedule an agent from the marketplace or user's library.
+        return """Run or schedule an agent from the marketplace.
 
         The tool automatically handles the setup flow:
         - Returns missing inputs if required fields are not provided
@@ -105,10 +98,6 @@ class RunAgentTool(BaseTool):
         - Executes immediately if all requirements are met
         - Schedules execution if cron expression is provided
 
-        Identify the agent using either:
-        - username_agent_slug: Marketplace format 'username/agent-name'
-        - library_agent_id: ID of an agent in the user's library
-
         For scheduled execution, provide: schedule_name, cron, and optionally timezone."""
 
     @property
@@ -120,10 +109,6 @@ class RunAgentTool(BaseTool):
                     "type": "string",
                     "description": "Agent identifier in format 'username/agent-name'",
                 },
-                "library_agent_id": {
-                    "type": "string",
-                    "description": "Library agent ID from user's library",
-                },
                 "inputs": {
                     "type": "object",
                     "description": "Input values for the agent",
@@ -146,7 +131,7 @@ class RunAgentTool(BaseTool):
                     "description": "IANA timezone for schedule (default: UTC)",
                 },
             },
-            "required": [],
+            "required": ["username_agent_slug"],
         }
 
     @property
@@ -164,16 +149,10 @@ class RunAgentTool(BaseTool):
         params = RunAgentInput(**kwargs)
         session_id = session.session_id
 
-        # Validate at least one identifier is provided
-        has_slug = params.username_agent_slug and "/" in params.username_agent_slug
-        has_library_id = bool(params.library_agent_id)
-
-        if not has_slug and not has_library_id:
+        # Validate agent slug format
+        if not params.username_agent_slug or "/" not in params.username_agent_slug:
             return ErrorResponse(
-                message=(
-                    "Please provide either a username_agent_slug "
-                    "(format 'username/agent-name') or a library_agent_id"
-                ),
+                message="Please provide an agent slug in format 'username/agent-name'",
                 session_id=session_id,
             )
 
@@ -188,41 +167,13 @@ class RunAgentTool(BaseTool):
         is_schedule = bool(params.schedule_name or params.cron)
 
         try:
-            # Step 1: Fetch agent details
-            graph: GraphModel | None = None
-            library_agent = None
-
-            # Priority: library_agent_id if provided
-            if has_library_id:
-                library_agent = await library_db.get_library_agent(
-                    params.library_agent_id, user_id
-                )
-                if not library_agent:
-                    return ErrorResponse(
-                        message=f"Library agent '{params.library_agent_id}' not found",
-                        session_id=session_id,
-                    )
-                # Get the graph from the library agent
-                from backend.data.graph import get_graph
-
-                graph = await get_graph(
-                    library_agent.graph_id,
-                    library_agent.graph_version,
-                    user_id=user_id,
-                )
-            else:
-                # Fetch from marketplace slug
-                username, agent_name = params.username_agent_slug.split("/", 1)
-                graph, _ = await fetch_graph_from_store_slug(username, agent_name)
+            # Step 1: Fetch agent details (always happens first)
+            username, agent_name = params.username_agent_slug.split("/", 1)
+            graph, store_agent = await fetch_graph_from_store_slug(username, agent_name)
 
             if not graph:
-                identifier = (
-                    params.library_agent_id
-                    if has_library_id
-                    else params.username_agent_slug
-                )
                 return ErrorResponse(
-                    message=f"Agent '{identifier}' not found",
+                    message=f"Agent '{params.username_agent_slug}' not found in marketplace",
                     session_id=session_id,
                 )
 

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

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

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

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

autogpt_platform/backend/backend/blocks/human_in_the_loop.py

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

autogpt_platform/backend/backend/blocks/smart_decision_maker.py

@@ -391,8 +391,12 @@ class SmartDecisionMakerBlock(Block):
         """
         block = sink_node.block
 
+        # Use custom name from node metadata if set, otherwise fall back to block.name
+        custom_name = sink_node.metadata.get("customized_name")
+        tool_name = custom_name if custom_name else block.name
+
         tool_function: dict[str, Any] = {
-            "name": SmartDecisionMakerBlock.cleanup(block.name),
+            "name": SmartDecisionMakerBlock.cleanup(tool_name),
             "description": block.description,
         }
         sink_block_input_schema = block.input_schema
@@ -489,14 +493,24 @@ class SmartDecisionMakerBlock(Block):
                 f"Sink graph metadata not found: {graph_id} {graph_version}"
             )
 
+        # Use custom name from node metadata if set, otherwise fall back to graph name
+        custom_name = sink_node.metadata.get("customized_name")
+        tool_name = custom_name if custom_name else sink_graph_meta.name
+
         tool_function: dict[str, Any] = {
-            "name": SmartDecisionMakerBlock.cleanup(sink_graph_meta.name),
+            "name": SmartDecisionMakerBlock.cleanup(tool_name),
             "description": sink_graph_meta.description,
         }
 
         properties = {}
+        field_mapping = {}
 
         for link in links:
+            field_name = link.sink_name
+
+            clean_field_name = SmartDecisionMakerBlock.cleanup(field_name)
+            field_mapping[clean_field_name] = field_name
+
             sink_block_input_schema = sink_node.input_default["input_schema"]
             sink_block_properties = sink_block_input_schema.get("properties", {}).get(
                 link.sink_name, {}
@@ -506,7 +520,7 @@ class SmartDecisionMakerBlock(Block):
                 if "description" in sink_block_properties
                 else f"The {link.sink_name} of the tool"
             )
-            properties[link.sink_name] = {
+            properties[clean_field_name] = {
                 "type": "string",
                 "description": description,
                 "default": json.dumps(sink_block_properties.get("default", None)),
@@ -519,7 +533,7 @@ class SmartDecisionMakerBlock(Block):
             "strict": True,
         }
 
-        # Store node info for later use in output processing
+        tool_function["_field_mapping"] = field_mapping
         tool_function["_sink_node_id"] = sink_node.id
 
         return {"type": "function", "function": tool_function}
@@ -1147,8 +1161,9 @@ class SmartDecisionMakerBlock(Block):
                 original_field_name = field_mapping.get(clean_arg_name, clean_arg_name)
                 arg_value = tool_args.get(clean_arg_name)
 
-                sanitized_arg_name = self.cleanup(original_field_name)
-                emit_key = f"tools_^_{sink_node_id}_~_{sanitized_arg_name}"
+                # Use original_field_name directly (not sanitized) to match link sink_name
+                # The field_mapping already translates from LLM's cleaned names to original names
+                emit_key = f"tools_^_{sink_node_id}_~_{original_field_name}"
 
                 logger.debug(
                     "[SmartDecisionMakerBlock|geid:%s|neid:%s] emit %s",

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

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

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

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

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

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

autogpt_platform/backend/backend/data/block.py

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

autogpt_platform/backend/backend/data/graph.py

@@ -244,7 +244,10 @@ class BaseGraph(BaseDbModel):
         return any(
             node.block_id
             for node in self.nodes
-            if node.block.block_type == BlockType.HUMAN_IN_THE_LOOP
+            if (
+                node.block.block_type == BlockType.HUMAN_IN_THE_LOOP
+                or node.block.requires_human_review
+            )
         )
 
     @property

autogpt_platform/backend/backend/data/understanding.py

@@ -1,429 +0,0 @@
-"""Data models and access layer for user business understanding."""
-
-import logging
-from datetime import datetime
-from typing import Any, Optional, cast
-
-import pydantic
-from prisma.models import UserBusinessUnderstanding
-from prisma.types import (
-    UserBusinessUnderstandingCreateInput,
-    UserBusinessUnderstandingUpdateInput,
-)
-
-from backend.data.redis_client import get_redis_async
-from backend.util.json import SafeJson
-
-logger = logging.getLogger(__name__)
-
-# Cache configuration
-CACHE_KEY_PREFIX = "understanding"
-CACHE_TTL_SECONDS = 48 * 60 * 60  # 48 hours
-
-
-def _cache_key(user_id: str) -> str:
-    """Generate cache key for user business understanding."""
-    return f"{CACHE_KEY_PREFIX}:{user_id}"
-
-
-def _json_to_list(value: Any) -> list[str]:
-    """Convert Json field to list[str], handling None."""
-    if value is None:
-        return []
-    if isinstance(value, list):
-        return cast(list[str], value)
-    return []
-
-
-class BusinessUnderstandingInput(pydantic.BaseModel):
-    """Input model for updating business understanding - all fields optional for incremental updates."""
-
-    # User info
-    user_name: Optional[str] = pydantic.Field(None, description="The user's name")
-    job_title: Optional[str] = pydantic.Field(None, description="The user's job title")
-
-    # Business basics
-    business_name: Optional[str] = pydantic.Field(
-        None, description="Name of the user's business"
-    )
-    industry: Optional[str] = pydantic.Field(None, description="Industry or sector")
-    business_size: Optional[str] = pydantic.Field(
-        None, description="Company size (e.g., '1-10', '11-50')"
-    )
-    user_role: Optional[str] = pydantic.Field(
-        None,
-        description="User's role in the organization (e.g., 'decision maker', 'implementer')",
-    )
-
-    # Processes & activities
-    key_workflows: Optional[list[str]] = pydantic.Field(
-        None, description="Key business workflows"
-    )
-    daily_activities: Optional[list[str]] = pydantic.Field(
-        None, description="Daily activities performed"
-    )
-
-    # Pain points & goals
-    pain_points: Optional[list[str]] = pydantic.Field(
-        None, description="Current pain points"
-    )
-    bottlenecks: Optional[list[str]] = pydantic.Field(
-        None, description="Process bottlenecks"
-    )
-    manual_tasks: Optional[list[str]] = pydantic.Field(
-        None, description="Manual/repetitive tasks"
-    )
-    automation_goals: Optional[list[str]] = pydantic.Field(
-        None, description="Desired automation goals"
-    )
-
-    # Current tools
-    current_software: Optional[list[str]] = pydantic.Field(
-        None, description="Software/tools currently used"
-    )
-    existing_automation: Optional[list[str]] = pydantic.Field(
-        None, description="Existing automations"
-    )
-
-    # Additional context
-    additional_notes: Optional[str] = pydantic.Field(
-        None, description="Any additional context"
-    )
-
-
-class BusinessUnderstanding(pydantic.BaseModel):
-    """Full business understanding model returned from database."""
-
-    id: str
-    user_id: str
-    created_at: datetime
-    updated_at: datetime
-
-    # User info
-    user_name: Optional[str] = None
-    job_title: Optional[str] = None
-
-    # Business basics
-    business_name: Optional[str] = None
-    industry: Optional[str] = None
-    business_size: Optional[str] = None
-    user_role: Optional[str] = None
-
-    # Processes & activities
-    key_workflows: list[str] = pydantic.Field(default_factory=list)
-    daily_activities: list[str] = pydantic.Field(default_factory=list)
-
-    # Pain points & goals
-    pain_points: list[str] = pydantic.Field(default_factory=list)
-    bottlenecks: list[str] = pydantic.Field(default_factory=list)
-    manual_tasks: list[str] = pydantic.Field(default_factory=list)
-    automation_goals: list[str] = pydantic.Field(default_factory=list)
-
-    # Current tools
-    current_software: list[str] = pydantic.Field(default_factory=list)
-    existing_automation: list[str] = pydantic.Field(default_factory=list)
-
-    # Additional context
-    additional_notes: Optional[str] = None
-
-    @classmethod
-    def from_db(cls, db_record: UserBusinessUnderstanding) -> "BusinessUnderstanding":
-        """Convert database record to Pydantic model."""
-        return cls(
-            id=db_record.id,
-            user_id=db_record.userId,
-            created_at=db_record.createdAt,
-            updated_at=db_record.updatedAt,
-            user_name=db_record.userName,
-            job_title=db_record.jobTitle,
-            business_name=db_record.businessName,
-            industry=db_record.industry,
-            business_size=db_record.businessSize,
-            user_role=db_record.userRole,
-            key_workflows=_json_to_list(db_record.keyWorkflows),
-            daily_activities=_json_to_list(db_record.dailyActivities),
-            pain_points=_json_to_list(db_record.painPoints),
-            bottlenecks=_json_to_list(db_record.bottlenecks),
-            manual_tasks=_json_to_list(db_record.manualTasks),
-            automation_goals=_json_to_list(db_record.automationGoals),
-            current_software=_json_to_list(db_record.currentSoftware),
-            existing_automation=_json_to_list(db_record.existingAutomation),
-            additional_notes=db_record.additionalNotes,
-        )
-
-
-def _merge_lists(existing: list | None, new: list | None) -> list | None:
-    """Merge two lists, removing duplicates while preserving order."""
-    if new is None:
-        return existing
-    if existing is None:
-        return new
-    # Preserve order, add new items that don't exist
-    merged = list(existing)
-    for item in new:
-        if item not in merged:
-            merged.append(item)
-    return merged
-
-
-async def _get_from_cache(user_id: str) -> Optional[BusinessUnderstanding]:
-    """Get business understanding from Redis cache."""
-    try:
-        redis = await get_redis_async()
-        cached_data = await redis.get(_cache_key(user_id))
-        if cached_data:
-            return BusinessUnderstanding.model_validate_json(cached_data)
-    except Exception as e:
-        logger.warning(f"Failed to get understanding from cache: {e}")
-    return None
-
-
-async def _set_cache(user_id: str, understanding: BusinessUnderstanding) -> None:
-    """Set business understanding in Redis cache with TTL."""
-    try:
-        redis = await get_redis_async()
-        await redis.setex(
-            _cache_key(user_id),
-            CACHE_TTL_SECONDS,
-            understanding.model_dump_json(),
-        )
-    except Exception as e:
-        logger.warning(f"Failed to set understanding in cache: {e}")
-
-
-async def _delete_cache(user_id: str) -> None:
-    """Delete business understanding from Redis cache."""
-    try:
-        redis = await get_redis_async()
-        await redis.delete(_cache_key(user_id))
-    except Exception as e:
-        logger.warning(f"Failed to delete understanding from cache: {e}")
-
-
-async def get_business_understanding(
-    user_id: str,
-) -> Optional[BusinessUnderstanding]:
-    """Get the business understanding for a user.
-
-    Checks cache first, falls back to database if not cached.
-    Results are cached for 48 hours.
-    """
-    # Try cache first
-    cached = await _get_from_cache(user_id)
-    if cached:
-        logger.debug(f"Business understanding cache hit for user {user_id}")
-        return cached
-
-    # Cache miss - load from database
-    logger.debug(f"Business understanding cache miss for user {user_id}")
-    record = await UserBusinessUnderstanding.prisma().find_unique(
-        where={"userId": user_id}
-    )
-    if record is None:
-        return None
-
-    understanding = BusinessUnderstanding.from_db(record)
-
-    # Store in cache for next time
-    await _set_cache(user_id, understanding)
-
-    return understanding
-
-
-async def upsert_business_understanding(
-    user_id: str,
-    data: BusinessUnderstandingInput,
-) -> BusinessUnderstanding:
-    """
-    Create or update business understanding with incremental merge strategy.
-
-    - String fields: new value overwrites if provided (not None)
-    - List fields: new items are appended to existing (deduplicated)
-    """
-    # Get existing record for merge
-    existing = await UserBusinessUnderstanding.prisma().find_unique(
-        where={"userId": user_id}
-    )
-
-    # Build update data with merge strategy
-    update_data: UserBusinessUnderstandingUpdateInput = {}
-    create_data: dict[str, Any] = {"userId": user_id}
-
-    # String fields - overwrite if provided
-    if data.user_name is not None:
-        update_data["userName"] = data.user_name
-        create_data["userName"] = data.user_name
-    if data.job_title is not None:
-        update_data["jobTitle"] = data.job_title
-        create_data["jobTitle"] = data.job_title
-    if data.business_name is not None:
-        update_data["businessName"] = data.business_name
-        create_data["businessName"] = data.business_name
-    if data.industry is not None:
-        update_data["industry"] = data.industry
-        create_data["industry"] = data.industry
-    if data.business_size is not None:
-        update_data["businessSize"] = data.business_size
-        create_data["businessSize"] = data.business_size
-    if data.user_role is not None:
-        update_data["userRole"] = data.user_role
-        create_data["userRole"] = data.user_role
-    if data.additional_notes is not None:
-        update_data["additionalNotes"] = data.additional_notes
-        create_data["additionalNotes"] = data.additional_notes
-
-    # List fields - merge with existing
-    if data.key_workflows is not None:
-        existing_list = _json_to_list(existing.keyWorkflows) if existing else None
-        merged = _merge_lists(existing_list, data.key_workflows)
-        update_data["keyWorkflows"] = SafeJson(merged)
-        create_data["keyWorkflows"] = SafeJson(merged)
-
-    if data.daily_activities is not None:
-        existing_list = _json_to_list(existing.dailyActivities) if existing else None
-        merged = _merge_lists(existing_list, data.daily_activities)
-        update_data["dailyActivities"] = SafeJson(merged)
-        create_data["dailyActivities"] = SafeJson(merged)
-
-    if data.pain_points is not None:
-        existing_list = _json_to_list(existing.painPoints) if existing else None
-        merged = _merge_lists(existing_list, data.pain_points)
-        update_data["painPoints"] = SafeJson(merged)
-        create_data["painPoints"] = SafeJson(merged)
-
-    if data.bottlenecks is not None:
-        existing_list = _json_to_list(existing.bottlenecks) if existing else None
-        merged = _merge_lists(existing_list, data.bottlenecks)
-        update_data["bottlenecks"] = SafeJson(merged)
-        create_data["bottlenecks"] = SafeJson(merged)
-
-    if data.manual_tasks is not None:
-        existing_list = _json_to_list(existing.manualTasks) if existing else None
-        merged = _merge_lists(existing_list, data.manual_tasks)
-        update_data["manualTasks"] = SafeJson(merged)
-        create_data["manualTasks"] = SafeJson(merged)
-
-    if data.automation_goals is not None:
-        existing_list = _json_to_list(existing.automationGoals) if existing else None
-        merged = _merge_lists(existing_list, data.automation_goals)
-        update_data["automationGoals"] = SafeJson(merged)
-        create_data["automationGoals"] = SafeJson(merged)
-
-    if data.current_software is not None:
-        existing_list = _json_to_list(existing.currentSoftware) if existing else None
-        merged = _merge_lists(existing_list, data.current_software)
-        update_data["currentSoftware"] = SafeJson(merged)
-        create_data["currentSoftware"] = SafeJson(merged)
-
-    if data.existing_automation is not None:
-        existing_list = _json_to_list(existing.existingAutomation) if existing else None
-        merged = _merge_lists(existing_list, data.existing_automation)
-        update_data["existingAutomation"] = SafeJson(merged)
-        create_data["existingAutomation"] = SafeJson(merged)
-
-    # Upsert
-    record = await UserBusinessUnderstanding.prisma().upsert(
-        where={"userId": user_id},
-        data={
-            "create": UserBusinessUnderstandingCreateInput(**create_data),
-            "update": update_data,
-        },
-    )
-
-    understanding = BusinessUnderstanding.from_db(record)
-
-    # Update cache with new understanding
-    await _set_cache(user_id, understanding)
-
-    return understanding
-
-
-async def clear_business_understanding(user_id: str) -> bool:
-    """Clear/delete business understanding for a user from both DB and cache."""
-    # Delete from cache first
-    await _delete_cache(user_id)
-
-    try:
-        await UserBusinessUnderstanding.prisma().delete(where={"userId": user_id})
-        return True
-    except Exception:
-        # Record might not exist
-        return False
-
-
-def format_understanding_for_prompt(understanding: BusinessUnderstanding) -> str:
-    """Format business understanding as text for system prompt injection."""
-    sections = []
-
-    # User info section
-    user_info = []
-    if understanding.user_name:
-        user_info.append(f"Name: {understanding.user_name}")
-    if understanding.job_title:
-        user_info.append(f"Job Title: {understanding.job_title}")
-    if user_info:
-        sections.append("## User\n" + "\n".join(user_info))
-
-    # Business section
-    business_info = []
-    if understanding.business_name:
-        business_info.append(f"Company: {understanding.business_name}")
-    if understanding.industry:
-        business_info.append(f"Industry: {understanding.industry}")
-    if understanding.business_size:
-        business_info.append(f"Size: {understanding.business_size}")
-    if understanding.user_role:
-        business_info.append(f"Role Context: {understanding.user_role}")
-    if business_info:
-        sections.append("## Business\n" + "\n".join(business_info))
-
-    # Processes section
-    processes = []
-    if understanding.key_workflows:
-        processes.append(f"Key Workflows: {', '.join(understanding.key_workflows)}")
-    if understanding.daily_activities:
-        processes.append(
-            f"Daily Activities: {', '.join(understanding.daily_activities)}"
-        )
-    if processes:
-        sections.append("## Processes\n" + "\n".join(processes))
-
-    # Pain points section
-    pain_points = []
-    if understanding.pain_points:
-        pain_points.append(f"Pain Points: {', '.join(understanding.pain_points)}")
-    if understanding.bottlenecks:
-        pain_points.append(f"Bottlenecks: {', '.join(understanding.bottlenecks)}")
-    if understanding.manual_tasks:
-        pain_points.append(f"Manual Tasks: {', '.join(understanding.manual_tasks)}")
-    if pain_points:
-        sections.append("## Pain Points\n" + "\n".join(pain_points))
-
-    # Goals section
-    if understanding.automation_goals:
-        sections.append(
-            "## Automation Goals\n"
-            + "\n".join(f"- {goal}" for goal in understanding.automation_goals)
-        )
-
-    # Current tools section
-    tools_info = []
-    if understanding.current_software:
-        tools_info.append(
-            f"Current Software: {', '.join(understanding.current_software)}"
-        )
-    if understanding.existing_automation:
-        tools_info.append(
-            f"Existing Automation: {', '.join(understanding.existing_automation)}"
-        )
-    if tools_info:
-        sections.append("## Current Tools\n" + "\n".join(tools_info))
-
-    # Additional notes
-    if understanding.additional_notes:
-        sections.append(f"## Additional Context\n{understanding.additional_notes}")
-
-    if not sections:
-        return ""
-
-    return "# User Business Context\n\n" + "\n\n".join(sections)

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

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

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

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

autogpt_platform/backend/backend/util/settings.py

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

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

@@ -1,81 +0,0 @@
--- DropIndex
-DROP INDEX "StoreListingVersion_storeListingId_version_key";
-
--- CreateTable
-CREATE TABLE "UserBusinessUnderstanding" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "userId" TEXT NOT NULL,
-    "userName" TEXT,
-    "jobTitle" TEXT,
-    "businessName" TEXT,
-    "industry" TEXT,
-    "businessSize" TEXT,
-    "userRole" TEXT,
-    "keyWorkflows" JSONB,
-    "dailyActivities" JSONB,
-    "painPoints" JSONB,
-    "bottlenecks" JSONB,
-    "manualTasks" JSONB,
-    "automationGoals" JSONB,
-    "currentSoftware" JSONB,
-    "existingAutomation" JSONB,
-    "additionalNotes" TEXT,
-
-    CONSTRAINT "UserBusinessUnderstanding_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ChatSession" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "userId" TEXT,
-    "title" TEXT,
-    "credentials" JSONB NOT NULL DEFAULT '{}',
-    "successfulAgentRuns" JSONB NOT NULL DEFAULT '{}',
-    "successfulAgentSchedules" JSONB NOT NULL DEFAULT '{}',
-    "totalPromptTokens" INTEGER NOT NULL DEFAULT 0,
-    "totalCompletionTokens" INTEGER NOT NULL DEFAULT 0,
-
-    CONSTRAINT "ChatSession_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ChatMessage" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "sessionId" TEXT NOT NULL,
-    "role" TEXT NOT NULL,
-    "content" TEXT,
-    "name" TEXT,
-    "toolCallId" TEXT,
-    "refusal" TEXT,
-    "toolCalls" JSONB,
-    "functionCall" JSONB,
-    "sequence" INTEGER NOT NULL,
-
-    CONSTRAINT "ChatMessage_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "UserBusinessUnderstanding_userId_key" ON "UserBusinessUnderstanding"("userId");
-
--- CreateIndex
-CREATE INDEX "UserBusinessUnderstanding_userId_idx" ON "UserBusinessUnderstanding"("userId");
-
--- CreateIndex
-CREATE INDEX "ChatSession_userId_updatedAt_idx" ON "ChatSession"("userId", "updatedAt");
-
--- CreateIndex
-CREATE INDEX "ChatMessage_sessionId_sequence_idx" ON "ChatMessage"("sessionId", "sequence");
-
--- CreateIndex
-CREATE UNIQUE INDEX "ChatMessage_sessionId_sequence_key" ON "ChatMessage"("sessionId", "sequence");
-
--- AddForeignKey
-ALTER TABLE "UserBusinessUnderstanding" ADD CONSTRAINT "UserBusinessUnderstanding_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "ChatMessage" ADD CONSTRAINT "ChatMessage_sessionId_fkey" FOREIGN KEY ("sessionId") REFERENCES "ChatSession"("id") ON DELETE CASCADE ON UPDATE CASCADE;

autogpt_platform/backend/pyproject.toml

@@ -135,6 +135,9 @@ ignore_patterns = []
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "session"
+# Disable syrupy plugin to avoid conflict with pytest-snapshot
+# Both provide --snapshot-update argument causing ArgumentError
+addopts = "-p no:syrupy"
 filterwarnings = [
     "ignore:'audioop' is deprecated:DeprecationWarning:discord.player",
     "ignore:invalid escape sequence:DeprecationWarning:tweepy.api",

autogpt_platform/backend/schema.prisma

@@ -53,7 +53,6 @@ model User {
 
   Profile               Profile[]
   UserOnboarding        UserOnboarding?
-  BusinessUnderstanding UserBusinessUnderstanding?
   BuilderSearchHistory  BuilderSearchHistory[]
   StoreListings         StoreListing[]
   StoreListingReviews   StoreListingReview[]
@@ -122,109 +121,19 @@ model UserOnboarding {
   User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
 }
 
-model UserBusinessUnderstanding {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @default(now()) @updatedAt
-
-  userId String @unique
-  User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
-
-  // User info
-  userName String?
-  jobTitle String?
-
-  // Business basics (string columns)
-  businessName String?
-  industry     String?
-  businessSize String? // "1-10", "11-50", "51-200", "201-1000", "1000+"
-  userRole     String? // Role in organization context (e.g., "decision maker", "implementer")
-
-  // Processes & activities (JSON arrays)
-  keyWorkflows    Json?
-  dailyActivities Json?
-
-  // Pain points & goals (JSON arrays)
-  painPoints      Json?
-  bottlenecks     Json?
-  manualTasks     Json?
-  automationGoals Json?
-
-  // Current tools (JSON arrays)
-  currentSoftware    Json?
-  existingAutomation Json?
-
-  additionalNotes String?
-
-  @@index([userId])
-}
-
 model BuilderSearchHistory {
   id        String   @id @default(uuid())
   createdAt DateTime @default(now())
   updatedAt DateTime @default(now()) @updatedAt
 
   searchQuery String
-  filter      String[] @default([])
-  byCreator   String[] @default([])
+  filter      String[]  @default([])
+  byCreator   String[]  @default([])
 
   userId String
   User   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
 }
 
-////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////
-////////////////   CHAT SESSION TABLES   ///////////////////
-////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////
-
-model ChatSession {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @default(now()) @updatedAt
-
-  userId String?
-
-  // Session metadata
-  title       String?
-  credentials Json    @default("{}") // Map of provider -> credential metadata
-
-  // Rate limiting counters (stored as JSON maps)
-  successfulAgentRuns      Json @default("{}") // Map of graph_id -> count
-  successfulAgentSchedules Json @default("{}") // Map of graph_id -> count
-
-  // Usage tracking
-  totalPromptTokens     Int @default(0)
-  totalCompletionTokens Int @default(0)
-
-  Messages ChatMessage[]
-
-  @@index([userId, updatedAt])
-}
-
-model ChatMessage {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-
-  sessionId String
-  Session   ChatSession @relation(fields: [sessionId], references: [id], onDelete: Cascade)
-
-  // Message content
-  role         String // "user", "assistant", "system", "tool", "function"
-  content      String?
-  name         String?
-  toolCallId   String?
-  refusal      String?
-  toolCalls    Json? // List of tool calls for assistant messages
-  functionCall Json? // Deprecated but kept for compatibility
-
-  // Ordering within session
-  sequence Int
-
-  @@unique([sessionId, sequence])
-  @@index([sessionId, sequence])
-}
-
 // This model describes the Agent Graph/Flow (Multi Agent System).
 model AgentGraph {
   id        String    @default(uuid())
@@ -812,26 +721,26 @@ view StoreAgent {
   storeListingVersionId String
   updated_at            DateTime
 
-  slug              String
-  agent_name        String
-  agent_video       String?
-  agent_output_demo String?
-  agent_image       String[]
+  slug                String
+  agent_name          String
+  agent_video         String?
+  agent_output_demo   String?
+  agent_image         String[]
 
-  featured           Boolean                  @default(false)
-  creator_username   String?
-  creator_avatar     String?
-  sub_heading        String
-  description        String
-  categories         String[]
-  search             Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
-  runs               Int
-  rating             Float
-  versions           String[]
-  agentGraphVersions String[]
-  agentGraphId       String
-  is_available       Boolean                  @default(true)
-  useForOnboarding   Boolean                  @default(false)
+  featured         Boolean                  @default(false)
+  creator_username String?
+  creator_avatar   String?
+  sub_heading      String
+  description      String
+  categories       String[]
+  search           Unsupported("tsvector")? @default(dbgenerated("''::tsvector"))
+  runs                Int
+  rating              Float
+  versions            String[]
+  agentGraphVersions  String[]
+  agentGraphId        String
+  is_available        Boolean                  @default(true)
+  useForOnboarding    Boolean                  @default(false)
 
   // Materialized views used (refreshed every 15 minutes via pg_cron):
   // - mv_agent_run_counts - Pre-aggregated agent execution counts by agentGraphId
@@ -947,14 +856,14 @@ model StoreListingVersion {
   AgentGraph        AgentGraph @relation(fields: [agentGraphId, agentGraphVersion], references: [id, version])
 
   // Content fields
-  name               String
-  subHeading         String
-  videoUrl           String?
-  agentOutputDemoUrl String?
-  imageUrls          String[]
-  description        String
-  instructions       String?
-  categories         String[]
+  name                String
+  subHeading          String
+  videoUrl            String?
+  agentOutputDemoUrl  String?
+  imageUrls           String[]
+  description         String
+  instructions        String?
+  categories          String[]
 
   isFeatured Boolean @default(false)
 
@@ -990,6 +899,7 @@ model StoreListingVersion {
   // Reviews for this specific version
   Reviews StoreListingReview[]
 
+  @@unique([storeListingId, version])
   @@index([storeListingId, submissionStatus, isAvailable])
   @@index([submissionStatus])
   @@index([reviewerId])
@@ -1088,16 +998,16 @@ model OAuthApplication {
   updatedAt DateTime @updatedAt
 
   // Application metadata
-  name             String
-  description      String?
-  logoUrl          String? // URL to app logo stored in GCS
-  clientId         String  @unique
-  clientSecret     String // Hashed with Scrypt (same as API keys)
-  clientSecretSalt String // Salt for Scrypt hashing
+  name               String
+  description        String?
+  logoUrl            String? // URL to app logo stored in GCS
+  clientId           String @unique
+  clientSecret       String // Hashed with Scrypt (same as API keys)
+  clientSecretSalt   String // Salt for Scrypt hashing
 
   // OAuth configuration
   redirectUris String[] // Allowed callback URLs
-  grantTypes   String[]           @default(["authorization_code", "refresh_token"])
+  grantTypes   String[] @default(["authorization_code", "refresh_token"])
   scopes       APIKeyPermission[] // Which permissions the app can request
 
   // Application management

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

@@ -92,29 +92,33 @@ export function useMarketplaceUpdate({ agent }: UseMarketplaceUpdateProps) {
 
     const isUserCreator = agent?.owner_user_id === user?.id;
 
-    // Check if there's a pending submission for this specific agent version
     const submissionsResponse = okData(submissionsData) as any;
-    const hasPendingSubmissionForCurrentVersion =
-      isUserCreator &&
-      submissionsResponse?.submissions?.some(
-        (submission: StoreSubmission) =>
-          submission.agent_id === agent.graph_id &&
-          submission.agent_version === agent.graph_version &&
-          submission.status === "PENDING",
-      );
+    const agentSubmissions =
+      submissionsResponse?.submissions?.filter(
+        (submission: StoreSubmission) => submission.agent_id === agent.graph_id,
+      ) || [];
+
+    const highestSubmittedVersion =
+      agentSubmissions.length > 0
+        ? Math.max(
+            ...agentSubmissions.map(
+              (submission: StoreSubmission) => submission.agent_version,
+            ),
+          )
+        : 0;
+
+    const hasUnpublishedChanges =
+      isUserCreator && agent.graph_version > highestSubmittedVersion;
 
     if (!storeAgent) {
       return {
         hasUpdate: false,
         latestVersion: undefined,
         isUserCreator,
-        hasPublishUpdate:
-          isUserCreator && !hasPendingSubmissionForCurrentVersion,
+        hasPublishUpdate: agentSubmissions.length > 0 && hasUnpublishedChanges,
       };
     }
 
-    // Get the latest version from the marketplace
-    // agentGraphVersions array contains graph version numbers as strings, get the highest one
     const latestMarketplaceVersion =
       storeAgent.agentGraphVersions?.length > 0
         ? Math.max(
@@ -124,18 +128,11 @@ export function useMarketplaceUpdate({ agent }: UseMarketplaceUpdateProps) {
           )
         : undefined;
 
-    // Show publish update button if:
-    // 1. User is the creator
-    // 2. No pending submission for current version
-    // 3. Either: agent not published yet OR local version is newer than marketplace
     const hasPublishUpdate =
       isUserCreator &&
-      !hasPendingSubmissionForCurrentVersion &&
-      (latestMarketplaceVersion === undefined || // Not published yet
-        agent.graph_version > latestMarketplaceVersion); // Or local version is newer
+      agent.graph_version >
+        Math.max(latestMarketplaceVersion || 0, highestSubmittedVersion);
 
-    // If marketplace version is newer than user's version, show update banner
-    // This applies to both creators and non-creators
     const hasMarketplaceUpdate =
       latestMarketplaceVersion !== undefined &&
       latestMarketplaceVersion > agent.graph_version;

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

@@ -939,12 +939,12 @@
         }
       }
     },
-    "/api/chat/onboarding/sessions": {
+    "/api/chat/sessions": {
       "post": {
         "tags": ["v2", "chat", "chat"],
-        "summary": "Create Onboarding Session",
-        "description": "Create a new onboarding chat session.\n\nInitiates a new chat session specifically for user onboarding,\nusing a specialized prompt that guides users through their first\nexperience with AutoGPT.\n\nArgs:\n    user_id: The optional authenticated user ID parsed from the JWT.\n\nReturns:\n    CreateSessionResponse: Details of the created onboarding session.",
-        "operationId": "postV2CreateOnboardingSession",
+        "summary": "Create Session",
+        "description": "Create a new chat session.\n\nInitiates a new chat session for either an authenticated or anonymous user.\n\nArgs:\n    user_id: The optional authenticated user ID parsed from the JWT. If missing, creates an anonymous session.\n\nReturns:\n    CreateSessionResponse: Details of the created session.",
+        "operationId": "postV2CreateSession",
         "responses": {
           "200": {
             "description": "Successful Response",
@@ -963,167 +963,6 @@
         "security": [{ "HTTPBearerJWT": [] }]
       }
     },
-    "/api/chat/onboarding/sessions/{session_id}": {
-      "get": {
-        "tags": ["v2", "chat", "chat"],
-        "summary": "Get Onboarding Session",
-        "description": "Retrieve the details of an onboarding chat session.\n\nArgs:\n    session_id: The unique identifier for the onboarding session.\n    user_id: The optional authenticated user ID.\n\nReturns:\n    SessionDetailResponse: Details for the requested session.",
-        "operationId": "getV2GetOnboardingSession",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "session_id",
-            "in": "path",
-            "required": true,
-            "schema": { "type": "string", "title": "Session Id" }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionDetailResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/chat/onboarding/sessions/{session_id}/stream": {
-      "post": {
-        "tags": ["v2", "chat", "chat"],
-        "summary": "Stream Onboarding Chat",
-        "description": "Stream onboarding chat responses for a session.\n\nUses the specialized onboarding system prompt to guide new users\nthrough their first experience with AutoGPT. Streams AI responses\nin real time over Server-Sent Events (SSE).\n\nArgs:\n    session_id: The onboarding session identifier.\n    request: Request body containing message and optional context.\n    user_id: Optional authenticated user ID.\n\nReturns:\n    StreamingResponse: SSE-formatted response chunks.",
-        "operationId": "postV2StreamOnboardingChat",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "session_id",
-            "in": "path",
-            "required": true,
-            "schema": { "type": "string", "title": "Session Id" }
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/StreamChatRequest" }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": { "application/json": { "schema": {} } }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/chat/sessions": {
-      "get": {
-        "tags": ["v2", "chat", "chat"],
-        "summary": "List Sessions",
-        "description": "List chat sessions for the authenticated user.\n\nReturns a paginated list of chat sessions belonging to the current user,\nordered by most recently updated.\n\nArgs:\n    user_id: The authenticated user's ID.\n    limit: Maximum number of sessions to return (1-100).\n    offset: Number of sessions to skip for pagination.\n\nReturns:\n    ListSessionsResponse: List of session summaries and total count.",
-        "operationId": "getV2ListSessions",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "limit",
-            "in": "query",
-            "required": false,
-            "schema": {
-              "type": "integer",
-              "maximum": 100,
-              "minimum": 1,
-              "default": 50,
-              "title": "Limit"
-            }
-          },
-          {
-            "name": "offset",
-            "in": "query",
-            "required": false,
-            "schema": {
-              "type": "integer",
-              "minimum": 0,
-              "default": 0,
-              "title": "Offset"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ListSessionsResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      },
-      "post": {
-        "tags": ["v2", "chat", "chat"],
-        "summary": "Create Session",
-        "description": "Create a new chat session.\n\nInitiates a new chat session for either an authenticated or anonymous user.\n\nArgs:\n    user_id: The optional authenticated user ID parsed from the JWT. If missing, creates an anonymous session.\n\nReturns:\n    CreateSessionResponse: Details of the created session.",
-        "operationId": "postV2CreateSession",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/CreateSessionResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          }
-        }
-      }
-    },
     "/api/chat/sessions/{session_id}": {
       "get": {
         "tags": ["v2", "chat", "chat"],
@@ -1209,9 +1048,9 @@
     "/api/chat/sessions/{session_id}/stream": {
       "get": {
         "tags": ["v2", "chat", "chat"],
-        "summary": "Stream Chat Get",
-        "description": "Stream chat responses for a session (GET - legacy endpoint).\n\nStreams the AI/completion responses in real time over Server-Sent Events (SSE), including:\n  - Text fragments as they are generated\n  - Tool call UI elements (if invoked)\n  - Tool execution results\n\nArgs:\n    session_id: The chat session identifier to associate with the streamed messages.\n    message: The user's new message to process.\n    user_id: Optional authenticated user ID.\n    is_user_message: Whether the message is a user message.\nReturns:\n    StreamingResponse: SSE-formatted response chunks.",
-        "operationId": "getV2StreamChatGet",
+        "summary": "Stream Chat",
+        "description": "Stream chat responses for a session.\n\nStreams the AI/completion responses in real time over Server-Sent Events (SSE), including:\n  - Text fragments as they are generated\n  - Tool call UI elements (if invoked)\n  - Tool execution results\n\nArgs:\n    session_id: The chat session identifier to associate with the streamed messages.\n    message: The user's new message to process.\n    user_id: Optional authenticated user ID.\n    is_user_message: Whether the message is a user message.\nReturns:\n    StreamingResponse: SSE-formatted response chunks.",
+        "operationId": "getV2StreamChat",
         "security": [{ "HTTPBearerJWT": [] }],
         "parameters": [
           {
@@ -1259,46 +1098,6 @@
             }
           }
         }
-      },
-      "post": {
-        "tags": ["v2", "chat", "chat"],
-        "summary": "Stream Chat Post",
-        "description": "Stream chat responses for a session (POST with context support).\n\nStreams the AI/completion responses in real time over Server-Sent Events (SSE), including:\n  - Text fragments as they are generated\n  - Tool call UI elements (if invoked)\n  - Tool execution results\n\nArgs:\n    session_id: The chat session identifier to associate with the streamed messages.\n    request: Request body containing message, is_user_message, and optional context.\n    user_id: Optional authenticated user ID.\nReturns:\n    StreamingResponse: SSE-formatted response chunks.",
-        "operationId": "postV2StreamChatPost",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "session_id",
-            "in": "path",
-            "required": true,
-            "schema": { "type": "string", "title": "Session Id" }
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": { "$ref": "#/components/schemas/StreamChatRequest" }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": { "application/json": { "schema": {} } }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
       }
     },
     "/api/credits": {
@@ -8220,20 +8019,6 @@
         "required": ["source_id", "sink_id", "source_name", "sink_name"],
         "title": "Link"
       },
-      "ListSessionsResponse": {
-        "properties": {
-          "sessions": {
-            "items": { "$ref": "#/components/schemas/SessionSummaryResponse" },
-            "type": "array",
-            "title": "Sessions"
-          },
-          "total": { "type": "integer", "title": "Total" }
-        },
-        "type": "object",
-        "required": ["sessions", "total"],
-        "title": "ListSessionsResponse",
-        "description": "Response model for listing chat sessions."
-      },
       "LogRawMetricRequest": {
         "properties": {
           "metric_name": {
@@ -9563,21 +9348,6 @@
         "title": "SessionDetailResponse",
         "description": "Response model providing complete details for a chat session, including messages."
       },
-      "SessionSummaryResponse": {
-        "properties": {
-          "id": { "type": "string", "title": "Id" },
-          "created_at": { "type": "string", "title": "Created At" },
-          "updated_at": { "type": "string", "title": "Updated At" },
-          "title": {
-            "anyOf": [{ "type": "string" }, { "type": "null" }],
-            "title": "Title"
-          }
-        },
-        "type": "object",
-        "required": ["id", "created_at", "updated_at"],
-        "title": "SessionSummaryResponse",
-        "description": "Response model for a session summary (without messages)."
-      },
       "SetGraphActiveVersion": {
         "properties": {
           "active_graph_version": {
@@ -10129,30 +9899,6 @@
         "required": ["submissions", "pagination"],
         "title": "StoreSubmissionsResponse"
       },
-      "StreamChatRequest": {
-        "properties": {
-          "message": { "type": "string", "title": "Message" },
-          "is_user_message": {
-            "type": "boolean",
-            "title": "Is User Message",
-            "default": true
-          },
-          "context": {
-            "anyOf": [
-              {
-                "additionalProperties": { "type": "string" },
-                "type": "object"
-              },
-              { "type": "null" }
-            ],
-            "title": "Context"
-          }
-        },
-        "type": "object",
-        "required": ["message"],
-        "title": "StreamChatRequest",
-        "description": "Request model for streaming chat with optional context."
-      },
       "SubmissionStatus": {
         "type": "string",
         "enum": ["DRAFT", "PENDING", "APPROVED", "REJECTED"],

autogpt_platform/frontend/src/components/contextual/EditAgentModal/components/EditAgentForm.tsx

@@ -133,7 +133,7 @@ export function EditAgentForm({
               <Input
                 id={field.name}
                 label="Changes Summary"
-                type="text"
+                type="textarea"
                 placeholder="Briefly describe what you changed"
                 error={form.formState.errors.changes_summary?.message}
                 {...field}

autogpt_platform/frontend/src/components/contextual/EditAgentModal/components/useEditAgentForm.ts

@@ -47,7 +47,7 @@ export const useEditAgentForm = ({
     changes_summary: z
       .string()
       .min(1, "Changes summary is required")
-      .max(200, "Changes summary must be less than 200 characters"),
+      .max(500, "Changes summary must be less than 500 characters"),
     agentOutputDemo: z
       .string()
       .refine(validateYouTubeUrl, "Please enter a valid YouTube URL"),

autogpt_platform/frontend/src/components/contextual/PublishAgentModal/components/AgentInfoStep/useAgentInfoStep.ts

@@ -53,21 +53,24 @@ export function useAgentInfoStep({
   useEffect(() => {
     if (initialData?.agent_id) {
       setAgentId(initialData.agent_id);
-      const initialImages = [
-        ...(initialData?.thumbnailSrc ? [initialData.thumbnailSrc] : []),
-        ...(initialData.additionalImages || []),
-      ];
-      setImages(initialImages);
-
-      // Update form with initial data
+      setImages(
+        Array.from(
+          new Set([
+            ...(initialData?.thumbnailSrc ? [initialData.thumbnailSrc] : []),
+            ...(initialData.additionalImages || []),
+          ]),
+        ),
+      );
       form.reset({
-        changesSummary: initialData.changesSummary || "",
+        changesSummary: isMarketplaceUpdate
+          ? ""
+          : initialData.changesSummary || "",
         title: initialData.title,
         subheader: initialData.subheader,
         slug: initialData.slug.toLocaleLowerCase().trim(),
         youtubeLink: initialData.youtubeLink,
         category: initialData.category,
-        description: initialData.description,
+        description: isMarketplaceUpdate ? "" : initialData.description,
         recommendedScheduleCron: initialData.recommendedScheduleCron || "",
         instructions: initialData.instructions || "",
         agentOutputDemo: initialData.agentOutputDemo || "",
@@ -149,12 +152,7 @@ export function useAgentInfoStep({
     agentId,
     images,
     isSubmitting,
-    initialImages: initialData
-      ? [
-          ...(initialData?.thumbnailSrc ? [initialData.thumbnailSrc] : []),
-          ...(initialData.additionalImages || []),
-        ]
-      : [],
+    initialImages: images,
     initialSelectedImage: initialData?.thumbnailSrc || null,
     handleImagesChange,
     handleSubmit: form.handleSubmit(handleFormSubmit),

docs/_javascript/mathjax.js

@@ -1,16 +0,0 @@
-window.MathJax = {
-    tex: {
-        inlineMath: [["\\(", "\\)"]],
-        displayMath: [["\\[", "\\]"]],
-        processEscapes: true,
-        processEnvironments: true
-    },
-    options: {
-        ignoreHtmlClass: ".*|",
-        processHtmlClass: "arithmatex"
-    }
-};
-
-document$.subscribe(() => {
-    MathJax.typesetPromise()
-})

docs/_javascript/tablesort.js

@@ -1,6 +0,0 @@
-document$.subscribe(function () {
-    var tables = document.querySelectorAll("article table:not([class])")
-    tables.forEach(function (table) {
-        new Tablesort(table)
-    })
-})

docs/content/contribute/index.md

@@ -1,48 +1,35 @@
 # Contributing to the Docs
 
-We welcome contributions to our documentation! If you would like to contribute, please follow the steps below.
+We welcome contributions to our documentation! Our docs are hosted on GitBook and synced with GitHub.
 
-## Setting up the Docs
+## How It Works
 
-1. Clone the repository:
+- Documentation lives in the `docs/` directory on the `gitbook` branch
+- GitBook automatically syncs changes from GitHub
+- You can edit docs directly on GitHub or locally
+
+## Editing Docs Locally
+
+1. Clone the repository and switch to the gitbook branch:
 
     ```shell
-    git clone github.com/Significant-Gravitas/AutoGPT.git
+    git clone https://github.com/Significant-Gravitas/AutoGPT.git
+    cd AutoGPT
+    git checkout gitbook
     ```
 
-1. Install the dependencies:
+2. Make your changes to markdown files in `docs/`
 
-    ```shell
-    python -m pip install -r docs/requirements.txt
-    ```
+3. Preview changes:
+   - Push to a branch and create a PR - GitBook will generate a preview
+   - Or use any markdown preview tool locally
 
-    or
+## Adding a New Page
 
-    ```shell
-    python3 -m pip install -r docs/requirements.txt
-    ```
-
-1. Start iterating using mkdocs' live server:
-
-    ```shell
-    mkdocs serve
-    ```
-
-1. Open your browser and navigate to `http://127.0.0.1:8000`.
-
-1. The server will automatically reload the docs when you save your changes.
-
-## Adding a new page
-
-1. Create a new markdown file in the `docs/content` directory.
-1. Add the new page to the `nav` section in the `mkdocs.yml` file.
-1. Add the content to the new markdown file.
-1. Run `mkdocs serve` to see your changes.
-
-## Checking links
-
-To check for broken links in the documentation, run `mkdocs build` and look for warnings in the console output.
+1. Create a new markdown file in the appropriate `docs/` subdirectory
+2. Add the new page to the relevant `SUMMARY.md` file to include it in the navigation
+3. Submit a pull request to the `gitbook` branch
 
 ## Submitting a Pull Request
 
-When you're ready to submit your changes, please create a pull request. We will review your changes and merge them if they are appropriate.
+When you're ready to submit your changes, create a pull request targeting the `gitbook` branch. We will review your changes and merge them if appropriate.

docs/mkdocs.yml

@@ -1,194 +0,0 @@
-site_name: AutoGPT Documentation
-site_url: https://docs.agpt.co/
-repo_url: https://github.com/Significant-Gravitas/AutoGPT
-repo_name: AutoGPT
-edit_uri: edit/master/docs/content
-docs_dir: content
-nav:
-  - Home: index.md
-
-  - The AutoGPT Platform 🆕:
-    - Getting Started:
-        - Setup AutoGPT (Local-Host): platform/getting-started.md
-        - Edit an Agent: platform/edit-agent.md
-        - Delete an Agent: platform/delete-agent.md
-        - Download & Import and Agent: platform/download-agent-from-marketplace-local.md
-        - Create a Basic Agent: platform/create-basic-agent.md
-        - Submit an Agent to the Marketplace: platform/submit-agent-to-marketplace.md
-    - Advanced Setup: platform/advanced_setup.md
-    - Agent Blocks: platform/agent-blocks.md
-    - Build your own Blocks: platform/new_blocks.md
-    - Block SDK Guide: platform/block-sdk-guide.md
-    - Using Ollama: platform/ollama.md
-    - Using AI/ML API: platform/aimlapi.md
-    - Using D-ID: platform/d_id.md
-    - Blocks: platform/blocks/blocks.md
-    - API:
-      - Introduction: platform/integrating/api-guide.md
-      - OAuth & SSO: platform/integrating/oauth-guide.md
-    - Contributing:
-        - Tests: platform/contributing/tests.md
-        - OAuth Flows: platform/contributing/oauth-integration-flow.md
-  - AutoGPT Classic:
-      - Introduction: classic/index.md
-      - Setup:
-          - Setting up AutoGPT: classic/setup/index.md
-          - Set up with Docker: classic/setup/docker.md
-          - For Developers: classic/setup/for-developers.md
-          - Configuration:
-              - Options: classic/configuration/options.md
-              - Search: classic/configuration/search.md
-              - Voice: classic/configuration/voice.md
-      - Usage: classic/usage.md
-      - Help us improve AutoGPT:
-          - Share your debug logs with us: classic/share-your-logs.md
-          - Contribution guide: contributing.md
-          - Running tests: classic/testing.md
-          - Code of Conduct: code-of-conduct.md
-      - Benchmark:
-          - Readme: https://github.com/Significant-Gravitas/AutoGPT/blob/master/classic/benchmark/README.md
-      - Forge:
-         - Introduction: forge/get-started.md
-         - Components:
-             - Introduction: forge/components/introduction.md
-             - Agents: forge/components/agents.md
-             - Components: forge/components/components.md
-             - Protocols: forge/components/protocols.md
-             - Commands: forge/components/commands.md
-             - Built in Components: forge/components/built-in-components.md
-             - Creating Components: forge/components/creating-components.md
-      - Frontend:
-         - Readme: https://github.com/Significant-Gravitas/AutoGPT/blob/master/classic/frontend/README.md
-
-  - Contribute: 
-        - Introduction: contribute/index.md
-        - Testing: ../../autogpt_platform/backend/TESTING.md
-    
-  # - Challenges:
-  #     - Introduction: challenges/introduction.md
-  #     - List of Challenges:
-  #         - Memory:
-  #             - Introduction: challenges/memory/introduction.md
-  #             - Memory Challenge A: challenges/memory/challenge_a.md
-  #             - Memory Challenge B: challenges/memory/challenge_b.md
-  #             - Memory Challenge C: challenges/memory/challenge_c.md
-  #             - Memory Challenge D: challenges/memory/challenge_d.md
-  #         - Information retrieval:
-  #             - Introduction: challenges/information_retrieval/introduction.md
-  #             - Information Retrieval Challenge A: challenges/information_retrieval/challenge_a.md
-  #             - Information Retrieval Challenge B: challenges/information_retrieval/challenge_b.md
-  # - Submit a Challenge: challenges/submit.md
-  # - Beat a Challenge: challenges/beat.md
-
-  - License: https://github.com/Significant-Gravitas/AutoGPT/blob/master/LICENSE
-
-theme:
-  name: material
-  custom_dir: overrides
-  language: en
-  icon:
-    repo: fontawesome/brands/github
-    logo: material/book-open-variant
-    edit: material/pencil
-    view: material/eye
-  favicon: assets/favicon.png
-  features:
-    - navigation.sections
-    - navigation.footer
-    - navigation.top
-    - navigation.tracking
-    - navigation.tabs
-    # - navigation.path
-    - toc.follow
-    - toc.integrate
-    - content.action.edit
-    - content.action.view
-    - content.code.copy
-    - content.code.annotate
-    - content.tabs.link
-  palette:
-    # Palette toggle for light mode
-    - media: "(prefers-color-scheme: light)"
-      scheme: default
-      toggle:
-        icon: material/weather-night
-        name: Switch to dark mode
-
-    # Palette toggle for dark mode
-    - media: "(prefers-color-scheme: dark)"
-      scheme: slate
-      toggle:
-        icon: material/weather-sunny
-        name: Switch to light mode
-
-markdown_extensions:
-  # Python Markdown
-  - abbr
-  - admonition
-  - attr_list
-  - def_list
-  - footnotes
-  - md_in_html
-  - toc:
-      permalink: true
-  - tables
-
-  # Python Markdown Extensions
-  - pymdownx.arithmatex:
-      generic: true
-  - pymdownx.betterem:
-      smart_enable: all
-  - pymdownx.critic
-  - pymdownx.caret
-  - pymdownx.details
-  - pymdownx.emoji:
-      emoji_index: !!python/name:material.extensions.emoji.twemoji
-      emoji_generator: !!python/name:material.extensions.emoji.to_svg
-  - pymdownx.highlight
-  - pymdownx.inlinehilite
-  - pymdownx.keys
-  - pymdownx.mark
-  - pymdownx.smartsymbols
-  - pymdownx.snippets:
-      base_path: ['.','../']
-      check_paths: true
-      dedent_subsections: true
-  - pymdownx.superfences:
-      custom_fences:
-        - name: mermaid
-          class: mermaid
-          format: !!python/name:pymdownx.superfences.fence_code_format
-  - pymdownx.tabbed:
-      alternate_style: true
-  - pymdownx.tasklist:
-      custom_checkbox: true
-  - pymdownx.tilde
-
-plugins:
-  - table-reader
-  - search
-  - git-revision-date-localized:
-      enable_creation_date: true
-
-extra:
-  social:
-    - icon: fontawesome/brands/github
-      link: https://github.com/Significant-Gravitas/AutoGPT
-    - icon: fontawesome/brands/x-twitter
-      link: https://x.com/Auto_GPT
-    - icon: fontawesome/brands/instagram
-      link: https://www.instagram.com/autogpt/
-    - icon: fontawesome/brands/discord
-      link: https://discord.gg/autogpt
-      
-extra:
-  analytics:
-    provider: google
-    property: G-XKPNKB9XG6
-
-extra_javascript:
-  - https://unpkg.com/tablesort@5.3.0/dist/tablesort.min.js
-  - _javascript/tablesort.js
-  - _javascript/mathjax.js
-  - https://cdnjs.cloudflare.com/polyfill/v3/polyfill.min.js?features=es6
-  - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js

docs/netlify.toml

@@ -1,5 +0,0 @@
-# Netlify config for AutoGPT docs
-
-[build]
-  publish = "public/"
-  command = "mkdocs build -d public"

docs/overrides/main.html

@@ -1,61 +0,0 @@
-{% extends "base.html" %}
-
-
-{% block extrahead %}
-<style>
-  svg.ms-w-12 {
-    width: 2rem !important;
-  }
-  svg.ms-h-12 {
-    height: 2rem !important;
-  }
-  /* Temporary solution for the font sizes  */
-  #headlessui-dialog-panel-2 p{
-    font-size: 16px;
-  }
-  #headlessui-dialog-panel-2 textarea{
-    font-size: 16px;
-  }
-  #headlessui-dialog-panel-2 span{
-    font-size: 14px;
-
-  }
-  #headlessui-dialog-panel-2 div{
-    font-size: 16px;
-  }
-  #headlessui-dialog-panel-2 a{
-    font-size: 14px;
-    line-height: 1rem;
-  }
-  #headlessui-dialog-panel-2 button{
-    border: 1px solid #0000001d;
-    line-height: 1rem;
-
-}
-  /* Temporary solution for the font size  */
-  #headlessui-dialog-panel-2 > div > div > div > div.ms-w-full.ms-rounded-xl.ms-flex.ms-flex-col.ms-relative > div > div > div > div > div.ms-flex.ms-flex-row.ms-items-center.ms-justify-between.ms-gap-1 > p{
-    font-size: 14px;
-    line-height: 1rem;
-  }
-
-</style>
-
-<div id="my-component-root" class="mendable-search"></div>
-
-<script src="https://unpkg.com/@mendable/search@0.0.155/dist/umd/mendable-bundle.min.js"></script>
-{% raw %}
-<script>
-    Mendable.initialize({
-      anon_key: 'a0bd44db-eb3b-412f-8924-b31c58244a64',
-      type: 'floatingButton',
-      style : { accentColor: '#3F51B5', darkMode: false },
-      floatingButtonStyle:{
-        backgroundColor: '#3F51B5',
-        color: '#fff',
-      },
-      icon: "https://mendable-storage.s3.amazonaws.com/autoGPT.gif",
-      botIcon: "https://mendable-storage.s3.amazonaws.com/autoGPTbot.gif",
-    })
-  </script>
-{% endraw %}
-{% endblock %}

docs/platform/SUMMARY.md

@@ -0,0 +1,34 @@
+# Table of contents
+
+* [What is the AutoGPT Platform?](what-is-autogpt-platform.md)
+
+## Getting Started
+
+* [Setting Up Auto-GPT (Local Host)](getting-started.md)
+* [AutoGPT Platform Installer](installer.md)
+* [Edit an Agent](edit-agent.md)
+* [Delete an Agent](delete-agent.md)
+* [Download & Import an Agent](download-agent-from-marketplace-local.md)
+* [Create a Basic Agent](create-basic-agent.md)
+* [Submit an Agent to the Marketplace](submit-agent-to-marketplace.md)
+
+## Advanced Setup
+
+* [Advanced Setup](advanced_setup.md)
+
+## Building Blocks
+
+* [Agent Blocks Overview](agent-blocks.md)
+* [Build your own Blocks](new_blocks.md)
+* [Block SDK Guide](block-sdk-guide.md)
+
+## Using AI Services
+
+* [Using Ollama](ollama.md)
+* [Using AI/ML API](aimlapi.md)
+* [Using D-ID](d_id.md)
+
+## API & Integrations
+
+* [API Introduction](integrating/api-guide.md)
+* [OAuth & SSO](integrating/oauth-guide.md)

docs/platform/block-sdk-guide.md

@@ -227,7 +227,7 @@ backend/blocks/my_provider/
 
 ## Best Practices
 
-1. **Error Handling**: Error output pin is already defined on BlockSchemaOutput
+1. **Error Handling**: Use `BlockInputError` for validation failures and `BlockExecutionError` for runtime errors (import from `backend.util.exceptions`). These inherit from `ValueError` so the executor treats them as user-fixable. See [Error Handling in new_blocks.md](new_blocks.md#error-handling) for details.
 2. **Credentials**: Use the provider's `credentials_field()` method
 3. **Validation**: Use SchemaField constraints (ge, le, min_length, etc.)
 4. **Categories**: Choose appropriate categories for discoverability

docs/platform/new_blocks.md

@@ -616,7 +616,59 @@ custom_requests = Requests(
 
 ### Error Handling
 
-All blocks should have an error output that catches all reasonable errors that a user can handle, wrap them in a ValueError, and re-raise. Don't catch things the system admin would need to fix like being out of money or unreachable addresses.  
+Blocks should raise appropriate exceptions for errors that users can fix. The executor classifies errors based on whether they inherit from `ValueError` - these are treated as "expected failures" (user-fixable) rather than system errors.
+
+#### Block Exception Classes
+
+Import from `backend.util.exceptions`:
+
+```python
+from backend.util.exceptions import BlockInputError, BlockExecutionError
+```
+
+| Exception | Use Case | Example |
+|-----------|----------|---------|
+| `BlockInputError` | Invalid user input, validation failures, missing required fields | Bad API key format, invalid URL, missing credentials |
+| `BlockExecutionError` | Runtime failures the user can address | API errors, auth failures, resource not found, rate limits |
+| `ValueError` | Simple cases (auto-wrapped to `BlockExecutionError`) | Basic validation errors |
+
+#### Raising Exceptions
+
+```python
+from backend.util.exceptions import BlockInputError, BlockExecutionError
+
+class MyBlock(Block):
+    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+        # Input validation - use BlockInputError
+        if not input_data.api_key:
+            raise BlockInputError(
+                message="API key is required",
+                block_name=self.name,
+                block_id=self.id,
+            )
+
+        try:
+            result = await self.call_api(input_data)
+            yield "result", result
+        except AuthenticationError as e:
+            # API/runtime errors - use BlockExecutionError
+            raise BlockExecutionError(
+                message=f"Authentication failed: {e}",
+                block_name=self.name,
+                block_id=self.id,
+            ) from e
+```
+
+#### What NOT to Catch
+
+Don't catch errors that require system admin intervention:
+
+- Out of money/credits
+- Unreachable infrastructure
+- Database connection failures
+- Internal server errors from your own services
+
+Let these propagate as unexpected errors so they get proper attention.  
 
 ### Data Models
 

docs/platform/what-is-autogpt-platform.md

@@ -0,0 +1,82 @@
+# What is the AutoGPT Platform?
+
+The AutoGPT Platform is a groundbreaking system that revolutionizes AI utilization for businesses and individuals. It enables the creation, deployment, and management of continuous agents that work tirelessly on your behalf, bringing unprecedented efficiency and innovation to your workflows.
+
+## Key Features
+
+* **Seamless Integration and Low-Code Workflows**: Rapidly create complex workflows without extensive coding knowledge.
+* **Autonomous Operation and Continuous Agents**: Deploy cloud-based assistants that run indefinitely, activating on relevant triggers.
+* **Intelligent Automation and Maximum Efficiency**: Streamline workflows by automating repetitive processes.
+* **Reliable Performance and Predictable Execution**: Enjoy consistent and dependable long-running processes.
+
+## Platform Architecture
+
+The AutoGPT Platform consists of two main components:
+
+### 1. AutoGPT Server
+
+The powerhouse of our platform, containing:
+
+* **Source Code**: Core logic driving agents and automation processes.
+* **Infrastructure**: Robust systems ensuring reliable and scalable performance.
+* **Marketplace**: A comprehensive marketplace for pre-built agents.
+
+### 2. AutoGPT Frontend
+
+The user interface where you interact with the platform:
+
+* **Agent Builder**: Design and configure your own AI agents.
+* **Workflow Management**: Build, modify, and optimize automation workflows.
+* **Deployment Controls**: Manage the lifecycle of your agents.
+* **Ready-to-Use Agents**: Select from pre-configured agents.
+* **Agent Interaction**: Run and interact with agents through a user-friendly interface.
+* **Monitoring and Analytics**: Track agent performance and gain insights.
+
+## Platform Components
+
+### Agents and Workflows
+
+In the platform, you can create highly customized workflows to build agents. An agent is essentially an automated workflow that you design to perform specific tasks or processes. Create customized workflows to build agents for various tasks, including:
+
+* Data processing and analysis
+* Task scheduling and management
+* Communication and notification systems
+* Integration between different software tools
+* AI-powered decision making and content generation
+
+### Blocks as Integrations
+
+Blocks represent actions and are the building blocks of your workflows, including:
+
+* Connections to external services
+* Data processing tools
+* AI models for various tasks
+* Custom scripts or functions
+* Conditional logic and decision-making components
+
+You can learn more under: [Build your own Blocks](new_blocks.md)
+
+## Available Language Models
+
+The platform comes pre-integrated with cutting-edge LLM providers:
+
+* OpenAI - <https://openai.com/>
+* Anthropic - <https://www.anthropic.com/>
+* Groq - <https://groq.com/>
+* Llama - <https://llamaindex.ai/>
+* AI/ML API - <https://aimlapi.com/>
+  * AI/ML API provides 300+ AI models including Deepseek, Gemini, ChatGPT. The models run at enterprise-grade rate limits and uptimes.
+
+## License Overview
+
+We've adopted a dual-license approach to balance open collaboration with sustainable development:
+
+* **MIT License**: The majority of the AutoGPT repository remains under this license.
+* **Polyform Shield License**: Applies to the new `autogpt_platform` folder.
+
+This strategy allows us to share previously closed-source components, fostering a vibrant ecosystem of developers and users.
+
+## Ready to Get Started?
+
+* Read the [Getting Started docs](getting-started.md) to self-host.
+* [Join the waitlist](https://agpt.co/waitlist) for the cloud-hosted beta.