Merge branch 'dev' into refactor/remove-old-agent-library-view

## Summary
- Remove left and right borders from tables rendered in CoPilot chat
- Increase cell padding (py-3 → py-3.5) for better spacing between text
and lines
- Applies to both Streamdown (main chat) and MarkdownRenderer (tool
outputs)

Design feedback from Olivia to make tables "breathe" more.

## Test plan
- [ ] Open CoPilot chat and trigger a response containing a table
- [ ] Verify tables no longer have left/right borders
- [ ] Verify increased spacing between rows
- [ ] Check both light and dark modes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

<!-- greptile_comment -->

<h2>Greptile Overview</h2>

<details><summary><h3>Greptile Summary</h3></summary>

Improved CoPilot chat table styling by removing left and right borders
and increasing vertical padding from `py-3` to `py-3.5`. Changes apply
to both:
- Streamdown-rendered tables (via CSS selector in `globals.css`)  
- MarkdownRenderer tables (via Tailwind classes)

The changes make tables "breathe" more per design feedback from Olivia.

**Issue Found:**
- The CSS padding value in `globals.css:192` is `0.625rem` (`py-2.5`)
but should be `0.875rem` (`py-3.5`) to match the PR description and the
MarkdownRenderer implementation.
</details>


<details><summary><h3>Confidence Score: 2/5</h3></summary>

- This PR has a logical error that will cause inconsistent table styling
between Streamdown and MarkdownRenderer tables
- The implementation has an inconsistency where the CSS file uses
`py-2.5` padding while the PR description and MarkdownRenderer use
`py-3.5`. This will result in different table padding between the two
rendering systems, contradicting the goal of consistent styling
improvements.
- Pay close attention to `autogpt_platform/frontend/src/app/globals.css`
- the padding value needs to be corrected to match the intended design
</details>


<!-- greptile_other_comments_section -->

<!-- /greptile_comment -->

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

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

@@ -0,0 +1,154 @@
+"""Dummy Agent Generator for testing.
+
+Returns mock responses matching the format expected from the external service.
+Enable via AGENTGENERATOR_USE_DUMMY=true in settings.
+
+WARNING: This is for testing only. Do not use in production.
+"""
+
+import asyncio
+import logging
+import uuid
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Dummy decomposition result (instructions type)
+DUMMY_DECOMPOSITION_RESULT: dict[str, Any] = {
+    "type": "instructions",
+    "steps": [
+        {
+            "description": "Get input from user",
+            "action": "input",
+            "block_name": "AgentInputBlock",
+        },
+        {
+            "description": "Process the input",
+            "action": "process",
+            "block_name": "TextFormatterBlock",
+        },
+        {
+            "description": "Return output to user",
+            "action": "output",
+            "block_name": "AgentOutputBlock",
+        },
+    ],
+}
+
+# Block IDs from backend/blocks/io.py
+AGENT_INPUT_BLOCK_ID = "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b"
+AGENT_OUTPUT_BLOCK_ID = "363ae599-353e-4804-937e-b2ee3cef3da4"
+
+
+def _generate_dummy_agent_json() -> dict[str, Any]:
+    """Generate a minimal valid agent JSON for testing."""
+    input_node_id = str(uuid.uuid4())
+    output_node_id = str(uuid.uuid4())
+
+    return {
+        "id": str(uuid.uuid4()),
+        "version": 1,
+        "is_active": True,
+        "name": "Dummy Test Agent",
+        "description": "A dummy agent generated for testing purposes",
+        "nodes": [
+            {
+                "id": input_node_id,
+                "block_id": AGENT_INPUT_BLOCK_ID,
+                "input_default": {
+                    "name": "input",
+                    "title": "Input",
+                    "description": "Enter your input",
+                    "placeholder_values": [],
+                },
+                "metadata": {"position": {"x": 0, "y": 0}},
+            },
+            {
+                "id": output_node_id,
+                "block_id": AGENT_OUTPUT_BLOCK_ID,
+                "input_default": {
+                    "name": "output",
+                    "title": "Output",
+                    "description": "Agent output",
+                    "format": "{output}",
+                },
+                "metadata": {"position": {"x": 400, "y": 0}},
+            },
+        ],
+        "links": [
+            {
+                "id": str(uuid.uuid4()),
+                "source_id": input_node_id,
+                "sink_id": output_node_id,
+                "source_name": "result",
+                "sink_name": "value",
+                "is_static": False,
+            },
+        ],
+    }
+
+
+async def decompose_goal_dummy(
+    description: str,
+    context: str = "",
+    library_agents: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Return dummy decomposition result."""
+    logger.info("Using dummy agent generator for decompose_goal")
+    return DUMMY_DECOMPOSITION_RESULT.copy()
+
+
+async def generate_agent_dummy(
+    instructions: dict[str, Any],
+    library_agents: list[dict[str, Any]] | None = None,
+    operation_id: str | None = None,
+    task_id: str | None = None,
+) -> dict[str, Any]:
+    """Return dummy agent JSON after a simulated delay."""
+    logger.info("Using dummy agent generator for generate_agent (30s delay)")
+    await asyncio.sleep(30)
+    return _generate_dummy_agent_json()
+
+
+async def generate_agent_patch_dummy(
+    update_request: str,
+    current_agent: dict[str, Any],
+    library_agents: list[dict[str, Any]] | None = None,
+    operation_id: str | None = None,
+    task_id: str | None = None,
+) -> dict[str, Any]:
+    """Return dummy patched agent (returns the current agent with updated description)."""
+    logger.info("Using dummy agent generator for generate_agent_patch")
+    patched = current_agent.copy()
+    patched["description"] = (
+        f"{current_agent.get('description', '')} (updated: {update_request})"
+    )
+    return patched
+
+
+async def customize_template_dummy(
+    template_agent: dict[str, Any],
+    modification_request: str,
+    context: str = "",
+) -> dict[str, Any]:
+    """Return dummy customized template (returns template with updated description)."""
+    logger.info("Using dummy agent generator for customize_template")
+    customized = template_agent.copy()
+    customized["description"] = (
+        f"{template_agent.get('description', '')} (customized: {modification_request})"
+    )
+    return customized
+
+
+async def get_blocks_dummy() -> list[dict[str, Any]]:
+    """Return dummy blocks list."""
+    logger.info("Using dummy agent generator for get_blocks")
+    return [
+        {"id": AGENT_INPUT_BLOCK_ID, "name": "AgentInputBlock"},
+        {"id": AGENT_OUTPUT_BLOCK_ID, "name": "AgentOutputBlock"},
+    ]
+
+
+async def health_check_dummy() -> bool:
+    """Always returns healthy for dummy service."""
+    return True

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

@@ -12,8 +12,19 @@ import httpx
 
 from backend.util.settings import Settings
 
+from .dummy import (
+    customize_template_dummy,
+    decompose_goal_dummy,
+    generate_agent_dummy,
+    generate_agent_patch_dummy,
+    get_blocks_dummy,
+    health_check_dummy,
+)
+
 logger = logging.getLogger(__name__)
 
+_dummy_mode_warned = False
+
 
 def _create_error_response(
     error_message: str,
@@ -90,10 +101,26 @@ def _get_settings() -> Settings:
     return _settings
 
 
-def is_external_service_configured() -> bool:
-    """Check if external Agent Generator service is configured."""
+def _is_dummy_mode() -> bool:
+    """Check if dummy mode is enabled for testing."""
+    global _dummy_mode_warned
     settings = _get_settings()
-    return bool(settings.config.agentgenerator_host)
+    is_dummy = bool(settings.config.agentgenerator_use_dummy)
+    if is_dummy and not _dummy_mode_warned:
+        logger.warning(
+            "Agent Generator running in DUMMY MODE - returning mock responses. "
+            "Do not use in production!"
+        )
+        _dummy_mode_warned = True
+    return is_dummy
+
+
+def is_external_service_configured() -> bool:
+    """Check if external Agent Generator service is configured (or dummy mode)."""
+    settings = _get_settings()
+    return bool(settings.config.agentgenerator_host) or bool(
+        settings.config.agentgenerator_use_dummy
+    )
 
 
 def _get_base_url() -> str:
@@ -137,6 +164,9 @@ async def decompose_goal_external(
         - {"type": "error", "error": "...", "error_type": "..."} on error
         Or None on unexpected error
     """
+    if _is_dummy_mode():
+        return await decompose_goal_dummy(description, context, library_agents)
+
     client = _get_client()
 
     if context:
@@ -226,6 +256,11 @@ async def generate_agent_external(
     Returns:
         Agent JSON dict, {"status": "accepted"} for async, or error dict {"type": "error", ...} on error
     """
+    if _is_dummy_mode():
+        return await generate_agent_dummy(
+            instructions, library_agents, operation_id, task_id
+        )
+
     client = _get_client()
 
     # Build request payload
@@ -297,6 +332,11 @@ async def generate_agent_patch_external(
     Returns:
         Updated agent JSON, clarifying questions dict, {"status": "accepted"} for async, or error dict on error
     """
+    if _is_dummy_mode():
+        return await generate_agent_patch_dummy(
+            update_request, current_agent, library_agents, operation_id, task_id
+        )
+
     client = _get_client()
 
     # Build request payload
@@ -383,6 +423,11 @@ async def customize_template_external(
     Returns:
         Customized agent JSON, clarifying questions dict, or error dict on error
     """
+    if _is_dummy_mode():
+        return await customize_template_dummy(
+            template_agent, modification_request, context
+        )
+
     client = _get_client()
 
     request = modification_request
@@ -445,6 +490,9 @@ async def get_blocks_external() -> list[dict[str, Any]] | None:
     Returns:
         List of block info dicts or None on error
     """
+    if _is_dummy_mode():
+        return await get_blocks_dummy()
+
     client = _get_client()
 
     try:
@@ -478,6 +526,9 @@ async def health_check() -> bool:
     if not is_external_service_configured():
         return False
 
+    if _is_dummy_mode():
+        return await health_check_dummy()
+
     client = _get_client()
 
     try:

autogpt_platform/backend/backend/blocks/claude_code.py

@@ -1,10 +1,10 @@
 import json
 import shlex
 import uuid
-from typing import Literal, Optional
+from typing import TYPE_CHECKING, Literal, Optional
 
 from e2b import AsyncSandbox as BaseAsyncSandbox
-from pydantic import BaseModel, SecretStr
+from pydantic import SecretStr
 
 from backend.blocks._base import (
     Block,
@@ -20,6 +20,13 @@ from backend.data.model import (
     SchemaField,
 )
 from backend.integrations.providers import ProviderName
+from backend.util.sandbox_files import (
+    SandboxFileOutput,
+    extract_and_store_sandbox_files,
+)
+
+if TYPE_CHECKING:
+    from backend.executor.utils import ExecutionContext
 
 
 class ClaudeCodeExecutionError(Exception):
@@ -174,22 +181,15 @@ class ClaudeCodeBlock(Block):
             advanced=True,
         )
 
-    class FileOutput(BaseModel):
-        """A file extracted from the sandbox."""
-
-        path: str
-        relative_path: str  # Path relative to working directory (for GitHub, etc.)
-        name: str
-        content: str
-
     class Output(BlockSchemaOutput):
         response: str = SchemaField(
             description="The output/response from Claude Code execution"
         )
-        files: list["ClaudeCodeBlock.FileOutput"] = SchemaField(
+        files: list[SandboxFileOutput] = SchemaField(
             description=(
                 "List of text files created/modified by Claude Code during this execution. "
-                "Each file has 'path', 'relative_path', 'name', and 'content' fields."
+                "Each file has 'path', 'relative_path', 'name', 'content', and 'workspace_ref' fields. "
+                "workspace_ref contains a workspace:// URI if the file was stored to workspace."
             )
         )
         conversation_history: str = SchemaField(
@@ -252,6 +252,7 @@ class ClaudeCodeBlock(Block):
                             "relative_path": "index.html",
                             "name": "index.html",
                             "content": "<html>Hello World</html>",
+                            "workspace_ref": None,
                         }
                     ],
                 ),
@@ -267,11 +268,12 @@ class ClaudeCodeBlock(Block):
                 "execute_claude_code": lambda *args, **kwargs: (
                     "Created index.html with hello world content",  # response
                     [
-                        ClaudeCodeBlock.FileOutput(
+                        SandboxFileOutput(
                             path="/home/user/index.html",
                             relative_path="index.html",
                             name="index.html",
                             content="<html>Hello World</html>",
+                            workspace_ref=None,
                         )
                     ],  # files
                     "User: Create a hello world HTML file\n"
@@ -294,7 +296,8 @@ class ClaudeCodeBlock(Block):
         existing_sandbox_id: str,
         conversation_history: str,
         dispose_sandbox: bool,
-    ) -> tuple[str, list["ClaudeCodeBlock.FileOutput"], str, str, str]:
+        execution_context: "ExecutionContext",
+    ) -> tuple[str, list[SandboxFileOutput], str, str, str]:
         """
         Execute Claude Code in an E2B sandbox.
 
@@ -449,14 +452,18 @@ class ClaudeCodeBlock(Block):
                 else:
                     new_conversation_history = turn_entry
 
-            # Extract files created/modified during this run
-            files = await self._extract_files(
-                sandbox, working_directory, start_timestamp
+            # Extract files created/modified during this run and store to workspace
+            sandbox_files = await extract_and_store_sandbox_files(
+                sandbox=sandbox,
+                working_directory=working_directory,
+                execution_context=execution_context,
+                since_timestamp=start_timestamp,
+                text_only=True,
             )
 
             return (
                 response,
-                files,
+                sandbox_files,  # Already SandboxFileOutput objects
                 new_conversation_history,
                 current_session_id,
                 sandbox_id,
@@ -471,140 +478,6 @@ class ClaudeCodeBlock(Block):
             if dispose_sandbox and sandbox:
                 await sandbox.kill()
 
-    async def _extract_files(
-        self,
-        sandbox: BaseAsyncSandbox,
-        working_directory: str,
-        since_timestamp: str | None = None,
-    ) -> list["ClaudeCodeBlock.FileOutput"]:
-        """
-        Extract text files created/modified during this Claude Code execution.
-
-        Args:
-            sandbox: The E2B sandbox instance
-            working_directory: Directory to search for files
-            since_timestamp: ISO timestamp - only return files modified after this time
-
-        Returns:
-            List of FileOutput objects with path, relative_path, name, and content
-        """
-        files: list[ClaudeCodeBlock.FileOutput] = []
-
-        # Text file extensions we can safely read as text
-        text_extensions = {
-            ".txt",
-            ".md",
-            ".html",
-            ".htm",
-            ".css",
-            ".js",
-            ".ts",
-            ".jsx",
-            ".tsx",
-            ".json",
-            ".xml",
-            ".yaml",
-            ".yml",
-            ".toml",
-            ".ini",
-            ".cfg",
-            ".conf",
-            ".py",
-            ".rb",
-            ".php",
-            ".java",
-            ".c",
-            ".cpp",
-            ".h",
-            ".hpp",
-            ".cs",
-            ".go",
-            ".rs",
-            ".swift",
-            ".kt",
-            ".scala",
-            ".sh",
-            ".bash",
-            ".zsh",
-            ".sql",
-            ".graphql",
-            ".env",
-            ".gitignore",
-            ".dockerfile",
-            "Dockerfile",
-            ".vue",
-            ".svelte",
-            ".astro",
-            ".mdx",
-            ".rst",
-            ".tex",
-            ".csv",
-            ".log",
-        }
-
-        try:
-            # List files recursively using find command
-            # Exclude node_modules and .git directories, but allow hidden files
-            # like .env and .gitignore (they're filtered by text_extensions later)
-            # Filter by timestamp to only get files created/modified during this run
-            safe_working_dir = shlex.quote(working_directory)
-            timestamp_filter = ""
-            if since_timestamp:
-                timestamp_filter = f"-newermt {shlex.quote(since_timestamp)} "
-            find_result = await sandbox.commands.run(
-                f"find {safe_working_dir} -type f "
-                f"{timestamp_filter}"
-                f"-not -path '*/node_modules/*' "
-                f"-not -path '*/.git/*' "
-                f"2>/dev/null"
-            )
-
-            if find_result.stdout:
-                for file_path in find_result.stdout.strip().split("\n"):
-                    if not file_path:
-                        continue
-
-                    # Check if it's a text file we can read
-                    is_text = any(
-                        file_path.endswith(ext) for ext in text_extensions
-                    ) or file_path.endswith("Dockerfile")
-
-                    if is_text:
-                        try:
-                            content = await sandbox.files.read(file_path)
-                            # Handle bytes or string
-                            if isinstance(content, bytes):
-                                content = content.decode("utf-8", errors="replace")
-
-                            # Extract filename from path
-                            file_name = file_path.split("/")[-1]
-
-                            # Calculate relative path by stripping working directory
-                            relative_path = file_path
-                            if file_path.startswith(working_directory):
-                                relative_path = file_path[len(working_directory) :]
-                                # Remove leading slash if present
-                                if relative_path.startswith("/"):
-                                    relative_path = relative_path[1:]
-
-                            files.append(
-                                ClaudeCodeBlock.FileOutput(
-                                    path=file_path,
-                                    relative_path=relative_path,
-                                    name=file_name,
-                                    content=content,
-                                )
-                            )
-                        except Exception:
-                            # Skip files that can't be read
-                            pass
-
-        except Exception:
-            # If file extraction fails, return empty results
-            pass
-
-        return files
-
     def _escape_prompt(self, prompt: str) -> str:
         """Escape the prompt for safe shell execution."""
         # Use single quotes and escape any single quotes in the prompt
@@ -617,6 +490,7 @@ class ClaudeCodeBlock(Block):
         *,
         e2b_credentials: APIKeyCredentials,
         anthropic_credentials: APIKeyCredentials,
+        execution_context: "ExecutionContext",
         **kwargs,
     ) -> BlockOutput:
         try:
@@ -637,6 +511,7 @@ class ClaudeCodeBlock(Block):
                 existing_sandbox_id=input_data.sandbox_id,
                 conversation_history=input_data.conversation_history,
                 dispose_sandbox=input_data.dispose_sandbox,
+                execution_context=execution_context,
             )
 
             yield "response", response

autogpt_platform/backend/backend/blocks/code_executor.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
 from e2b_code_interpreter import AsyncSandbox
 from e2b_code_interpreter import Result as E2BExecutionResult
@@ -20,6 +20,13 @@ from backend.data.model import (
     SchemaField,
 )
 from backend.integrations.providers import ProviderName
+from backend.util.sandbox_files import (
+    SandboxFileOutput,
+    extract_and_store_sandbox_files,
+)
+
+if TYPE_CHECKING:
+    from backend.executor.utils import ExecutionContext
 
 TEST_CREDENTIALS = APIKeyCredentials(
     id="01234567-89ab-cdef-0123-456789abcdef",
@@ -85,6 +92,9 @@ class CodeExecutionResult(MainCodeExecutionResult):
 class BaseE2BExecutorMixin:
     """Shared implementation methods for E2B executor blocks."""
 
+    # Default working directory in E2B sandboxes
+    WORKING_DIR = "/home/user"
+
     async def execute_code(
         self,
         api_key: str,
@@ -95,14 +105,21 @@ class BaseE2BExecutorMixin:
         timeout: Optional[int] = None,
         sandbox_id: Optional[str] = None,
         dispose_sandbox: bool = False,
+        execution_context: Optional["ExecutionContext"] = None,
+        extract_files: bool = False,
     ):
         """
         Unified code execution method that handles all three use cases:
         1. Create new sandbox and execute (ExecuteCodeBlock)
         2. Create new sandbox, execute, and return sandbox_id (InstantiateCodeSandboxBlock)
         3. Connect to existing sandbox and execute (ExecuteCodeStepBlock)
+
+        Args:
+            extract_files: If True and execution_context provided, extract files
+                           created/modified during execution and store to workspace.
         """  # noqa
         sandbox = None
+        files: list[SandboxFileOutput] = []
         try:
             if sandbox_id:
                 # Connect to existing sandbox (ExecuteCodeStepBlock case)
@@ -118,6 +135,12 @@ class BaseE2BExecutorMixin:
                     for cmd in setup_commands:
                         await sandbox.commands.run(cmd)
 
+            # Capture timestamp before execution to scope file extraction
+            start_timestamp = None
+            if extract_files:
+                ts_result = await sandbox.commands.run("date -u +%Y-%m-%dT%H:%M:%S")
+                start_timestamp = ts_result.stdout.strip() if ts_result.stdout else None
+
             # Execute the code
             execution = await sandbox.run_code(
                 code,
@@ -133,7 +156,24 @@ class BaseE2BExecutorMixin:
             stdout_logs = "".join(execution.logs.stdout)
             stderr_logs = "".join(execution.logs.stderr)
 
-            return results, text_output, stdout_logs, stderr_logs, sandbox.sandbox_id
+            # Extract files created/modified during this execution
+            if extract_files and execution_context:
+                files = await extract_and_store_sandbox_files(
+                    sandbox=sandbox,
+                    working_directory=self.WORKING_DIR,
+                    execution_context=execution_context,
+                    since_timestamp=start_timestamp,
+                    text_only=False,  # Include binary files too
+                )
+
+            return (
+                results,
+                text_output,
+                stdout_logs,
+                stderr_logs,
+                sandbox.sandbox_id,
+                files,
+            )
         finally:
             # Dispose of sandbox if requested to reduce usage costs
             if dispose_sandbox and sandbox:
@@ -238,6 +278,12 @@ class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
             description="Standard output logs from execution"
         )
         stderr_logs: str = SchemaField(description="Standard error logs from execution")
+        files: list[SandboxFileOutput] = SchemaField(
+            description=(
+                "Files created or modified during execution. "
+                "Each file has path, name, content, and workspace_ref (if stored)."
+            ),
+        )
 
     def __init__(self):
         super().__init__(
@@ -259,23 +305,30 @@ class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
                 ("results", []),
                 ("response", "Hello World"),
                 ("stdout_logs", "Hello World\n"),
+                ("files", []),
             ],
             test_mock={
-                "execute_code": lambda api_key, code, language, template_id, setup_commands, timeout, dispose_sandbox: (  # noqa
+                "execute_code": lambda api_key, code, language, template_id, setup_commands, timeout, dispose_sandbox, execution_context, extract_files: (  # noqa
                     [],  # results
                     "Hello World",  # text_output
                     "Hello World\n",  # stdout_logs
                     "",  # stderr_logs
                     "sandbox_id",  # sandbox_id
+                    [],  # files
                 ),
             },
         )
 
     async def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+        self,
+        input_data: Input,
+        *,
+        credentials: APIKeyCredentials,
+        execution_context: "ExecutionContext",
+        **kwargs,
     ) -> BlockOutput:
         try:
-            results, text_output, stdout, stderr, _ = await self.execute_code(
+            results, text_output, stdout, stderr, _, files = await self.execute_code(
                 api_key=credentials.api_key.get_secret_value(),
                 code=input_data.code,
                 language=input_data.language,
@@ -283,6 +336,8 @@ class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
                 setup_commands=input_data.setup_commands,
                 timeout=input_data.timeout,
                 dispose_sandbox=input_data.dispose_sandbox,
+                execution_context=execution_context,
+                extract_files=True,
             )
 
             # Determine result object shape & filter out empty formats
@@ -296,6 +351,8 @@ class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
                 yield "stdout_logs", stdout
             if stderr:
                 yield "stderr_logs", stderr
+            # Always yield files (empty list if none)
+            yield "files", [f.model_dump() for f in files]
         except Exception as e:
             yield "error", str(e)
 
@@ -393,6 +450,7 @@ class InstantiateCodeSandboxBlock(Block, BaseE2BExecutorMixin):
                     "Hello World\n",  # stdout_logs
                     "",  # stderr_logs
                     "sandbox_id",  # sandbox_id
+                    [],  # files
                 ),
             },
         )
@@ -401,7 +459,7 @@ class InstantiateCodeSandboxBlock(Block, BaseE2BExecutorMixin):
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         try:
-            _, text_output, stdout, stderr, sandbox_id = await self.execute_code(
+            _, text_output, stdout, stderr, sandbox_id, _ = await self.execute_code(
                 api_key=credentials.api_key.get_secret_value(),
                 code=input_data.setup_code,
                 language=input_data.language,
@@ -500,6 +558,7 @@ class ExecuteCodeStepBlock(Block, BaseE2BExecutorMixin):
                     "Hello World\n",  # stdout_logs
                     "",  # stderr_logs
                     sandbox_id,  # sandbox_id
+                    [],  # files
                 ),
             },
         )
@@ -508,7 +567,7 @@ class ExecuteCodeStepBlock(Block, BaseE2BExecutorMixin):
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         try:
-            results, text_output, stdout, stderr, _ = await self.execute_code(
+            results, text_output, stdout, stderr, _, _ = await self.execute_code(
                 api_key=credentials.api_key.get_secret_value(),
                 code=input_data.step_code,
                 language=input_data.language,

autogpt_platform/backend/backend/util/sandbox_files.py

@@ -0,0 +1,288 @@
+"""
+Shared utilities for extracting and storing files from E2B sandboxes.
+
+This module provides common file extraction and workspace storage functionality
+for blocks that run code in E2B sandboxes (Claude Code, Code Executor, etc.).
+"""
+
+import base64
+import logging
+import mimetypes
+import shlex
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from backend.util.file import store_media_file
+from backend.util.type import MediaFileType
+
+if TYPE_CHECKING:
+    from e2b import AsyncSandbox as BaseAsyncSandbox
+
+    from backend.executor.utils import ExecutionContext
+
+logger = logging.getLogger(__name__)
+
+# Text file extensions that can be safely read and stored as text
+TEXT_EXTENSIONS = {
+    ".txt",
+    ".md",
+    ".html",
+    ".htm",
+    ".css",
+    ".js",
+    ".ts",
+    ".jsx",
+    ".tsx",
+    ".json",
+    ".xml",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".ini",
+    ".cfg",
+    ".conf",
+    ".py",
+    ".rb",
+    ".php",
+    ".java",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".cs",
+    ".go",
+    ".rs",
+    ".swift",
+    ".kt",
+    ".scala",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".sql",
+    ".graphql",
+    ".env",
+    ".gitignore",
+    ".dockerfile",
+    "Dockerfile",
+    ".vue",
+    ".svelte",
+    ".astro",
+    ".mdx",
+    ".rst",
+    ".tex",
+    ".csv",
+    ".log",
+}
+
+
+class SandboxFileOutput(BaseModel):
+    """A file extracted from a sandbox and optionally stored in workspace."""
+
+    path: str
+    """Full path in the sandbox."""
+
+    relative_path: str
+    """Path relative to the working directory."""
+
+    name: str
+    """Filename only."""
+
+    content: str
+    """File content as text (for backward compatibility)."""
+
+    workspace_ref: str | None = None
+    """Workspace reference (workspace://{id}#mime) if stored, None otherwise."""
+
+
+@dataclass
+class ExtractedFile:
+    """Internal representation of an extracted file before storage."""
+
+    path: str
+    relative_path: str
+    name: str
+    content: bytes
+    is_text: bool
+
+
+async def extract_sandbox_files(
+    sandbox: "BaseAsyncSandbox",
+    working_directory: str,
+    since_timestamp: str | None = None,
+    text_only: bool = True,
+) -> list[ExtractedFile]:
+    """
+    Extract files from an E2B sandbox.
+
+    Args:
+        sandbox: The E2B sandbox instance
+        working_directory: Directory to search for files
+        since_timestamp: ISO timestamp - only return files modified after this time
+        text_only: If True, only extract text files (default). If False, extract all files.
+
+    Returns:
+        List of ExtractedFile objects with path, content, and metadata
+    """
+    files: list[ExtractedFile] = []
+
+    try:
+        # Build find command
+        safe_working_dir = shlex.quote(working_directory)
+        timestamp_filter = ""
+        if since_timestamp:
+            timestamp_filter = f"-newermt {shlex.quote(since_timestamp)} "
+
+        find_result = await sandbox.commands.run(
+            f"find {safe_working_dir} -type f "
+            f"{timestamp_filter}"
+            f"-not -path '*/node_modules/*' "
+            f"-not -path '*/.git/*' "
+            f"2>/dev/null"
+        )
+
+        if not find_result.stdout:
+            return files
+
+        for file_path in find_result.stdout.strip().split("\n"):
+            if not file_path:
+                continue
+
+            # Check if it's a text file
+            is_text = any(file_path.endswith(ext) for ext in TEXT_EXTENSIONS)
+
+            # Skip non-text files if text_only mode
+            if text_only and not is_text:
+                continue
+
+            try:
+                # Read file content as bytes
+                content = await sandbox.files.read(file_path, format="bytes")
+                if isinstance(content, str):
+                    content = content.encode("utf-8")
+                elif isinstance(content, bytearray):
+                    content = bytes(content)
+
+                # Extract filename from path
+                file_name = file_path.split("/")[-1]
+
+                # Calculate relative path
+                relative_path = file_path
+                if file_path.startswith(working_directory):
+                    relative_path = file_path[len(working_directory) :]
+                    if relative_path.startswith("/"):
+                        relative_path = relative_path[1:]
+
+                files.append(
+                    ExtractedFile(
+                        path=file_path,
+                        relative_path=relative_path,
+                        name=file_name,
+                        content=content,
+                        is_text=is_text,
+                    )
+                )
+            except Exception as e:
+                logger.debug(f"Failed to read file {file_path}: {e}")
+                continue
+
+    except Exception as e:
+        logger.warning(f"File extraction failed: {e}")
+
+    return files
+
+
+async def store_sandbox_files(
+    extracted_files: list[ExtractedFile],
+    execution_context: "ExecutionContext",
+) -> list[SandboxFileOutput]:
+    """
+    Store extracted sandbox files to workspace and return output objects.
+
+    Args:
+        extracted_files: List of files extracted from sandbox
+        execution_context: Execution context for workspace storage
+
+    Returns:
+        List of SandboxFileOutput objects with workspace refs
+    """
+    outputs: list[SandboxFileOutput] = []
+
+    for file in extracted_files:
+        # Decode content for text files (for backward compat content field)
+        if file.is_text:
+            try:
+                content_str = file.content.decode("utf-8", errors="replace")
+            except Exception:
+                content_str = ""
+        else:
+            content_str = f"[Binary file: {len(file.content)} bytes]"
+
+        # Build data URI (needed for storage and as binary fallback)
+        mime_type = mimetypes.guess_type(file.name)[0] or "application/octet-stream"
+        data_uri = f"data:{mime_type};base64,{base64.b64encode(file.content).decode()}"
+
+        # Try to store in workspace
+        workspace_ref: str | None = None
+        try:
+            result = await store_media_file(
+                file=MediaFileType(data_uri),
+                execution_context=execution_context,
+                return_format="for_block_output",
+            )
+            if result.startswith("workspace://"):
+                workspace_ref = result
+            elif not file.is_text:
+                # Non-workspace context (graph execution): store_media_file
+                # returned a data URI — use it as content so binary data isn't lost.
+                content_str = result
+        except Exception as e:
+            logger.warning(f"Failed to store file {file.name} to workspace: {e}")
+            # For binary files, fall back to data URI to prevent data loss
+            if not file.is_text:
+                content_str = data_uri
+
+        outputs.append(
+            SandboxFileOutput(
+                path=file.path,
+                relative_path=file.relative_path,
+                name=file.name,
+                content=content_str,
+                workspace_ref=workspace_ref,
+            )
+        )
+
+    return outputs
+
+
+async def extract_and_store_sandbox_files(
+    sandbox: "BaseAsyncSandbox",
+    working_directory: str,
+    execution_context: "ExecutionContext",
+    since_timestamp: str | None = None,
+    text_only: bool = True,
+) -> list[SandboxFileOutput]:
+    """
+    Extract files from sandbox and store them in workspace.
+
+    This is the main entry point combining extraction and storage.
+
+    Args:
+        sandbox: The E2B sandbox instance
+        working_directory: Directory to search for files
+        execution_context: Execution context for workspace storage
+        since_timestamp: ISO timestamp - only return files modified after this time
+        text_only: If True, only extract text files
+
+    Returns:
+        List of SandboxFileOutput objects with content and workspace refs
+    """
+    extracted = await extract_sandbox_files(
+        sandbox=sandbox,
+        working_directory=working_directory,
+        since_timestamp=since_timestamp,
+        text_only=text_only,
+    )
+
+    return await store_sandbox_files(extracted, execution_context)

autogpt_platform/backend/backend/util/settings.py

@@ -368,6 +368,10 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
         default=600,
         description="The timeout in seconds for Agent Generator service requests (includes retries for rate limits)",
     )
+    agentgenerator_use_dummy: bool = Field(
+        default=False,
+        description="Use dummy agent generator responses for testing (bypasses external service)",
+    )
 
     enable_example_blocks: bool = Field(
         default=False,

autogpt_platform/backend/test/agent_generator/test_service.py

@@ -25,6 +25,7 @@ class TestServiceConfiguration:
         """Test that external service is not configured when host is empty."""
         mock_settings = MagicMock()
         mock_settings.config.agentgenerator_host = ""
+        mock_settings.config.agentgenerator_use_dummy = False
 
         with patch.object(service, "_get_settings", return_value=mock_settings):
             assert service.is_external_service_configured() is False

autogpt_platform/frontend/instrumentation-client.ts

@@ -22,6 +22,11 @@ Sentry.init({
 
   enabled: shouldEnable,
 
+  // Suppress cross-origin stylesheet errors from Sentry Replay (rrweb)
+  // serializing DOM snapshots with cross-origin stylesheets
+  // (e.g., from browser extensions or CDN-loaded CSS)
+  ignoreErrors: [/Not allowed to access cross-origin stylesheet/],
+
   // Add optional integrations for additional features
   integrations: [
     Sentry.captureConsoleIntegration(),

autogpt_platform/frontend/src/app/(platform)/build/components/BuilderActions/components/RunGraph/useRunGraph.ts

@@ -4,7 +4,7 @@ import {
 } from "@/app/api/__generated__/endpoints/graphs/graphs";
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { parseAsInteger, parseAsString, useQueryStates } from "nuqs";
-import { GraphExecutionMeta } from "@/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/use-agent-runs";
+import { GraphExecutionMeta } from "@/app/api/__generated__/models/graphExecutionMeta";
 import { useGraphStore } from "@/app/(platform)/build/stores/graphStore";
 import { useShallow } from "zustand/react/shallow";
 import { useEffect, useState } from "react";

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

@@ -1,6 +1,6 @@
 import { useCallback } from "react";
 
-import { AgentRunDraftView } from "@/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-run-draft-view";
+import { AgentRunDraftView } from "@/app/(platform)/build/components/legacy-builder/agent-run-draft-view";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import type {
   CredentialsMetaInput,

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

@@ -18,7 +18,7 @@ import {
 import { useToast } from "@/components/molecules/Toast/use-toast";
 import { useQueryClient } from "@tanstack/react-query";
 import { getGetV2ListMySubmissionsQueryKey } from "@/app/api/__generated__/endpoints/store/store";
-import { CronExpressionDialog } from "@/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/cron-scheduler-dialog";
+import { CronExpressionDialog } from "@/components/contextual/CronScheduler/cron-scheduler-dialog";
 import { humanizeCronExpression } from "@/lib/cron-expression-utils";
 import { CalendarClockIcon } from "lucide-react";
 

autogpt_platform/frontend/src/app/(platform)/build/components/legacy-builder/agent-run-draft-view.tsx

@@ -20,7 +20,7 @@ import {
 import { useBackendAPI } from "@/lib/autogpt-server-api/context";
 
 import { RunAgentInputs } from "@/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentInputs/RunAgentInputs";
-import { ScheduleTaskDialog } from "@/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/cron-scheduler-dialog";
+import { ScheduleTaskDialog } from "@/components/contextual/CronScheduler/cron-scheduler-dialog";
 import ActionButtonGroup from "@/components/__legacy__/action-button-group";
 import type { ButtonAction } from "@/components/__legacy__/types";
 import {
@@ -53,7 +53,10 @@ import { ClockIcon, CopyIcon, InfoIcon } from "@phosphor-icons/react";
 import { CalendarClockIcon, Trash2Icon } from "lucide-react";
 
 import { analytics } from "@/services/analytics";
-import { AgentStatus, AgentStatusChip } from "./agent-status-chip";
+import {
+  AgentStatus,
+  AgentStatusChip,
+} from "@/app/(platform)/build/components/legacy-builder/agent-status-chip";
 
 export function AgentRunDraftView({
   graph,

autogpt_platform/frontend/src/app/(platform)/copilot/hooks/Untitled

@@ -1,10 +0,0 @@
-import { parseAsString, useQueryState } from "nuqs";
-
-export function useCopilotSessionId() {
-  const [urlSessionId, setUrlSessionId] = useQueryState(
-    "sessionId",
-    parseAsString,
-  );
-
-  return { urlSessionId, setUrlSessionId };
-}

autogpt_platform/frontend/src/app/(platform)/copilot/hooks/useLongRunningToolPolling.ts

@@ -0,0 +1,126 @@
+import { getGetV2GetSessionQueryKey } from "@/app/api/__generated__/endpoints/chat/chat";
+import { useQueryClient } from "@tanstack/react-query";
+import type { UIDataTypes, UIMessage, UITools } from "ai";
+import { useCallback, useEffect, useRef } from "react";
+import { convertChatSessionMessagesToUiMessages } from "../helpers/convertChatSessionToUiMessages";
+
+const OPERATING_TYPES = new Set([
+  "operation_started",
+  "operation_pending",
+  "operation_in_progress",
+]);
+
+const POLL_INTERVAL_MS = 1_500;
+
+/**
+ * Detects whether any message contains a tool part whose output indicates
+ * a long-running operation is still in progress.
+ */
+function hasOperatingTool(
+  messages: UIMessage<unknown, UIDataTypes, UITools>[],
+) {
+  for (const msg of messages) {
+    for (const part of msg.parts) {
+      if (!part.type.startsWith("tool-")) continue;
+      const toolPart = part as { output?: unknown };
+      if (!toolPart.output) continue;
+      const output =
+        typeof toolPart.output === "string"
+          ? safeParse(toolPart.output)
+          : toolPart.output;
+      if (
+        output &&
+        typeof output === "object" &&
+        "type" in output &&
+        OPERATING_TYPES.has((output as { type: string }).type)
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function safeParse(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Polls the session endpoint while any tool is in an "operating" state
+ * (operation_started / operation_pending / operation_in_progress).
+ *
+ * When the session data shows the tool output has changed (e.g. to
+ * agent_saved), it calls `setMessages` with the updated messages.
+ */
+export function useLongRunningToolPolling(
+  sessionId: string | null,
+  messages: UIMessage<unknown, UIDataTypes, UITools>[],
+  setMessages: (
+    updater: (
+      prev: UIMessage<unknown, UIDataTypes, UITools>[],
+    ) => UIMessage<unknown, UIDataTypes, UITools>[],
+  ) => void,
+) {
+  const queryClient = useQueryClient();
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const stopPolling = useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, []);
+
+  const poll = useCallback(async () => {
+    if (!sessionId) return;
+
+    // Invalidate the query cache so the next fetch gets fresh data
+    await queryClient.invalidateQueries({
+      queryKey: getGetV2GetSessionQueryKey(sessionId),
+    });
+
+    // Fetch fresh session data
+    const data = queryClient.getQueryData<{
+      status: number;
+      data: { messages?: unknown[] };
+    }>(getGetV2GetSessionQueryKey(sessionId));
+
+    if (data?.status !== 200 || !data.data.messages) return;
+
+    const freshMessages = convertChatSessionMessagesToUiMessages(
+      sessionId,
+      data.data.messages,
+    );
+
+    if (!freshMessages || freshMessages.length === 0) return;
+
+    // Update when the long-running tool completed
+    if (!hasOperatingTool(freshMessages)) {
+      setMessages(() => freshMessages);
+      stopPolling();
+    }
+  }, [sessionId, queryClient, setMessages, stopPolling]);
+
+  useEffect(() => {
+    const shouldPoll = hasOperatingTool(messages);
+
+    // Always clear any previous interval first so we never leak timers
+    // when the effect re-runs due to dependency changes (e.g. messages
+    // updating as the LLM streams text after the tool call).
+    stopPolling();
+
+    if (shouldPoll && sessionId) {
+      intervalRef.current = setInterval(() => {
+        poll();
+      }, POLL_INTERVAL_MS);
+    }
+
+    return () => {
+      stopPolling();
+    };
+  }, [messages, sessionId, poll, stopPolling]);
+}

autogpt_platform/frontend/src/app/(platform)/copilot/tools/CreateAgent/CreateAgent.tsx

@@ -1,24 +1,30 @@
 "use client";
 
-import { WarningDiamondIcon } from "@phosphor-icons/react";
+import { Button } from "@/components/atoms/Button/Button";
+import { Text } from "@/components/atoms/Text/Text";
+import {
+  BookOpenIcon,
+  CheckFatIcon,
+  PencilSimpleIcon,
+  WarningDiamondIcon,
+} from "@phosphor-icons/react";
 import type { ToolUIPart } from "ai";
+import NextLink from "next/link";
 import { useCopilotChatActions } from "../../components/CopilotChatActionsProvider/useCopilotChatActions";
 import { MorphingTextAnimation } from "../../components/MorphingTextAnimation/MorphingTextAnimation";
-import { ProgressBar } from "../../components/ProgressBar/ProgressBar";
 import {
   ContentCardDescription,
   ContentCodeBlock,
   ContentGrid,
   ContentHint,
-  ContentLink,
   ContentMessage,
 } from "../../components/ToolAccordion/AccordionContent";
 import { ToolAccordion } from "../../components/ToolAccordion/ToolAccordion";
-import { useAsymptoticProgress } from "../../hooks/useAsymptoticProgress";
 import {
   ClarificationQuestionsCard,
   ClarifyingQuestion,
 } from "./components/ClarificationQuestionsCard";
+import { MiniGame } from "./components/MiniGame/MiniGame";
 import {
   AccordionIcon,
   formatMaybeJson,
@@ -52,7 +58,7 @@ function getAccordionMeta(output: CreateAgentToolOutput) {
   const icon = <AccordionIcon />;
 
   if (isAgentSavedOutput(output)) {
-    return { icon, title: output.agent_name };
+    return { icon, title: output.agent_name, expanded: true };
   }
   if (isAgentPreviewOutput(output)) {
     return {
@@ -78,6 +84,7 @@ function getAccordionMeta(output: CreateAgentToolOutput) {
     return {
       icon,
       title: "Creating agent, this may take a few minutes. Sit back and relax.",
+      expanded: true,
     };
   }
   return {
@@ -107,8 +114,6 @@ export function CreateAgentTool({ part }: Props) {
       isOperationPendingOutput(output) ||
       isOperationInProgressOutput(output));
 
-  const progress = useAsymptoticProgress(isOperating);
-
   const hasExpandableContent =
     part.state === "output-available" &&
     !!output &&
@@ -152,31 +157,53 @@ export function CreateAgentTool({ part }: Props) {
         <ToolAccordion {...getAccordionMeta(output)}>
           {isOperating && (
             <ContentGrid>
-              <ProgressBar value={progress} className="max-w-[280px]" />
+              <MiniGame />
               <ContentHint>
-                This could take a few minutes, grab a coffee ☕
+                This could take a few minutes — play while you wait!
               </ContentHint>
             </ContentGrid>
           )}
 
           {isAgentSavedOutput(output) && (
-            <ContentGrid>
-              <ContentMessage>{output.message}</ContentMessage>
-              <div className="flex flex-wrap gap-2">
-                <ContentLink href={output.library_agent_link}>
-                  Open in library
-                </ContentLink>
-                <ContentLink href={output.agent_page_link}>
-                  Open in builder
-                </ContentLink>
+            <div className="rounded-xl border border-border/60 bg-card p-4 shadow-sm">
+              <div className="flex items-baseline gap-2">
+                <CheckFatIcon
+                  size={18}
+                  weight="regular"
+                  className="relative top-1 text-green-500"
+                />
+                <Text
+                  variant="body-medium"
+                  className="text-blacks mb-2 text-[16px]"
+                >
+                  {output.message}
+                </Text>
               </div>
-              <ContentCodeBlock>
-                {truncateText(
-                  formatMaybeJson({ agent_id: output.agent_id }),
-                  800,
-                )}
-              </ContentCodeBlock>
-            </ContentGrid>
+              <div className="mt-3 flex flex-wrap gap-4">
+                <Button variant="outline" size="small">
+                  <NextLink
+                    href={output.library_agent_link}
+                    className="inline-flex items-center gap-1.5"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                  >
+                    <BookOpenIcon size={14} weight="regular" />
+                    Open in library
+                  </NextLink>
+                </Button>
+                <Button variant="outline" size="small">
+                  <NextLink
+                    href={output.agent_page_link}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    className="inline-flex items-center gap-1.5"
+                  >
+                    <PencilSimpleIcon size={14} weight="regular" />
+                    Open in builder
+                  </NextLink>
+                </Button>
+              </div>
+            </div>
           )}
 
           {isAgentPreviewOutput(output) && (

autogpt_platform/frontend/src/app/(platform)/copilot/tools/CreateAgent/components/MiniGame/MiniGame.tsx

@@ -0,0 +1,21 @@
+"use client";
+
+import { useMiniGame } from "./useMiniGame";
+
+export function MiniGame() {
+  const { canvasRef } = useMiniGame();
+
+  return (
+    <div
+      className="w-full overflow-hidden rounded-md bg-background text-foreground"
+      style={{ border: "1px solid #d17fff" }}
+    >
+      <canvas
+        ref={canvasRef}
+        tabIndex={0}
+        className="block w-full outline-none"
+        style={{ imageRendering: "pixelated" }}
+      />
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/copilot/tools/CreateAgent/components/MiniGame/useMiniGame.ts

@@ -0,0 +1,579 @@
+import { useEffect, useRef } from "react";
+
+/* ------------------------------------------------------------------ */
+/*  Constants                                                         */
+/* ------------------------------------------------------------------ */
+
+const CANVAS_HEIGHT = 150;
+const GRAVITY = 0.55;
+const JUMP_FORCE = -9.5;
+const BASE_SPEED = 3;
+const SPEED_INCREMENT = 0.0008;
+const SPAWN_MIN = 70;
+const SPAWN_MAX = 130;
+const CHAR_SIZE = 18;
+const CHAR_X = 50;
+const GROUND_PAD = 20;
+const STORAGE_KEY = "copilot-minigame-highscore";
+
+// Colors
+const COLOR_BG = "#E8EAF6";
+const COLOR_CHAR = "#263238";
+const COLOR_BOSS = "#F50057";
+
+// Boss
+const BOSS_SIZE = 36;
+const BOSS_ENTER_SPEED = 2;
+const BOSS_LEAVE_SPEED = 3;
+const BOSS_SHOOT_COOLDOWN = 90;
+const BOSS_SHOTS_TO_EVADE = 5;
+const BOSS_INTERVAL = 20; // every N score
+const PROJ_SPEED = 4.5;
+const PROJ_SIZE = 12;
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                             */
+/* ------------------------------------------------------------------ */
+
+interface Obstacle {
+  x: number;
+  width: number;
+  height: number;
+  scored: boolean;
+}
+
+interface Projectile {
+  x: number;
+  y: number;
+  speed: number;
+  evaded: boolean;
+  type: "low" | "high";
+}
+
+interface BossState {
+  phase: "inactive" | "entering" | "fighting" | "leaving";
+  x: number;
+  targetX: number;
+  shotsEvaded: number;
+  cooldown: number;
+  projectiles: Projectile[];
+  bob: number;
+}
+
+interface GameState {
+  charY: number;
+  vy: number;
+  obstacles: Obstacle[];
+  score: number;
+  highScore: number;
+  speed: number;
+  frame: number;
+  nextSpawn: number;
+  running: boolean;
+  over: boolean;
+  groundY: number;
+  boss: BossState;
+  bossThreshold: number;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                           */
+/* ------------------------------------------------------------------ */
+
+function randInt(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function readHighScore(): number {
+  try {
+    return parseInt(localStorage.getItem(STORAGE_KEY) || "0", 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function writeHighScore(score: number) {
+  try {
+    localStorage.setItem(STORAGE_KEY, String(score));
+  } catch {
+    /* noop */
+  }
+}
+
+function makeBoss(): BossState {
+  return {
+    phase: "inactive",
+    x: 0,
+    targetX: 0,
+    shotsEvaded: 0,
+    cooldown: 0,
+    projectiles: [],
+    bob: 0,
+  };
+}
+
+function makeState(groundY: number): GameState {
+  return {
+    charY: groundY - CHAR_SIZE,
+    vy: 0,
+    obstacles: [],
+    score: 0,
+    highScore: readHighScore(),
+    speed: BASE_SPEED,
+    frame: 0,
+    nextSpawn: randInt(SPAWN_MIN, SPAWN_MAX),
+    running: false,
+    over: false,
+    groundY,
+    boss: makeBoss(),
+    bossThreshold: BOSS_INTERVAL,
+  };
+}
+
+function gameOver(s: GameState) {
+  s.running = false;
+  s.over = true;
+  if (s.score > s.highScore) {
+    s.highScore = s.score;
+    writeHighScore(s.score);
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Projectile collision — shared between fighting & leaving phases   */
+/* ------------------------------------------------------------------ */
+
+/** Returns true if the player died. */
+function tickProjectiles(s: GameState): boolean {
+  const boss = s.boss;
+
+  for (const p of boss.projectiles) {
+    p.x -= p.speed;
+
+    if (!p.evaded && p.x + PROJ_SIZE < CHAR_X) {
+      p.evaded = true;
+      boss.shotsEvaded++;
+    }
+
+    // Collision
+    if (
+      !p.evaded &&
+      CHAR_X + CHAR_SIZE > p.x &&
+      CHAR_X < p.x + PROJ_SIZE &&
+      s.charY + CHAR_SIZE > p.y &&
+      s.charY < p.y + PROJ_SIZE
+    ) {
+      gameOver(s);
+      return true;
+    }
+  }
+
+  boss.projectiles = boss.projectiles.filter((p) => p.x + PROJ_SIZE > -20);
+  return false;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Update                                                            */
+/* ------------------------------------------------------------------ */
+
+function update(s: GameState, canvasWidth: number) {
+  if (!s.running) return;
+
+  s.frame++;
+
+  // Speed only ramps during regular play
+  if (s.boss.phase === "inactive") {
+    s.speed = BASE_SPEED + s.frame * SPEED_INCREMENT;
+  }
+
+  // ---- Character physics (always active) ---- //
+  s.vy += GRAVITY;
+  s.charY += s.vy;
+  if (s.charY + CHAR_SIZE >= s.groundY) {
+    s.charY = s.groundY - CHAR_SIZE;
+    s.vy = 0;
+  }
+
+  // ---- Trigger boss ---- //
+  if (s.boss.phase === "inactive" && s.score >= s.bossThreshold) {
+    s.boss.phase = "entering";
+    s.boss.x = canvasWidth + 10;
+    s.boss.targetX = canvasWidth - BOSS_SIZE - 40;
+    s.boss.shotsEvaded = 0;
+    s.boss.cooldown = BOSS_SHOOT_COOLDOWN;
+    s.boss.projectiles = [];
+    s.obstacles = [];
+  }
+
+  // ---- Boss: entering ---- //
+  if (s.boss.phase === "entering") {
+    s.boss.bob = Math.sin(s.frame * 0.05) * 3;
+    s.boss.x -= BOSS_ENTER_SPEED;
+    if (s.boss.x <= s.boss.targetX) {
+      s.boss.x = s.boss.targetX;
+      s.boss.phase = "fighting";
+    }
+    return; // no obstacles while entering
+  }
+
+  // ---- Boss: fighting ---- //
+  if (s.boss.phase === "fighting") {
+    s.boss.bob = Math.sin(s.frame * 0.05) * 3;
+
+    // Shoot
+    s.boss.cooldown--;
+    if (s.boss.cooldown <= 0) {
+      const isLow = Math.random() < 0.5;
+      s.boss.projectiles.push({
+        x: s.boss.x - PROJ_SIZE,
+        y: isLow ? s.groundY - 14 : s.groundY - 70,
+        speed: PROJ_SPEED,
+        evaded: false,
+        type: isLow ? "low" : "high",
+      });
+      s.boss.cooldown = BOSS_SHOOT_COOLDOWN;
+    }
+
+    if (tickProjectiles(s)) return;
+
+    // Boss defeated?
+    if (s.boss.shotsEvaded >= BOSS_SHOTS_TO_EVADE) {
+      s.boss.phase = "leaving";
+      s.score += 5; // bonus
+      s.bossThreshold = s.score + BOSS_INTERVAL;
+    }
+    return;
+  }
+
+  // ---- Boss: leaving ---- //
+  if (s.boss.phase === "leaving") {
+    s.boss.bob = Math.sin(s.frame * 0.05) * 3;
+    s.boss.x += BOSS_LEAVE_SPEED;
+
+    // Still check in-flight projectiles
+    if (tickProjectiles(s)) return;
+
+    if (s.boss.x > canvasWidth + 50) {
+      s.boss = makeBoss();
+      s.nextSpawn = s.frame + randInt(SPAWN_MIN / 2, SPAWN_MAX / 2);
+    }
+    return;
+  }
+
+  // ---- Regular obstacle play ---- //
+  if (s.frame >= s.nextSpawn) {
+    s.obstacles.push({
+      x: canvasWidth + 10,
+      width: randInt(10, 16),
+      height: randInt(20, 48),
+      scored: false,
+    });
+    s.nextSpawn = s.frame + randInt(SPAWN_MIN, SPAWN_MAX);
+  }
+
+  for (const o of s.obstacles) {
+    o.x -= s.speed;
+    if (!o.scored && o.x + o.width < CHAR_X) {
+      o.scored = true;
+      s.score++;
+    }
+  }
+
+  s.obstacles = s.obstacles.filter((o) => o.x + o.width > -20);
+
+  for (const o of s.obstacles) {
+    const oY = s.groundY - o.height;
+    if (
+      CHAR_X + CHAR_SIZE > o.x &&
+      CHAR_X < o.x + o.width &&
+      s.charY + CHAR_SIZE > oY
+    ) {
+      gameOver(s);
+      return;
+    }
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Drawing                                                           */
+/* ------------------------------------------------------------------ */
+
+function drawBoss(ctx: CanvasRenderingContext2D, s: GameState, bg: string) {
+  const bx = s.boss.x;
+  const by = s.groundY - BOSS_SIZE + s.boss.bob;
+
+  // Body
+  ctx.save();
+  ctx.fillStyle = COLOR_BOSS;
+  ctx.globalAlpha = 0.9;
+  ctx.beginPath();
+  ctx.roundRect(bx, by, BOSS_SIZE, BOSS_SIZE, 4);
+  ctx.fill();
+  ctx.restore();
+
+  // Eyes
+  ctx.save();
+  ctx.fillStyle = bg;
+  const eyeY = by + 13;
+  ctx.beginPath();
+  ctx.arc(bx + 10, eyeY, 4, 0, Math.PI * 2);
+  ctx.fill();
+  ctx.beginPath();
+  ctx.arc(bx + 26, eyeY, 4, 0, Math.PI * 2);
+  ctx.fill();
+  ctx.restore();
+
+  // Angry eyebrows
+  ctx.save();
+  ctx.strokeStyle = bg;
+  ctx.lineWidth = 2;
+  ctx.beginPath();
+  ctx.moveTo(bx + 5, eyeY - 7);
+  ctx.lineTo(bx + 14, eyeY - 4);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(bx + 31, eyeY - 7);
+  ctx.lineTo(bx + 22, eyeY - 4);
+  ctx.stroke();
+  ctx.restore();
+
+  // Zigzag mouth
+  ctx.save();
+  ctx.strokeStyle = bg;
+  ctx.lineWidth = 1.5;
+  ctx.beginPath();
+  ctx.moveTo(bx + 10, by + 27);
+  ctx.lineTo(bx + 14, by + 24);
+  ctx.lineTo(bx + 18, by + 27);
+  ctx.lineTo(bx + 22, by + 24);
+  ctx.lineTo(bx + 26, by + 27);
+  ctx.stroke();
+  ctx.restore();
+}
+
+function drawProjectiles(ctx: CanvasRenderingContext2D, boss: BossState) {
+  ctx.save();
+  ctx.fillStyle = COLOR_BOSS;
+  ctx.globalAlpha = 0.8;
+  for (const p of boss.projectiles) {
+    if (p.evaded) continue;
+    ctx.beginPath();
+    ctx.arc(
+      p.x + PROJ_SIZE / 2,
+      p.y + PROJ_SIZE / 2,
+      PROJ_SIZE / 2,
+      0,
+      Math.PI * 2,
+    );
+    ctx.fill();
+  }
+  ctx.restore();
+}
+
+function draw(
+  ctx: CanvasRenderingContext2D,
+  s: GameState,
+  w: number,
+  h: number,
+  fg: string,
+  started: boolean,
+) {
+  ctx.fillStyle = COLOR_BG;
+  ctx.fillRect(0, 0, w, h);
+
+  // Ground
+  ctx.save();
+  ctx.strokeStyle = fg;
+  ctx.globalAlpha = 0.15;
+  ctx.setLineDash([4, 4]);
+  ctx.beginPath();
+  ctx.moveTo(0, s.groundY);
+  ctx.lineTo(w, s.groundY);
+  ctx.stroke();
+  ctx.restore();
+
+  // Character
+  ctx.save();
+  ctx.fillStyle = COLOR_CHAR;
+  ctx.globalAlpha = 0.85;
+  ctx.beginPath();
+  ctx.roundRect(CHAR_X, s.charY, CHAR_SIZE, CHAR_SIZE, 3);
+  ctx.fill();
+  ctx.restore();
+
+  // Eyes
+  ctx.save();
+  ctx.fillStyle = COLOR_BG;
+  ctx.beginPath();
+  ctx.arc(CHAR_X + 6, s.charY + 7, 2.5, 0, Math.PI * 2);
+  ctx.fill();
+  ctx.beginPath();
+  ctx.arc(CHAR_X + 12, s.charY + 7, 2.5, 0, Math.PI * 2);
+  ctx.fill();
+  ctx.restore();
+
+  // Obstacles
+  ctx.save();
+  ctx.fillStyle = fg;
+  ctx.globalAlpha = 0.55;
+  for (const o of s.obstacles) {
+    ctx.fillRect(o.x, s.groundY - o.height, o.width, o.height);
+  }
+  ctx.restore();
+
+  // Boss + projectiles
+  if (s.boss.phase !== "inactive") {
+    drawBoss(ctx, s, COLOR_BG);
+    drawProjectiles(ctx, s.boss);
+  }
+
+  // Score HUD
+  ctx.save();
+  ctx.fillStyle = fg;
+  ctx.globalAlpha = 0.5;
+  ctx.font = "bold 11px monospace";
+  ctx.textAlign = "right";
+  ctx.fillText(`Score: ${s.score}`, w - 12, 20);
+  ctx.fillText(`Best: ${s.highScore}`, w - 12, 34);
+  if (s.boss.phase === "fighting") {
+    ctx.fillText(
+      `Evade: ${s.boss.shotsEvaded}/${BOSS_SHOTS_TO_EVADE}`,
+      w - 12,
+      48,
+    );
+  }
+  ctx.restore();
+
+  // Prompts
+  if (!started && !s.running && !s.over) {
+    ctx.save();
+    ctx.fillStyle = fg;
+    ctx.globalAlpha = 0.5;
+    ctx.font = "12px sans-serif";
+    ctx.textAlign = "center";
+    ctx.fillText("Click or press Space to play while you wait", w / 2, h / 2);
+    ctx.restore();
+  }
+
+  if (s.over) {
+    ctx.save();
+    ctx.fillStyle = fg;
+    ctx.globalAlpha = 0.7;
+    ctx.font = "bold 13px sans-serif";
+    ctx.textAlign = "center";
+    ctx.fillText("Game Over", w / 2, h / 2 - 8);
+    ctx.font = "11px sans-serif";
+    ctx.fillText("Click or Space to restart", w / 2, h / 2 + 10);
+    ctx.restore();
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Hook                                                              */
+/* ------------------------------------------------------------------ */
+
+export function useMiniGame() {
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const stateRef = useRef<GameState | null>(null);
+  const rafRef = useRef(0);
+  const startedRef = useRef(false);
+
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+
+    const container = canvas.parentElement;
+    if (container) {
+      canvas.width = container.clientWidth;
+      canvas.height = CANVAS_HEIGHT;
+    }
+
+    const groundY = canvas.height - GROUND_PAD;
+    stateRef.current = makeState(groundY);
+
+    const style = getComputedStyle(canvas);
+    let fg = style.color || "#71717a";
+
+    // -------------------------------------------------------------- //
+    //  Jump                                                           //
+    // -------------------------------------------------------------- //
+    function jump() {
+      const s = stateRef.current;
+      if (!s) return;
+
+      if (s.over) {
+        const hs = s.highScore;
+        const gy = s.groundY;
+        stateRef.current = makeState(gy);
+        stateRef.current.highScore = hs;
+        stateRef.current.running = true;
+        startedRef.current = true;
+        return;
+      }
+
+      if (!s.running) {
+        s.running = true;
+        startedRef.current = true;
+        return;
+      }
+
+      // Only jump when on the ground
+      if (s.charY + CHAR_SIZE >= s.groundY) {
+        s.vy = JUMP_FORCE;
+      }
+    }
+
+    function onKey(e: KeyboardEvent) {
+      if (e.code === "Space" || e.key === " ") {
+        e.preventDefault();
+        jump();
+      }
+    }
+
+    function onClick() {
+      canvas?.focus();
+      jump();
+    }
+
+    // -------------------------------------------------------------- //
+    //  Loop                                                           //
+    // -------------------------------------------------------------- //
+    function loop() {
+      const s = stateRef.current;
+      if (!canvas || !s) return;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+
+      update(s, canvas.width);
+      draw(ctx, s, canvas.width, canvas.height, fg, startedRef.current);
+      rafRef.current = requestAnimationFrame(loop);
+    }
+
+    rafRef.current = requestAnimationFrame(loop);
+
+    canvas.addEventListener("click", onClick);
+    canvas.addEventListener("keydown", onKey);
+
+    const observer = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        canvas.width = entry.contentRect.width;
+        canvas.height = CANVAS_HEIGHT;
+        if (stateRef.current) {
+          stateRef.current.groundY = canvas.height - GROUND_PAD;
+        }
+        const cs = getComputedStyle(canvas);
+        fg = cs.color || fg;
+      }
+    });
+    if (container) observer.observe(container);
+
+    return () => {
+      cancelAnimationFrame(rafRef.current);
+      canvas.removeEventListener("click", onClick);
+      canvas.removeEventListener("keydown", onKey);
+      observer.disconnect();
+    };
+  }, []);
+
+  return { canvasRef };
+}

autogpt_platform/frontend/src/app/(platform)/copilot/useCopilotPage.ts

@@ -1,10 +1,14 @@
 import { useGetV2ListSessions } from "@/app/api/__generated__/endpoints/chat/chat";
+import { toast } from "@/components/molecules/Toast/use-toast";
 import { useBreakpoint } from "@/lib/hooks/useBreakpoint";
 import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
 import { useChat } from "@ai-sdk/react";
 import { DefaultChatTransport } from "ai";
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { useChatSession } from "./useChatSession";
+import { useLongRunningToolPolling } from "./hooks/useLongRunningToolPolling";
+
+const STREAM_START_TIMEOUT_MS = 12_000;
 
 export function useCopilotPage() {
   const { isUserLoading, isLoggedIn } = useSupabase();
@@ -52,6 +56,24 @@ export function useCopilotPage() {
     transport: transport ?? undefined,
   });
 
+  // Abort the stream if the backend doesn't start sending data within 12s.
+  const stopRef = useRef(stop);
+  stopRef.current = stop;
+  useEffect(() => {
+    if (status !== "submitted") return;
+
+    const timer = setTimeout(() => {
+      stopRef.current();
+      toast({
+        title: "Stream timed out",
+        description: "The server took too long to respond. Please try again.",
+        variant: "destructive",
+      });
+    }, STREAM_START_TIMEOUT_MS);
+
+    return () => clearTimeout(timer);
+  }, [status]);
+
   useEffect(() => {
     if (!hydratedMessages || hydratedMessages.length === 0) return;
     setMessages((prev) => {
@@ -60,6 +82,11 @@ export function useCopilotPage() {
     });
   }, [hydratedMessages, setMessages]);
 
+  // Poll session endpoint when a long-running tool (create_agent, edit_agent)
+  // is in progress. When the backend completes, the session data will contain
+  // the final tool output — this hook detects the change and updates messages.
+  useLongRunningToolPolling(sessionId, messages, setMessages);
+
   // Clear messages when session is null
   useEffect(() => {
     if (!sessionId) setMessages([]);

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

@@ -29,6 +29,7 @@ export function ScheduleListItem({
       description={formatDistanceToNow(schedule.next_run_time, {
         addSuffix: true,
       })}
+      descriptionTitle={new Date(schedule.next_run_time).toString()}
       onClick={onClick}
       selected={selected}
       icon={

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

@@ -7,6 +7,7 @@ import React from "react";
 interface Props {
   title: string;
   description?: string;
+  descriptionTitle?: string;
   icon?: React.ReactNode;
   selected?: boolean;
   onClick?: () => void;
@@ -16,6 +17,7 @@ interface Props {
 export function SidebarItemCard({
   title,
   description,
+  descriptionTitle,
   icon,
   selected,
   onClick,
@@ -38,7 +40,11 @@ export function SidebarItemCard({
           >
             {title}
           </Text>
-          <Text variant="body" className="leading-tight !text-zinc-500">
+          <Text
+            variant="body"
+            className="leading-tight !text-zinc-500"
+            title={descriptionTitle}
+          >
             {description}
           </Text>
         </div>

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

@@ -81,6 +81,9 @@ export function TaskListItem({
           ? formatDistanceToNow(run.started_at, { addSuffix: true })
           : "—"
       }
+      descriptionTitle={
+        run.started_at ? new Date(run.started_at).toString() : undefined
+      }
       onClick={onClick}
       selected={selected}
       actions={

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

@@ -1,631 +0,0 @@
-"use client";
-import { useParams, useRouter } from "next/navigation";
-import { useQueryState } from "nuqs";
-import React, {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
-
-import {
-  Graph,
-  GraphExecution,
-  GraphExecutionID,
-  GraphExecutionMeta,
-  GraphID,
-  LibraryAgent,
-  LibraryAgentID,
-  LibraryAgentPreset,
-  LibraryAgentPresetID,
-  Schedule,
-  ScheduleID,
-} from "@/lib/autogpt-server-api";
-import { useBackendAPI } from "@/lib/autogpt-server-api/context";
-import { exportAsJSONFile } from "@/lib/utils";
-
-import DeleteConfirmDialog from "@/components/__legacy__/delete-confirm-dialog";
-import type { ButtonAction } from "@/components/__legacy__/types";
-import { Button } from "@/components/__legacy__/ui/button";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/__legacy__/ui/dialog";
-import LoadingBox, { LoadingSpinner } from "@/components/__legacy__/ui/loading";
-import {
-  useToast,
-  useToastOnFail,
-} from "@/components/molecules/Toast/use-toast";
-import { AgentRunDetailsView } from "./components/agent-run-details-view";
-import { AgentRunDraftView } from "./components/agent-run-draft-view";
-import { CreatePresetDialog } from "./components/create-preset-dialog";
-import { useAgentRunsInfinite } from "./use-agent-runs";
-import { AgentRunsSelectorList } from "./components/agent-runs-selector-list";
-import { AgentScheduleDetailsView } from "./components/agent-schedule-details-view";
-
-export function OldAgentLibraryView() {
-  const { id: agentID }: { id: LibraryAgentID } = useParams();
-  const [executionId, setExecutionId] = useQueryState("executionId");
-  const toastOnFail = useToastOnFail();
-  const { toast } = useToast();
-  const router = useRouter();
-  const api = useBackendAPI();
-
-  // ============================ STATE =============================
-
-  const [graph, setGraph] = useState<Graph | null>(null); // Graph version corresponding to LibraryAgent
-  const [agent, setAgent] = useState<LibraryAgent | null>(null);
-  const agentRunsQuery = useAgentRunsInfinite(graph?.id); // only runs once graph.id is known
-  const agentRuns = agentRunsQuery.agentRuns;
-  const [agentPresets, setAgentPresets] = useState<LibraryAgentPreset[]>([]);
-  const [schedules, setSchedules] = useState<Schedule[]>([]);
-  const [selectedView, selectView] = useState<
-    | { type: "run"; id?: GraphExecutionID }
-    | { type: "preset"; id: LibraryAgentPresetID }
-    | { type: "schedule"; id: ScheduleID }
-  >({ type: "run" });
-  const [selectedRun, setSelectedRun] = useState<
-    GraphExecution | GraphExecutionMeta | null
-  >(null);
-  const selectedSchedule =
-    selectedView.type == "schedule"
-      ? schedules.find((s) => s.id == selectedView.id)
-      : null;
-  const [isFirstLoad, setIsFirstLoad] = useState<boolean>(true);
-  const [agentDeleteDialogOpen, setAgentDeleteDialogOpen] =
-    useState<boolean>(false);
-  const [confirmingDeleteAgentRun, setConfirmingDeleteAgentRun] =
-    useState<GraphExecutionMeta | null>(null);
-  const [confirmingDeleteAgentPreset, setConfirmingDeleteAgentPreset] =
-    useState<LibraryAgentPresetID | null>(null);
-  const [copyAgentDialogOpen, setCopyAgentDialogOpen] = useState(false);
-  const [creatingPresetFromExecutionID, setCreatingPresetFromExecutionID] =
-    useState<GraphExecutionID | null>(null);
-
-  // Set page title with agent name
-  useEffect(() => {
-    if (agent) {
-      document.title = `${agent.name} - Library - AutoGPT Platform`;
-    }
-  }, [agent]);
-
-  const openRunDraftView = useCallback(() => {
-    selectView({ type: "run" });
-  }, []);
-
-  const selectRun = useCallback((id: GraphExecutionID) => {
-    selectView({ type: "run", id });
-  }, []);
-
-  const selectPreset = useCallback((id: LibraryAgentPresetID) => {
-    selectView({ type: "preset", id });
-  }, []);
-
-  const selectSchedule = useCallback((id: ScheduleID) => {
-    selectView({ type: "schedule", id });
-  }, []);
-
-  const graphVersions = useRef<Record<number, Graph>>({});
-  const loadingGraphVersions = useRef<Record<number, Promise<Graph>>>({});
-  const getGraphVersion = useCallback(
-    async (graphID: GraphID, version: number) => {
-      if (version in graphVersions.current)
-        return graphVersions.current[version];
-      if (version in loadingGraphVersions.current)
-        return loadingGraphVersions.current[version];
-
-      const pendingGraph = api.getGraph(graphID, version).then((graph) => {
-        graphVersions.current[version] = graph;
-        return graph;
-      });
-      // Cache promise as well to avoid duplicate requests
-      loadingGraphVersions.current[version] = pendingGraph;
-      return pendingGraph;
-    },
-    [api, graphVersions, loadingGraphVersions],
-  );
-
-  const lastRefresh = useRef<number>(0);
-  const refreshPageData = useCallback(() => {
-    if (Date.now() - lastRefresh.current < 2e3) return; // 2 second debounce
-    lastRefresh.current = Date.now();
-
-    api.getLibraryAgent(agentID).then((agent) => {
-      setAgent(agent);
-
-      getGraphVersion(agent.graph_id, agent.graph_version).then(
-        (_graph) =>
-          (graph && graph.version == _graph.version) || setGraph(_graph),
-      );
-      Promise.all([
-        agentRunsQuery.refetchRuns(),
-        api.listLibraryAgentPresets({
-          graph_id: agent.graph_id,
-          page_size: 100,
-        }),
-      ]).then(([runsQueryResult, presets]) => {
-        setAgentPresets(presets.presets);
-
-        const newestAgentRunsResponse = runsQueryResult.data?.pages[0];
-        if (!newestAgentRunsResponse || newestAgentRunsResponse.status != 200)
-          return;
-        const newestAgentRuns = newestAgentRunsResponse.data.executions;
-        // Preload the corresponding graph versions for the latest 10 runs
-        new Set(
-          newestAgentRuns.slice(0, 10).map((run) => run.graph_version),
-        ).forEach((version) => getGraphVersion(agent.graph_id, version));
-      });
-    });
-  }, [api, agentID, getGraphVersion, graph]);
-
-  // On first load: select the latest run
-  useEffect(() => {
-    // Only for first load or first execution
-    if (selectedView.id || !isFirstLoad) return;
-    if (agentRuns.length == 0 && agentPresets.length == 0) return;
-
-    setIsFirstLoad(false);
-    if (agentRuns.length > 0) {
-      // select latest run
-      const latestRun = agentRuns.reduce((latest, current) => {
-        if (!latest.started_at && !current.started_at) return latest;
-        if (!latest.started_at) return current;
-        if (!current.started_at) return latest;
-        return latest.started_at > current.started_at ? latest : current;
-      }, agentRuns[0]);
-      selectRun(latestRun.id as GraphExecutionID);
-    } else {
-      // select top preset
-      const latestPreset = agentPresets.toSorted(
-        (a, b) => b.updated_at.getTime() - a.updated_at.getTime(),
-      )[0];
-      selectPreset(latestPreset.id);
-    }
-  }, [
-    isFirstLoad,
-    selectedView.id,
-    agentRuns,
-    agentPresets,
-    selectRun,
-    selectPreset,
-  ]);
-
-  useEffect(() => {
-    if (executionId) {
-      selectRun(executionId as GraphExecutionID);
-      setExecutionId(null);
-    }
-  }, [executionId, selectRun, setExecutionId]);
-
-  // Initial load
-  useEffect(() => {
-    refreshPageData();
-
-    // Show a toast when the WebSocket connection disconnects
-    let connectionToast: ReturnType<typeof toast> | null = null;
-    const cancelDisconnectHandler = api.onWebSocketDisconnect(() => {
-      connectionToast ??= toast({
-        title: "Connection to server was lost",
-        variant: "destructive",
-        description: (
-          <div className="flex items-center">
-            Trying to reconnect...
-            <LoadingSpinner className="ml-1.5 size-3.5" />
-          </div>
-        ),
-        duration: Infinity,
-        dismissable: true,
-      });
-    });
-    const cancelConnectHandler = api.onWebSocketConnect(() => {
-      if (connectionToast)
-        connectionToast.update({
-          id: connectionToast.id,
-          title: "✅ Connection re-established",
-          variant: "default",
-          description: (
-            <div className="flex items-center">
-              Refreshing data...
-              <LoadingSpinner className="ml-1.5 size-3.5" />
-            </div>
-          ),
-          duration: 2000,
-          dismissable: true,
-        });
-      connectionToast = null;
-    });
-    return () => {
-      cancelDisconnectHandler();
-      cancelConnectHandler();
-    };
-  }, []);
-
-  // Subscribe to WebSocket updates for agent runs
-  useEffect(() => {
-    if (!agent?.graph_id) return;
-
-    return api.onWebSocketConnect(() => {
-      refreshPageData(); // Sync up on (re)connect
-
-      // Subscribe to all executions for this agent
-      api.subscribeToGraphExecutions(agent.graph_id);
-    });
-  }, [api, agent?.graph_id, refreshPageData]);
-
-  // Handle execution updates
-  useEffect(() => {
-    const detachExecUpdateHandler = api.onWebSocketMessage(
-      "graph_execution_event",
-      (data) => {
-        if (data.graph_id != agent?.graph_id) return;
-
-        agentRunsQuery.upsertAgentRun(data);
-        if (data.id === selectedView.id) {
-          // Update currently viewed run
-          setSelectedRun(data);
-        }
-      },
-    );
-
-    return () => {
-      detachExecUpdateHandler();
-    };
-  }, [api, agent?.graph_id, selectedView.id]);
-
-  // Pre-load selectedRun based on selectedView
-  useEffect(() => {
-    if (selectedView.type != "run" || !selectedView.id) return;
-
-    const newSelectedRun = agentRuns.find((run) => run.id == selectedView.id);
-    if (selectedView.id !== selectedRun?.id) {
-      // Pull partial data from "cache" while waiting for the rest to load
-      setSelectedRun((newSelectedRun as GraphExecutionMeta) ?? null);
-    }
-  }, [api, selectedView, agentRuns, selectedRun?.id]);
-
-  // Load selectedRun based on selectedView; refresh on agent refresh
-  useEffect(() => {
-    if (selectedView.type != "run" || !selectedView.id || !agent) return;
-
-    api
-      .getGraphExecutionInfo(agent.graph_id, selectedView.id)
-      .then(async (run) => {
-        // Ensure corresponding graph version is available before rendering I/O
-        await getGraphVersion(run.graph_id, run.graph_version);
-        setSelectedRun(run);
-      });
-  }, [api, selectedView, agent, getGraphVersion]);
-
-  const fetchSchedules = useCallback(async () => {
-    if (!agent) return;
-
-    setSchedules(await api.listGraphExecutionSchedules(agent.graph_id));
-  }, [api, agent?.graph_id]);
-
-  useEffect(() => {
-    fetchSchedules();
-  }, [fetchSchedules]);
-
-  // =========================== ACTIONS ============================
-
-  const deleteRun = useCallback(
-    async (run: GraphExecutionMeta) => {
-      if (run.status == "RUNNING" || run.status == "QUEUED") {
-        await api.stopGraphExecution(run.graph_id, run.id);
-      }
-      await api.deleteGraphExecution(run.id);
-
-      setConfirmingDeleteAgentRun(null);
-      if (selectedView.type == "run" && selectedView.id == run.id) {
-        openRunDraftView();
-      }
-      agentRunsQuery.removeAgentRun(run.id);
-    },
-    [api, selectedView, openRunDraftView],
-  );
-
-  const deletePreset = useCallback(
-    async (presetID: LibraryAgentPresetID) => {
-      await api.deleteLibraryAgentPreset(presetID);
-
-      setConfirmingDeleteAgentPreset(null);
-      if (selectedView.type == "preset" && selectedView.id == presetID) {
-        openRunDraftView();
-      }
-      setAgentPresets((presets) => presets.filter((p) => p.id !== presetID));
-    },
-    [api, selectedView, openRunDraftView],
-  );
-
-  const deleteSchedule = useCallback(
-    async (scheduleID: ScheduleID) => {
-      const removedSchedule =
-        await api.deleteGraphExecutionSchedule(scheduleID);
-
-      setSchedules((schedules) => {
-        const newSchedules = schedules.filter(
-          (s) => s.id !== removedSchedule.id,
-        );
-        if (
-          selectedView.type == "schedule" &&
-          selectedView.id == removedSchedule.id
-        ) {
-          if (newSchedules.length > 0) {
-            // Select next schedule if available
-            selectSchedule(newSchedules[0].id);
-          } else {
-            // Reset to draft view if current schedule was deleted
-            openRunDraftView();
-          }
-        }
-        return newSchedules;
-      });
-      openRunDraftView();
-    },
-    [schedules, api],
-  );
-
-  const handleCreatePresetFromRun = useCallback(
-    async (name: string, description: string) => {
-      if (!creatingPresetFromExecutionID) return;
-
-      await api
-        .createLibraryAgentPreset({
-          name,
-          description,
-          graph_execution_id: creatingPresetFromExecutionID,
-        })
-        .then((preset) => {
-          setAgentPresets((prev) => [...prev, preset]);
-          selectPreset(preset.id);
-          setCreatingPresetFromExecutionID(null);
-        })
-        .catch(toastOnFail("create a preset"));
-    },
-    [api, creatingPresetFromExecutionID, selectPreset, toast],
-  );
-
-  const downloadGraph = useCallback(
-    async () =>
-      agent &&
-      // Export sanitized graph from backend
-      api
-        .getGraph(agent.graph_id, agent.graph_version, true)
-        .then((graph) =>
-          exportAsJSONFile(graph, `${graph.name}_v${graph.version}.json`),
-        ),
-    [api, agent],
-  );
-
-  const copyAgent = useCallback(async () => {
-    setCopyAgentDialogOpen(false);
-    api
-      .forkLibraryAgent(agentID)
-      .then((newAgent) => {
-        router.push(`/library/agents/${newAgent.id}`);
-      })
-      .catch((error) => {
-        console.error("Error copying agent:", error);
-        toast({
-          title: "Error copying agent",
-          description: `An error occurred while copying the agent: ${error.message}`,
-          variant: "destructive",
-        });
-      });
-  }, [agentID, api, router, toast]);
-
-  const agentActions: ButtonAction[] = useMemo(
-    () => [
-      {
-        label: "Customize agent",
-        href: `/build?flowID=${agent?.graph_id}&flowVersion=${agent?.graph_version}`,
-        disabled: !agent?.can_access_graph,
-      },
-      { label: "Export agent to file", callback: downloadGraph },
-      ...(!agent?.can_access_graph
-        ? [
-            {
-              label: "Edit a copy",
-              callback: () => setCopyAgentDialogOpen(true),
-            },
-          ]
-        : []),
-      {
-        label: "Delete agent",
-        callback: () => setAgentDeleteDialogOpen(true),
-      },
-    ],
-    [agent, downloadGraph],
-  );
-
-  const runGraph =
-    graphVersions.current[selectedRun?.graph_version ?? 0] ?? graph;
-
-  const onCreateSchedule = useCallback(
-    (schedule: Schedule) => {
-      setSchedules((prev) => [...prev, schedule]);
-      selectSchedule(schedule.id);
-    },
-    [selectView],
-  );
-
-  const onCreatePreset = useCallback(
-    (preset: LibraryAgentPreset) => {
-      setAgentPresets((prev) => [...prev, preset]);
-      selectPreset(preset.id);
-    },
-    [selectPreset],
-  );
-
-  const onUpdatePreset = useCallback(
-    (updated: LibraryAgentPreset) => {
-      setAgentPresets((prev) =>
-        prev.map((p) => (p.id === updated.id ? updated : p)),
-      );
-      selectPreset(updated.id);
-    },
-    [selectPreset],
-  );
-
-  if (!agent || !graph) {
-    return <LoadingBox className="h-[90vh]" />;
-  }
-
-  return (
-    <div className="container justify-stretch p-0 pt-16 lg:flex">
-      {/* Sidebar w/ list of runs */}
-      {/* TODO: render this below header in sm and md layouts */}
-      <AgentRunsSelectorList
-        className="agpt-div w-full border-b pb-2 lg:w-auto lg:border-b-0 lg:border-r lg:pb-0"
-        agent={agent}
-        agentRunsQuery={agentRunsQuery}
-        agentPresets={agentPresets}
-        schedules={schedules}
-        selectedView={selectedView}
-        onSelectRun={selectRun}
-        onSelectPreset={selectPreset}
-        onSelectSchedule={selectSchedule}
-        onSelectDraftNewRun={openRunDraftView}
-        doDeleteRun={setConfirmingDeleteAgentRun}
-        doDeletePreset={setConfirmingDeleteAgentPreset}
-        doDeleteSchedule={deleteSchedule}
-        doCreatePresetFromRun={setCreatingPresetFromExecutionID}
-      />
-
-      <div className="flex-1">
-        {/* Header */}
-        <div className="agpt-div w-full border-b">
-          <h1
-            data-testid="agent-title"
-            className="font-poppins text-3xl font-medium"
-          >
-            {
-              agent.name /* TODO: use dynamic/custom run title - https://github.com/Significant-Gravitas/AutoGPT/issues/9184 */
-            }
-          </h1>
-        </div>
-
-        {/* Run / Schedule views */}
-        {(selectedView.type == "run" && selectedView.id ? (
-          selectedRun && runGraph ? (
-            <AgentRunDetailsView
-              agent={agent}
-              graph={runGraph}
-              run={selectedRun}
-              agentActions={agentActions}
-              onRun={selectRun}
-              doDeleteRun={() => setConfirmingDeleteAgentRun(selectedRun)}
-              doCreatePresetFromRun={() =>
-                setCreatingPresetFromExecutionID(selectedRun.id)
-              }
-            />
-          ) : null
-        ) : selectedView.type == "run" ? (
-          /* Draft new runs / Create new presets */
-          <AgentRunDraftView
-            graph={graph}
-            onRun={selectRun}
-            onCreateSchedule={onCreateSchedule}
-            onCreatePreset={onCreatePreset}
-            agentActions={agentActions}
-            recommendedScheduleCron={agent?.recommended_schedule_cron || null}
-          />
-        ) : selectedView.type == "preset" ? (
-          /* Edit & update presets */
-          <AgentRunDraftView
-            graph={graph}
-            agentPreset={
-              agentPresets.find((preset) => preset.id == selectedView.id)!
-            }
-            onRun={selectRun}
-            recommendedScheduleCron={agent?.recommended_schedule_cron || null}
-            onCreateSchedule={onCreateSchedule}
-            onUpdatePreset={onUpdatePreset}
-            doDeletePreset={setConfirmingDeleteAgentPreset}
-            agentActions={agentActions}
-          />
-        ) : selectedView.type == "schedule" ? (
-          selectedSchedule &&
-          graph && (
-            <AgentScheduleDetailsView
-              graph={graph}
-              schedule={selectedSchedule}
-              // agent={agent}
-              agentActions={agentActions}
-              onForcedRun={selectRun}
-              doDeleteSchedule={deleteSchedule}
-            />
-          )
-        ) : null) || <LoadingBox className="h-[70vh]" />}
-
-        <DeleteConfirmDialog
-          entityType="agent"
-          open={agentDeleteDialogOpen}
-          onOpenChange={setAgentDeleteDialogOpen}
-          onDoDelete={() =>
-            agent &&
-            api.deleteLibraryAgent(agent.id).then(() => router.push("/library"))
-          }
-        />
-
-        <DeleteConfirmDialog
-          entityType="agent run"
-          open={!!confirmingDeleteAgentRun}
-          onOpenChange={(open) => !open && setConfirmingDeleteAgentRun(null)}
-          onDoDelete={() =>
-            confirmingDeleteAgentRun && deleteRun(confirmingDeleteAgentRun)
-          }
-        />
-        <DeleteConfirmDialog
-          entityType={agent.has_external_trigger ? "trigger" : "agent preset"}
-          open={!!confirmingDeleteAgentPreset}
-          onOpenChange={(open) => !open && setConfirmingDeleteAgentPreset(null)}
-          onDoDelete={() =>
-            confirmingDeleteAgentPreset &&
-            deletePreset(confirmingDeleteAgentPreset)
-          }
-        />
-        {/* Copy agent confirmation dialog */}
-        <Dialog
-          onOpenChange={setCopyAgentDialogOpen}
-          open={copyAgentDialogOpen}
-        >
-          <DialogContent>
-            <DialogHeader>
-              <DialogTitle>You&apos;re making an editable copy</DialogTitle>
-              <DialogDescription className="pt-2">
-                The original Marketplace agent stays the same and cannot be
-                edited. We&apos;ll save a new version of this agent to your
-                Library. From there, you can customize it however you&apos;d
-                like by clicking &quot;Customize agent&quot; — this will open
-                the builder where you can see and modify the inner workings.
-              </DialogDescription>
-            </DialogHeader>
-            <DialogFooter className="justify-end">
-              <Button
-                type="button"
-                variant="outline"
-                onClick={() => setCopyAgentDialogOpen(false)}
-              >
-                Cancel
-              </Button>
-              <Button type="button" onClick={copyAgent}>
-                Continue
-              </Button>
-            </DialogFooter>
-          </DialogContent>
-        </Dialog>
-        <CreatePresetDialog
-          open={!!creatingPresetFromExecutionID}
-          onOpenChange={() => setCreatingPresetFromExecutionID(null)}
-          onConfirm={handleCreatePresetFromRun}
-        />
-      </div>
-    </div>
-  );
-}

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

@@ -1,445 +0,0 @@
-"use client";
-import { format, formatDistanceToNow, formatDistanceStrict } from "date-fns";
-import React, { useCallback, useMemo, useEffect } from "react";
-
-import {
-  Graph,
-  GraphExecution,
-  GraphExecutionID,
-  GraphExecutionMeta,
-  LibraryAgent,
-} from "@/lib/autogpt-server-api";
-import { useBackendAPI } from "@/lib/autogpt-server-api/context";
-
-import ActionButtonGroup from "@/components/__legacy__/action-button-group";
-import type { ButtonAction } from "@/components/__legacy__/types";
-import {
-  Card,
-  CardContent,
-  CardHeader,
-  CardTitle,
-} from "@/components/__legacy__/ui/card";
-import {
-  IconRefresh,
-  IconSquare,
-  IconCircleAlert,
-} from "@/components/__legacy__/ui/icons";
-import { Input } from "@/components/__legacy__/ui/input";
-import LoadingBox from "@/components/__legacy__/ui/loading";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
-} from "@/components/atoms/Tooltip/BaseTooltip";
-import { useToastOnFail } from "@/components/molecules/Toast/use-toast";
-
-import { AgentRunStatus, agentRunStatusMap } from "./agent-run-status-chip";
-import useCredits from "@/hooks/useCredits";
-import { AgentRunOutputView } from "./agent-run-output-view";
-import { analytics } from "@/services/analytics";
-import { PendingReviewsList } from "@/components/organisms/PendingReviewsList/PendingReviewsList";
-import { usePendingReviewsForExecution } from "@/hooks/usePendingReviews";
-
-export function AgentRunDetailsView({
-  agent,
-  graph,
-  run,
-  agentActions,
-  onRun,
-  doDeleteRun,
-  doCreatePresetFromRun,
-}: {
-  agent: LibraryAgent;
-  graph: Graph;
-  run: GraphExecution | GraphExecutionMeta;
-  agentActions: ButtonAction[];
-  onRun: (runID: GraphExecutionID) => void;
-  doDeleteRun: () => void;
-  doCreatePresetFromRun: () => void;
-}): React.ReactNode {
-  const api = useBackendAPI();
-  const { formatCredits } = useCredits();
-
-  const runStatus: AgentRunStatus = useMemo(
-    () => agentRunStatusMap[run.status],
-    [run],
-  );
-
-  const {
-    pendingReviews,
-    isLoading: reviewsLoading,
-    refetch: refetchReviews,
-  } = usePendingReviewsForExecution(run.id);
-
-  const toastOnFail = useToastOnFail();
-
-  // Refetch pending reviews when execution status changes to REVIEW
-  useEffect(() => {
-    if (runStatus === "review" && run.id) {
-      refetchReviews();
-    }
-  }, [runStatus, run.id, refetchReviews]);
-
-  const infoStats: { label: string; value: React.ReactNode }[] = useMemo(() => {
-    if (!run) return [];
-    return [
-      {
-        label: "Status",
-        value: runStatus.charAt(0).toUpperCase() + runStatus.slice(1),
-      },
-      {
-        label: "Started",
-        value: run.started_at
-          ? `${formatDistanceToNow(run.started_at, { addSuffix: true })}, ${format(run.started_at, "HH:mm")}`
-          : "—",
-      },
-      ...(run.stats
-        ? [
-            {
-              label: "Duration",
-              value: formatDistanceStrict(0, run.stats.duration * 1000),
-            },
-            { label: "Steps", value: run.stats.node_exec_count },
-            { label: "Cost", value: formatCredits(run.stats.cost) },
-          ]
-        : []),
-    ];
-  }, [run, runStatus, formatCredits]);
-
-  const agentRunInputs:
-    | Record<
-        string,
-        {
-          title?: string;
-          /* type: BlockIOSubType; */
-          value: string | number | undefined;
-        }
-      >
-    | undefined = useMemo(() => {
-    if (!run.inputs) return undefined;
-    // TODO: show (link to) preset - https://github.com/Significant-Gravitas/AutoGPT/issues/9168
-
-    // Add type info from agent input schema
-    return Object.fromEntries(
-      Object.entries(run.inputs).map(([k, v]) => [
-        k,
-        {
-          title: graph.input_schema.properties[k]?.title,
-          // type: graph.input_schema.properties[k].type, // TODO: implement typed graph inputs
-          value: typeof v == "object" ? JSON.stringify(v, undefined, 2) : v,
-        },
-      ]),
-    );
-  }, [graph, run]);
-
-  const runAgain = useCallback(() => {
-    if (
-      !run.inputs ||
-      !(graph.credentials_input_schema?.required ?? []).every(
-        (k) => k in (run.credential_inputs ?? {}),
-      )
-    )
-      return;
-
-    if (run.preset_id) {
-      return api
-        .executeLibraryAgentPreset(
-          run.preset_id,
-          run.inputs!,
-          run.credential_inputs!,
-        )
-        .then(({ id }) => {
-          analytics.sendDatafastEvent("run_agent", {
-            name: graph.name,
-            id: graph.id,
-          });
-          onRun(id);
-        })
-        .catch(toastOnFail("execute agent preset"));
-    }
-
-    return api
-      .executeGraph(
-        graph.id,
-        graph.version,
-        run.inputs!,
-        run.credential_inputs!,
-        "library",
-      )
-      .then(({ id }) => {
-        analytics.sendDatafastEvent("run_agent", {
-          name: graph.name,
-          id: graph.id,
-        });
-        onRun(id);
-      })
-      .catch(toastOnFail("execute agent"));
-  }, [api, graph, run, onRun, toastOnFail]);
-
-  const stopRun = useCallback(
-    () => api.stopGraphExecution(graph.id, run.id),
-    [api, graph.id, run.id],
-  );
-
-  const agentRunOutputs:
-    | Record<
-        string,
-        {
-          title?: string;
-          /* type: BlockIOSubType; */
-          values: Array<React.ReactNode>;
-        }
-      >
-    | null
-    | undefined = useMemo(() => {
-    if (!("outputs" in run)) return undefined;
-    if (!["running", "success", "failed", "stopped"].includes(runStatus))
-      return null;
-
-    // Add type info from agent input schema
-    return Object.fromEntries(
-      Object.entries(run.outputs).map(([k, vv]) => [
-        k,
-        {
-          title: graph.output_schema.properties[k].title,
-          /* type: agent.output_schema.properties[k].type */
-          values: vv.map((v) =>
-            typeof v == "object" ? JSON.stringify(v, undefined, 2) : v,
-          ),
-        },
-      ]),
-    );
-  }, [graph, run, runStatus]);
-
-  const runActions: ButtonAction[] = useMemo(
-    () => [
-      ...(["running", "queued"].includes(runStatus)
-        ? ([
-            {
-              label: (
-                <>
-                  <IconSquare className="mr-2 size-4" />
-                  Stop run
-                </>
-              ),
-              variant: "secondary",
-              callback: stopRun,
-            },
-          ] satisfies ButtonAction[])
-        : []),
-      ...(["success", "failed", "stopped"].includes(runStatus) &&
-      !graph.has_external_trigger &&
-      (graph.credentials_input_schema?.required ?? []).every(
-        (k) => k in (run.credential_inputs ?? {}),
-      )
-        ? [
-            {
-              label: (
-                <>
-                  <IconRefresh className="mr-2 size-4" />
-                  Run again
-                </>
-              ),
-              callback: runAgain,
-              dataTestId: "run-again-button",
-            },
-          ]
-        : []),
-      ...(agent.can_access_graph
-        ? [
-            {
-              label: "Open run in builder",
-              href: `/build?flowID=${run.graph_id}&flowVersion=${run.graph_version}&flowExecutionID=${run.id}`,
-            },
-          ]
-        : []),
-      { label: "Create preset from run", callback: doCreatePresetFromRun },
-      { label: "Delete run", variant: "secondary", callback: doDeleteRun },
-    ],
-    [
-      runStatus,
-      runAgain,
-      stopRun,
-      doDeleteRun,
-      doCreatePresetFromRun,
-      graph.has_external_trigger,
-      graph.credentials_input_schema?.required,
-      agent.can_access_graph,
-      run.graph_id,
-      run.graph_version,
-      run.id,
-    ],
-  );
-
-  return (
-    <div className="agpt-div flex gap-6">
-      <div className="flex flex-1 flex-col gap-4">
-        <Card className="agpt-box">
-          <CardHeader>
-            <CardTitle className="font-poppins text-lg">Info</CardTitle>
-          </CardHeader>
-
-          <CardContent>
-            <div className="flex justify-stretch gap-4">
-              {infoStats.map(({ label, value }) => (
-                <div key={label} className="flex-1">
-                  <p className="text-sm font-medium text-black">{label}</p>
-                  <p className="text-sm text-neutral-600">{value}</p>
-                </div>
-              ))}
-            </div>
-            {run.status === "FAILED" && (
-              <div className="mt-4 rounded-md border border-red-200 bg-red-50 p-3 dark:border-red-800 dark:bg-red-900/20">
-                <p className="text-sm text-red-800 dark:text-red-200">
-                  <strong>Error:</strong>{" "}
-                  {run.stats?.error ||
-                    "The execution failed due to an internal error. You can re-run the agent to retry."}
-                </p>
-              </div>
-            )}
-          </CardContent>
-        </Card>
-
-        {/* Smart Agent Execution Summary */}
-        {run.stats?.activity_status && (
-          <Card className="agpt-box">
-            <CardHeader>
-              <CardTitle className="flex items-center gap-2 font-poppins text-lg">
-                Task Summary
-                <TooltipProvider>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <IconCircleAlert className="size-4 cursor-help text-neutral-500 hover:text-neutral-700" />
-                    </TooltipTrigger>
-                    <TooltipContent>
-                      <p className="max-w-xs">
-                        This AI-generated summary describes how the agent
-                        handled your task. It’s an experimental feature and may
-                        occasionally be inaccurate.
-                      </p>
-                    </TooltipContent>
-                  </Tooltip>
-                </TooltipProvider>
-              </CardTitle>
-            </CardHeader>
-            <CardContent className="space-y-4">
-              <p className="text-sm leading-relaxed text-neutral-700">
-                {run.stats.activity_status}
-              </p>
-
-              {/* Correctness Score */}
-              {typeof run.stats.correctness_score === "number" && (
-                <div className="flex items-center gap-3 rounded-lg bg-neutral-50 p-3">
-                  <div className="flex items-center gap-2">
-                    <span className="text-sm font-medium text-neutral-600">
-                      Success Estimate:
-                    </span>
-                    <div className="flex items-center gap-2">
-                      <div className="relative h-2 w-16 overflow-hidden rounded-full bg-neutral-200">
-                        <div
-                          className={`h-full transition-all ${
-                            run.stats.correctness_score >= 0.8
-                              ? "bg-green-500"
-                              : run.stats.correctness_score >= 0.6
-                                ? "bg-yellow-500"
-                                : run.stats.correctness_score >= 0.4
-                                  ? "bg-orange-500"
-                                  : "bg-red-500"
-                          }`}
-                          style={{
-                            width: `${Math.round(run.stats.correctness_score * 100)}%`,
-                          }}
-                        />
-                      </div>
-                      <span className="text-sm font-medium">
-                        {Math.round(run.stats.correctness_score * 100)}%
-                      </span>
-                    </div>
-                  </div>
-                  <TooltipProvider>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <IconCircleAlert className="size-4 cursor-help text-neutral-400 hover:text-neutral-600" />
-                      </TooltipTrigger>
-                      <TooltipContent>
-                        <p className="max-w-xs">
-                          AI-generated estimate of how well this execution
-                          achieved its intended purpose. This score indicates
-                          {run.stats.correctness_score >= 0.8
-                            ? " the agent was highly successful."
-                            : run.stats.correctness_score >= 0.6
-                              ? " the agent was mostly successful with minor issues."
-                              : run.stats.correctness_score >= 0.4
-                                ? " the agent was partially successful with some gaps."
-                                : " the agent had limited success with significant issues."}
-                        </p>
-                      </TooltipContent>
-                    </Tooltip>
-                  </TooltipProvider>
-                </div>
-              )}
-            </CardContent>
-          </Card>
-        )}
-
-        {agentRunOutputs !== null && (
-          <AgentRunOutputView agentRunOutputs={agentRunOutputs} />
-        )}
-
-        {/* Pending Reviews Section */}
-        {runStatus === "review" && (
-          <Card className="agpt-box">
-            <CardHeader>
-              <CardTitle className="font-poppins text-lg">
-                Pending Reviews ({pendingReviews.length})
-              </CardTitle>
-            </CardHeader>
-            <CardContent>
-              {reviewsLoading ? (
-                <LoadingBox spinnerSize={12} className="h-24" />
-              ) : pendingReviews.length > 0 ? (
-                <PendingReviewsList
-                  reviews={pendingReviews}
-                  onReviewComplete={refetchReviews}
-                  emptyMessage="No pending reviews for this execution"
-                />
-              ) : (
-                <div className="py-4 text-neutral-600">
-                  No pending reviews for this execution
-                </div>
-              )}
-            </CardContent>
-          </Card>
-        )}
-
-        <Card className="agpt-box">
-          <CardHeader>
-            <CardTitle className="font-poppins text-lg">Input</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-4">
-            {agentRunInputs !== undefined ? (
-              Object.entries(agentRunInputs).map(([key, { title, value }]) => (
-                <div key={key} className="flex flex-col gap-1.5">
-                  <label className="text-sm font-medium">{title || key}</label>
-                  <Input value={value} className="rounded-full" disabled />
-                </div>
-              ))
-            ) : (
-              <LoadingBox spinnerSize={12} className="h-24" />
-            )}
-          </CardContent>
-        </Card>
-      </div>
-
-      {/* Run / Agent Actions */}
-      <aside className="w-48 xl:w-56">
-        <div className="flex flex-col gap-8">
-          <ActionButtonGroup title="Run actions" actions={runActions} />
-
-          <ActionButtonGroup title="Agent actions" actions={agentActions} />
-        </div>
-      </aside>
-    </div>
-  );
-}

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

@@ -1,178 +0,0 @@
-"use client";
-
-import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
-import React, { useMemo } from "react";
-
-import {
-  Card,
-  CardContent,
-  CardHeader,
-  CardTitle,
-} from "@/components/__legacy__/ui/card";
-
-import LoadingBox from "@/components/__legacy__/ui/loading";
-import type { OutputMetadata } from "../../../../../../../../components/contextual/OutputRenderers";
-import {
-  globalRegistry,
-  OutputActions,
-  OutputItem,
-} from "../../../../../../../../components/contextual/OutputRenderers";
-
-export function AgentRunOutputView({
-  agentRunOutputs,
-}: {
-  agentRunOutputs:
-    | Record<
-        string,
-        {
-          title?: string;
-          /* type: BlockIOSubType; */
-          values: Array<React.ReactNode>;
-        }
-      >
-    | undefined;
-}) {
-  const enableEnhancedOutputHandling = useGetFlag(
-    Flag.ENABLE_ENHANCED_OUTPUT_HANDLING,
-  );
-
-  // Prepare items for the renderer system
-  const outputItems = useMemo(() => {
-    if (!agentRunOutputs) return [];
-
-    const items: Array<{
-      key: string;
-      label: string;
-      value: unknown;
-      metadata?: OutputMetadata;
-      renderer: any;
-    }> = [];
-
-    Object.entries(agentRunOutputs).forEach(([key, { title, values }]) => {
-      values.forEach((value, index) => {
-        // Enhanced metadata extraction
-        const metadata: OutputMetadata = {};
-
-        // Type guard to safely access properties
-        if (
-          typeof value === "object" &&
-          value !== null &&
-          !React.isValidElement(value)
-        ) {
-          const objValue = value as any;
-          if (objValue.type) metadata.type = objValue.type;
-          if (objValue.mimeType) metadata.mimeType = objValue.mimeType;
-          if (objValue.filename) metadata.filename = objValue.filename;
-        }
-
-        const renderer = globalRegistry.getRenderer(value, metadata);
-        if (renderer) {
-          items.push({
-            key: `${key}-${index}`,
-            label: index === 0 ? title || key : "",
-            value,
-            metadata,
-            renderer,
-          });
-        } else {
-          const textRenderer = globalRegistry
-            .getAllRenderers()
-            .find((r) => r.name === "TextRenderer");
-          if (textRenderer) {
-            items.push({
-              key: `${key}-${index}`,
-              label: index === 0 ? title || key : "",
-              value: JSON.stringify(value, null, 2),
-              metadata,
-              renderer: textRenderer,
-            });
-          }
-        }
-      });
-    });
-
-    return items;
-  }, [agentRunOutputs]);
-
-  return (
-    <>
-      {enableEnhancedOutputHandling ? (
-        <Card className="agpt-box" style={{ maxWidth: "950px" }}>
-          <CardHeader>
-            <div className="flex items-center justify-between">
-              <CardTitle className="font-poppins text-lg">Output</CardTitle>
-              {outputItems.length > 0 && (
-                <OutputActions
-                  items={outputItems.map((item) => ({
-                    value: item.value,
-                    metadata: item.metadata,
-                    renderer: item.renderer,
-                  }))}
-                />
-              )}
-            </div>
-          </CardHeader>
-
-          <CardContent
-            className="flex flex-col gap-4"
-            style={{ maxWidth: "660px" }}
-          >
-            {agentRunOutputs !== undefined ? (
-              outputItems.length > 0 ? (
-                outputItems.map((item) => (
-                  <OutputItem
-                    key={item.key}
-                    value={item.value}
-                    metadata={item.metadata}
-                    renderer={item.renderer}
-                    label={item.label}
-                  />
-                ))
-              ) : (
-                <p className="text-sm text-muted-foreground">
-                  No outputs to display
-                </p>
-              )
-            ) : (
-              <LoadingBox spinnerSize={12} className="h-24" />
-            )}
-          </CardContent>
-        </Card>
-      ) : (
-        <Card className="agpt-box" style={{ maxWidth: "950px" }}>
-          <CardHeader>
-            <CardTitle className="font-poppins text-lg">Output</CardTitle>
-          </CardHeader>
-
-          <CardContent
-            className="flex flex-col gap-4"
-            style={{ maxWidth: "660px" }}
-          >
-            {agentRunOutputs !== undefined ? (
-              Object.entries(agentRunOutputs).map(
-                ([key, { title, values }]) => (
-                  <div key={key} className="flex flex-col gap-1.5">
-                    <label className="text-sm font-medium">
-                      {title || key}
-                    </label>
-                    {values.map((value, i) => (
-                      <p
-                        className="resize-none overflow-x-auto whitespace-pre-wrap break-words border-none text-sm text-neutral-700 disabled:cursor-not-allowed"
-                        key={i}
-                      >
-                        {value}
-                      </p>
-                    ))}
-                    {/* TODO: pretty type-dependent rendering */}
-                  </div>
-                ),
-              )
-            ) : (
-              <LoadingBox spinnerSize={12} className="h-24" />
-            )}
-          </CardContent>
-        </Card>
-      )}
-    </>
-  );
-}

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

@@ -1,68 +0,0 @@
-import React from "react";
-
-import { Badge } from "@/components/__legacy__/ui/badge";
-
-import { GraphExecutionMeta } from "@/lib/autogpt-server-api/types";
-
-export type AgentRunStatus =
-  | "success"
-  | "failed"
-  | "queued"
-  | "running"
-  | "stopped"
-  | "scheduled"
-  | "draft"
-  | "review";
-
-export const agentRunStatusMap: Record<
-  GraphExecutionMeta["status"],
-  AgentRunStatus
-> = {
-  INCOMPLETE: "draft",
-  COMPLETED: "success",
-  FAILED: "failed",
-  QUEUED: "queued",
-  RUNNING: "running",
-  TERMINATED: "stopped",
-  REVIEW: "review",
-};
-
-const statusData: Record<
-  AgentRunStatus,
-  { label: string; variant: keyof typeof statusStyles }
-> = {
-  success: { label: "Success", variant: "success" },
-  running: { label: "Running", variant: "info" },
-  failed: { label: "Failed", variant: "destructive" },
-  queued: { label: "Queued", variant: "warning" },
-  draft: { label: "Draft", variant: "secondary" },
-  stopped: { label: "Stopped", variant: "secondary" },
-  scheduled: { label: "Scheduled", variant: "secondary" },
-  review: { label: "In Review", variant: "warning" },
-};
-
-const statusStyles = {
-  success:
-    "bg-green-100 text-green-800 hover:bg-green-100 hover:text-green-800",
-  destructive: "bg-red-100 text-red-800 hover:bg-red-100 hover:text-red-800",
-  warning:
-    "bg-yellow-100 text-yellow-800 hover:bg-yellow-100 hover:text-yellow-800",
-  info: "bg-blue-100 text-blue-800 hover:bg-blue-100 hover:text-blue-800",
-  secondary:
-    "bg-slate-100 text-slate-800 hover:bg-slate-100 hover:text-slate-800",
-};
-
-export function AgentRunStatusChip({
-  status,
-}: {
-  status: AgentRunStatus;
-}): React.ReactElement {
-  return (
-    <Badge
-      variant="secondary"
-      className={`text-xs font-medium ${statusStyles[statusData[status]?.variant]} rounded-[45px] px-[9px] py-[3px]`}
-    >
-      {statusData[status]?.label}
-    </Badge>
-  );
-}

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

@@ -1,130 +0,0 @@
-import React from "react";
-import { formatDistanceToNow, isPast } from "date-fns";
-
-import { cn } from "@/lib/utils";
-
-import { Link2Icon, Link2OffIcon, MoreVertical } from "lucide-react";
-import { Card, CardContent } from "@/components/__legacy__/ui/card";
-import { Button } from "@/components/__legacy__/ui/button";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger,
-} from "@/components/__legacy__/ui/dropdown-menu";
-
-import { AgentStatus, AgentStatusChip } from "./agent-status-chip";
-import { AgentRunStatus, AgentRunStatusChip } from "./agent-run-status-chip";
-import { PushPinSimpleIcon } from "@phosphor-icons/react";
-
-export type AgentRunSummaryProps = (
-  | {
-      type: "run";
-      status: AgentRunStatus;
-    }
-  | {
-      type: "preset";
-      status?: undefined;
-    }
-  | {
-      type: "preset.triggered";
-      status: AgentStatus;
-    }
-  | {
-      type: "schedule";
-      status: "scheduled";
-    }
-) & {
-  title: string;
-  timestamp?: number | Date;
-  selected?: boolean;
-  onClick?: () => void;
-  // onRename: () => void;
-  onDelete: () => void;
-  onPinAsPreset?: () => void;
-  className?: string;
-};
-
-export function AgentRunSummaryCard({
-  type,
-  status,
-  title,
-  timestamp,
-  selected = false,
-  onClick,
-  // onRename,
-  onDelete,
-  onPinAsPreset,
-  className,
-}: AgentRunSummaryProps): React.ReactElement {
-  return (
-    <Card
-      className={cn(
-        "agpt-rounded-card cursor-pointer border-zinc-300",
-        selected ? "agpt-card-selected" : "",
-        className,
-      )}
-      onClick={onClick}
-    >
-      <CardContent className="relative p-2.5 lg:p-4">
-        {(type == "run" || type == "schedule") && (
-          <AgentRunStatusChip status={status} />
-        )}
-        {type == "preset" && (
-          <div className="flex items-center text-sm font-medium text-neutral-700">
-            <PushPinSimpleIcon className="mr-1 size-4 text-foreground" /> Preset
-          </div>
-        )}
-        {type == "preset.triggered" && (
-          <div className="flex items-center justify-between">
-            <AgentStatusChip status={status} />
-
-            <div className="flex items-center text-sm font-medium text-neutral-700">
-              {status == "inactive" ? (
-                <Link2OffIcon className="mr-1 size-4 text-foreground" />
-              ) : (
-                <Link2Icon className="mr-1 size-4 text-foreground" />
-              )}{" "}
-              Trigger
-            </div>
-          </div>
-        )}
-
-        <div className="mt-5 flex items-center justify-between">
-          <h3 className="truncate pr-2 text-base font-medium text-neutral-900">
-            {title}
-          </h3>
-
-          <DropdownMenu>
-            <DropdownMenuTrigger asChild>
-              <Button variant="ghost" className="h-5 w-5 p-0">
-                <MoreVertical className="h-5 w-5" />
-              </Button>
-            </DropdownMenuTrigger>
-            <DropdownMenuContent>
-              {onPinAsPreset && (
-                <DropdownMenuItem onClick={onPinAsPreset}>
-                  Pin as a preset
-                </DropdownMenuItem>
-              )}
-
-              {/* <DropdownMenuItem onClick={onRename}>Rename</DropdownMenuItem> */}
-
-              <DropdownMenuItem onClick={onDelete}>Delete</DropdownMenuItem>
-            </DropdownMenuContent>
-          </DropdownMenu>
-        </div>
-
-        {timestamp && (
-          <p
-            className="mt-1 text-sm font-normal text-neutral-500"
-            title={new Date(timestamp).toString()}
-          >
-            {isPast(timestamp) ? "Ran" : "Runs in"}{" "}
-            {formatDistanceToNow(timestamp, { addSuffix: true })}
-          </p>
-        )}
-      </CardContent>
-    </Card>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/agent-runs-selector-list.tsx

@@ -1,237 +0,0 @@
-"use client";
-import { Plus } from "lucide-react";
-import React, { useEffect, useState } from "react";
-
-import {
-  GraphExecutionID,
-  GraphExecutionMeta,
-  LibraryAgent,
-  LibraryAgentPreset,
-  LibraryAgentPresetID,
-  Schedule,
-  ScheduleID,
-} from "@/lib/autogpt-server-api";
-import { cn } from "@/lib/utils";
-
-import { Badge } from "@/components/__legacy__/ui/badge";
-import { Button } from "@/components/atoms/Button/Button";
-import LoadingBox, { LoadingSpinner } from "@/components/__legacy__/ui/loading";
-import { Separator } from "@/components/__legacy__/ui/separator";
-import { ScrollArea } from "@/components/__legacy__/ui/scroll-area";
-import { InfiniteScroll } from "@/components/contextual/InfiniteScroll/InfiniteScroll";
-import { AgentRunsQuery } from "../use-agent-runs";
-import { agentRunStatusMap } from "./agent-run-status-chip";
-import { AgentRunSummaryCard } from "./agent-run-summary-card";
-
-interface AgentRunsSelectorListProps {
-  agent: LibraryAgent;
-  agentRunsQuery: AgentRunsQuery;
-  agentPresets: LibraryAgentPreset[];
-  schedules: Schedule[];
-  selectedView: { type: "run" | "preset" | "schedule"; id?: string };
-  allowDraftNewRun?: boolean;
-  onSelectRun: (id: GraphExecutionID) => void;
-  onSelectPreset: (preset: LibraryAgentPresetID) => void;
-  onSelectSchedule: (id: ScheduleID) => void;
-  onSelectDraftNewRun: () => void;
-  doDeleteRun: (id: GraphExecutionMeta) => void;
-  doDeletePreset: (id: LibraryAgentPresetID) => void;
-  doDeleteSchedule: (id: ScheduleID) => void;
-  doCreatePresetFromRun?: (id: GraphExecutionID) => void;
-  className?: string;
-}
-
-export function AgentRunsSelectorList({
-  agent,
-  agentRunsQuery: {
-    agentRuns,
-    agentRunCount,
-    agentRunsLoading,
-    hasMoreRuns,
-    fetchMoreRuns,
-    isFetchingMoreRuns,
-  },
-  agentPresets,
-  schedules,
-  selectedView,
-  allowDraftNewRun = true,
-  onSelectRun,
-  onSelectPreset,
-  onSelectSchedule,
-  onSelectDraftNewRun,
-  doDeleteRun,
-  doDeletePreset,
-  doDeleteSchedule,
-  doCreatePresetFromRun,
-  className,
-}: AgentRunsSelectorListProps): React.ReactElement {
-  const [activeListTab, setActiveListTab] = useState<"runs" | "scheduled">(
-    "runs",
-  );
-
-  useEffect(() => {
-    if (selectedView.type === "schedule") {
-      setActiveListTab("scheduled");
-    } else {
-      setActiveListTab("runs");
-    }
-  }, [selectedView]);
-
-  const listItemClasses = "h-28 w-72 lg:w-full lg:h-32";
-
-  return (
-    <aside className={cn("flex flex-col gap-4", className)}>
-      {allowDraftNewRun ? (
-        <Button
-          className={"mb-4 hidden lg:flex"}
-          onClick={onSelectDraftNewRun}
-          leftIcon={<Plus className="h-6 w-6" />}
-        >
-          New {agent.has_external_trigger ? "trigger" : "run"}
-        </Button>
-      ) : null}
-
-      <div className="flex gap-2">
-        <Badge
-          variant={activeListTab === "runs" ? "secondary" : "outline"}
-          className="cursor-pointer gap-2 rounded-full text-base"
-          onClick={() => setActiveListTab("runs")}
-        >
-          <span>Runs</span>
-          <span className="text-neutral-600">
-            {agentRunCount ?? <LoadingSpinner className="size-4" />}
-          </span>
-        </Badge>
-
-        <Badge
-          variant={activeListTab === "scheduled" ? "secondary" : "outline"}
-          className="cursor-pointer gap-2 rounded-full text-base"
-          onClick={() => setActiveListTab("scheduled")}
-        >
-          <span>Scheduled</span>
-          <span className="text-neutral-600">{schedules.length}</span>
-        </Badge>
-      </div>
-
-      {/* Runs / Schedules list */}
-      {agentRunsLoading && activeListTab === "runs" ? (
-        <LoadingBox className="h-28 w-full lg:h-[calc(100vh-300px)] lg:w-72 xl:w-80" />
-      ) : (
-        <ScrollArea
-          className="w-full lg:h-[calc(100vh-300px)] lg:w-72 xl:w-80"
-          orientation={window.innerWidth >= 1024 ? "vertical" : "horizontal"}
-        >
-          <InfiniteScroll
-            direction={window.innerWidth >= 1024 ? "vertical" : "horizontal"}
-            hasNextPage={hasMoreRuns}
-            fetchNextPage={fetchMoreRuns}
-            isFetchingNextPage={isFetchingMoreRuns}
-          >
-            <div className="flex items-center gap-2 lg:flex-col">
-              {/* New Run button - only in small layouts */}
-              {allowDraftNewRun && (
-                <Button
-                  size="large"
-                  className={
-                    "flex h-12 w-40 items-center gap-2 py-6 lg:hidden " +
-                    (selectedView.type == "run" && !selectedView.id
-                      ? "agpt-card-selected text-accent"
-                      : "")
-                  }
-                  onClick={onSelectDraftNewRun}
-                  leftIcon={<Plus className="h-6 w-6" />}
-                >
-                  New {agent.has_external_trigger ? "trigger" : "run"}
-                </Button>
-              )}
-
-              {activeListTab === "runs" ? (
-                <>
-                  {agentPresets
-                    .filter((preset) => preset.webhook) // Triggers
-                    .toSorted(
-                      (a, b) => b.updated_at.getTime() - a.updated_at.getTime(),
-                    )
-                    .map((preset) => (
-                      <AgentRunSummaryCard
-                        className={cn(listItemClasses, "lg:h-auto")}
-                        key={preset.id}
-                        type="preset.triggered"
-                        status={preset.is_active ? "active" : "inactive"}
-                        title={preset.name}
-                        // timestamp={preset.last_run_time} // TODO: implement this
-                        selected={selectedView.id === preset.id}
-                        onClick={() => onSelectPreset(preset.id)}
-                        onDelete={() => doDeletePreset(preset.id)}
-                      />
-                    ))}
-                  {agentPresets
-                    .filter((preset) => !preset.webhook) // Presets
-                    .toSorted(
-                      (a, b) => b.updated_at.getTime() - a.updated_at.getTime(),
-                    )
-                    .map((preset) => (
-                      <AgentRunSummaryCard
-                        className={cn(listItemClasses, "lg:h-auto")}
-                        key={preset.id}
-                        type="preset"
-                        title={preset.name}
-                        // timestamp={preset.last_run_time} // TODO: implement this
-                        selected={selectedView.id === preset.id}
-                        onClick={() => onSelectPreset(preset.id)}
-                        onDelete={() => doDeletePreset(preset.id)}
-                      />
-                    ))}
-                  {agentPresets.length > 0 && <Separator className="my-1" />}
-                  {agentRuns
-                    .toSorted((a, b) => {
-                      const aTime = a.started_at?.getTime() ?? 0;
-                      const bTime = b.started_at?.getTime() ?? 0;
-                      return bTime - aTime;
-                    })
-                    .map((run) => (
-                      <AgentRunSummaryCard
-                        className={listItemClasses}
-                        key={run.id}
-                        type="run"
-                        status={agentRunStatusMap[run.status]}
-                        title={
-                          (run.preset_id
-                            ? agentPresets.find((p) => p.id == run.preset_id)
-                                ?.name
-                            : null) ?? agent.name
-                        }
-                        timestamp={run.started_at ?? undefined}
-                        selected={selectedView.id === run.id}
-                        onClick={() => onSelectRun(run.id)}
-                        onDelete={() => doDeleteRun(run as GraphExecutionMeta)}
-                        onPinAsPreset={
-                          doCreatePresetFromRun
-                            ? () => doCreatePresetFromRun(run.id)
-                            : undefined
-                        }
-                      />
-                    ))}
-                </>
-              ) : (
-                schedules.map((schedule) => (
-                  <AgentRunSummaryCard
-                    className={listItemClasses}
-                    key={schedule.id}
-                    type="schedule"
-                    status="scheduled" // TODO: implement active/inactive status for schedules
-                    title={schedule.name}
-                    timestamp={schedule.next_run_time}
-                    selected={selectedView.id === schedule.id}
-                    onClick={() => onSelectSchedule(schedule.id)}
-                    onDelete={() => doDeleteSchedule(schedule.id)}
-                  />
-                ))
-              )}
-            </div>
-          </InfiniteScroll>
-        </ScrollArea>
-      )}
-    </aside>
-  );
-}

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

@@ -1,180 +0,0 @@
-"use client";
-import React, { useCallback, useMemo } from "react";
-
-import {
-  Graph,
-  GraphExecutionID,
-  Schedule,
-  ScheduleID,
-} from "@/lib/autogpt-server-api";
-import { useBackendAPI } from "@/lib/autogpt-server-api/context";
-
-import ActionButtonGroup from "@/components/__legacy__/action-button-group";
-import type { ButtonAction } from "@/components/__legacy__/types";
-import {
-  Card,
-  CardContent,
-  CardHeader,
-  CardTitle,
-} from "@/components/__legacy__/ui/card";
-import { IconCross } from "@/components/__legacy__/ui/icons";
-import { Input } from "@/components/__legacy__/ui/input";
-import LoadingBox from "@/components/__legacy__/ui/loading";
-import { useToastOnFail } from "@/components/molecules/Toast/use-toast";
-import { humanizeCronExpression } from "@/lib/cron-expression-utils";
-import { formatScheduleTime } from "@/lib/timezone-utils";
-import { useUserTimezone } from "@/lib/hooks/useUserTimezone";
-import { PlayIcon } from "lucide-react";
-
-import { AgentRunStatus } from "./agent-run-status-chip";
-
-export function AgentScheduleDetailsView({
-  graph,
-  schedule,
-  agentActions,
-  onForcedRun,
-  doDeleteSchedule,
-}: {
-  graph: Graph;
-  schedule: Schedule;
-  agentActions: ButtonAction[];
-  onForcedRun: (runID: GraphExecutionID) => void;
-  doDeleteSchedule: (scheduleID: ScheduleID) => void;
-}): React.ReactNode {
-  const api = useBackendAPI();
-
-  const selectedRunStatus: AgentRunStatus = "scheduled";
-
-  const toastOnFail = useToastOnFail();
-
-  // Get user's timezone for displaying schedule times
-  const userTimezone = useUserTimezone();
-
-  const infoStats: { label: string; value: React.ReactNode }[] = useMemo(() => {
-    return [
-      {
-        label: "Status",
-        value:
-          selectedRunStatus.charAt(0).toUpperCase() +
-          selectedRunStatus.slice(1),
-      },
-      {
-        label: "Schedule",
-        value: humanizeCronExpression(schedule.cron),
-      },
-      {
-        label: "Next run",
-        value: formatScheduleTime(schedule.next_run_time, userTimezone),
-      },
-    ];
-  }, [schedule, selectedRunStatus, userTimezone]);
-
-  const agentRunInputs: Record<
-    string,
-    { title?: string; /* type: BlockIOSubType; */ value: any }
-  > = useMemo(() => {
-    // TODO: show (link to) preset - https://github.com/Significant-Gravitas/AutoGPT/issues/9168
-
-    // Add type info from agent input schema
-    return Object.fromEntries(
-      Object.entries(schedule.input_data).map(([k, v]) => [
-        k,
-        {
-          title: graph.input_schema.properties[k].title,
-          /* TODO: type: agent.input_schema.properties[k].type */
-          value: v,
-        },
-      ]),
-    );
-  }, [graph, schedule]);
-
-  const runNow = useCallback(
-    () =>
-      api
-        .executeGraph(
-          graph.id,
-          graph.version,
-          schedule.input_data,
-          schedule.input_credentials,
-          "library",
-        )
-        .then((run) => onForcedRun(run.id))
-        .catch(toastOnFail("execute agent")),
-    [api, graph, schedule, onForcedRun, toastOnFail],
-  );
-
-  const runActions: ButtonAction[] = useMemo(
-    () => [
-      {
-        label: (
-          <>
-            <PlayIcon className="mr-2 size-4" />
-            Run now
-          </>
-        ),
-        callback: runNow,
-      },
-      {
-        label: (
-          <>
-            <IconCross className="mr-2 size-4 px-0.5" />
-            Delete schedule
-          </>
-        ),
-        callback: () => doDeleteSchedule(schedule.id),
-        variant: "destructive",
-      },
-    ],
-    [runNow],
-  );
-
-  return (
-    <div className="agpt-div flex gap-6">
-      <div className="flex flex-1 flex-col gap-4">
-        <Card className="agpt-box">
-          <CardHeader>
-            <CardTitle className="font-poppins text-lg">Info</CardTitle>
-          </CardHeader>
-
-          <CardContent>
-            <div className="flex justify-stretch gap-4">
-              {infoStats.map(({ label, value }) => (
-                <div key={label} className="flex-1">
-                  <p className="text-sm font-medium text-black">{label}</p>
-                  <p className="text-sm text-neutral-600">{value}</p>
-                </div>
-              ))}
-            </div>
-          </CardContent>
-        </Card>
-
-        <Card className="agpt-box">
-          <CardHeader>
-            <CardTitle className="font-poppins text-lg">Input</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-4">
-            {agentRunInputs !== undefined ? (
-              Object.entries(agentRunInputs).map(([key, { title, value }]) => (
-                <div key={key} className="flex flex-col gap-1.5">
-                  <label className="text-sm font-medium">{title || key}</label>
-                  <Input value={value} className="rounded-full" disabled />
-                </div>
-              ))
-            ) : (
-              <LoadingBox spinnerSize={12} className="h-24" />
-            )}
-          </CardContent>
-        </Card>
-      </div>
-
-      {/* Run / Agent Actions */}
-      <aside className="w-48 xl:w-56">
-        <div className="flex flex-col gap-8">
-          <ActionButtonGroup title="Run actions" actions={runActions} />
-
-          <ActionButtonGroup title="Agent actions" actions={agentActions} />
-        </div>
-      </aside>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/create-preset-dialog.tsx

@@ -1,100 +0,0 @@
-"use client";
-
-import React, { useState } from "react";
-import { Button } from "@/components/__legacy__/ui/button";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/__legacy__/ui/dialog";
-import { Input } from "@/components/__legacy__/ui/input";
-import { Textarea } from "@/components/__legacy__/ui/textarea";
-
-interface CreatePresetDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  onConfirm: (name: string, description: string) => Promise<void> | void;
-}
-
-export function CreatePresetDialog({
-  open,
-  onOpenChange,
-  onConfirm,
-}: CreatePresetDialogProps) {
-  const [name, setName] = useState("");
-  const [description, setDescription] = useState("");
-
-  const handleSubmit = async () => {
-    if (name.trim()) {
-      await onConfirm(name.trim(), description.trim());
-      setName("");
-      setDescription("");
-      onOpenChange(false);
-    }
-  };
-
-  const handleCancel = () => {
-    setName("");
-    setDescription("");
-    onOpenChange(false);
-  };
-
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
-      e.preventDefault();
-      handleSubmit();
-    }
-  };
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="sm:max-w-[425px]">
-        <DialogHeader>
-          <DialogTitle>Create Preset</DialogTitle>
-          <DialogDescription>
-            Give your preset a name and description to help identify it later.
-          </DialogDescription>
-        </DialogHeader>
-        <div className="grid gap-4 py-4">
-          <div className="grid gap-2">
-            <label htmlFor="preset-name" className="text-sm font-medium">
-              Name *
-            </label>
-            <Input
-              id="preset-name"
-              placeholder="Enter preset name"
-              value={name}
-              onChange={(e) => setName(e.target.value)}
-              onKeyDown={handleKeyDown}
-              autoFocus
-            />
-          </div>
-          <div className="grid gap-2">
-            <label htmlFor="preset-description" className="text-sm font-medium">
-              Description
-            </label>
-            <Textarea
-              id="preset-description"
-              placeholder="Optional description"
-              value={description}
-              onChange={(e) => setDescription(e.target.value)}
-              onKeyDown={handleKeyDown}
-              rows={3}
-            />
-          </div>
-        </div>
-        <DialogFooter>
-          <Button variant="outline" onClick={handleCancel}>
-            Cancel
-          </Button>
-          <Button onClick={handleSubmit} disabled={!name.trim()}>
-            Create Preset
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/use-agent-runs.ts

@@ -1,210 +0,0 @@
-import {
-  GraphExecutionMeta as LegacyGraphExecutionMeta,
-  GraphID,
-  GraphExecutionID,
-} from "@/lib/autogpt-server-api";
-import { getQueryClient } from "@/lib/react-query/queryClient";
-import {
-  getPaginatedTotalCount,
-  getPaginationNextPageNumber,
-  unpaginate,
-} from "@/app/api/helpers";
-import {
-  getV1ListGraphExecutionsResponse,
-  getV1ListGraphExecutionsResponse200,
-  useGetV1ListGraphExecutionsInfinite,
-} from "@/app/api/__generated__/endpoints/graphs/graphs";
-import { GraphExecutionsPaginated } from "@/app/api/__generated__/models/graphExecutionsPaginated";
-import { GraphExecutionMeta as RawGraphExecutionMeta } from "@/app/api/__generated__/models/graphExecutionMeta";
-
-export type GraphExecutionMeta = Omit<
-  RawGraphExecutionMeta,
-  "id" | "user_id" | "graph_id" | "preset_id" | "stats"
-> &
-  Pick<
-    LegacyGraphExecutionMeta,
-    "id" | "user_id" | "graph_id" | "preset_id" | "stats"
-  >;
-
-/** Hook to fetch runs for a specific graph, with support for infinite scroll.
- *
- * @param graphID - The ID of the graph to fetch agent runs for. This parameter is
- *                  optional in the sense that the hook doesn't run unless it is passed.
- *                  This way, it can be used in components where the graph ID is not
- *                  immediately available.
- */
-export const useAgentRunsInfinite = (graphID?: GraphID) => {
-  const queryClient = getQueryClient();
-  const {
-    data: queryResults,
-    refetch: refetchRuns,
-    isPending: agentRunsLoading,
-    isRefetching: agentRunsReloading,
-    hasNextPage: hasMoreRuns,
-    fetchNextPage: fetchMoreRuns,
-    isFetchingNextPage: isFetchingMoreRuns,
-    queryKey,
-  } = useGetV1ListGraphExecutionsInfinite(
-    graphID!,
-    { page: 1, page_size: 20 },
-    {
-      query: {
-        getNextPageParam: getPaginationNextPageNumber,
-
-        // Prevent query from running if graphID is not available (yet)
-        ...(!graphID
-          ? {
-              enabled: false,
-              queryFn: () =>
-                // Fake empty response if graphID is not available (yet)
-                Promise.resolve({
-                  status: 200,
-                  data: {
-                    executions: [],
-                    pagination: {
-                      current_page: 1,
-                      page_size: 20,
-                      total_items: 0,
-                      total_pages: 0,
-                    },
-                  },
-                  headers: new Headers(),
-                } satisfies getV1ListGraphExecutionsResponse),
-            }
-          : {}),
-      },
-    },
-    queryClient,
-  );
-
-  const agentRuns = queryResults ? unpaginate(queryResults, "executions") : [];
-  const agentRunCount = getPaginatedTotalCount(queryResults);
-
-  const upsertAgentRun = (newAgentRun: GraphExecutionMeta) => {
-    queryClient.setQueryData(
-      queryKey,
-      (currentQueryData: typeof queryResults) => {
-        if (!currentQueryData?.pages || agentRunCount === undefined)
-          return currentQueryData;
-
-        const exists = currentQueryData.pages.some((page) => {
-          if (page.status !== 200) return false;
-
-          const response = page.data;
-          return response.executions.some((run) => run.id === newAgentRun.id);
-        });
-        if (exists) {
-          // If the run already exists, we update it
-          return {
-            ...currentQueryData,
-            pages: currentQueryData.pages.map((page) => {
-              if (page.status !== 200) return page;
-              const response = page.data;
-              const executions = response.executions;
-
-              const index = executions.findIndex(
-                (run) => run.id === newAgentRun.id,
-              );
-              if (index === -1) return page;
-
-              const newExecutions = [...executions];
-              newExecutions[index] = newAgentRun;
-
-              return {
-                ...page,
-                data: {
-                  ...response,
-                  executions: newExecutions,
-                },
-              } satisfies getV1ListGraphExecutionsResponse;
-            }),
-          };
-        }
-
-        // If the run does not exist, we add it to the first page
-        const page = currentQueryData
-          .pages[0] as getV1ListGraphExecutionsResponse200 & {
-          headers: Headers;
-        };
-        const updatedExecutions = [newAgentRun, ...page.data.executions];
-        const updatedPage = {
-          ...page,
-          data: {
-            ...page.data,
-            executions: updatedExecutions,
-          },
-        } satisfies getV1ListGraphExecutionsResponse;
-        const updatedPages = [updatedPage, ...currentQueryData.pages.slice(1)];
-        return {
-          ...currentQueryData,
-          pages: updatedPages.map(
-            // Increment the total runs count in the pagination info of all pages
-            (page) =>
-              page.status === 200
-                ? {
-                    ...page,
-                    data: {
-                      ...page.data,
-                      pagination: {
-                        ...page.data.pagination,
-                        total_items: agentRunCount + 1,
-                      },
-                    },
-                  }
-                : page,
-          ),
-        };
-      },
-    );
-  };
-
-  const removeAgentRun = (runID: GraphExecutionID) => {
-    queryClient.setQueryData(
-      [queryKey, { page: 1, page_size: 20 }],
-      (currentQueryData: typeof queryResults) => {
-        if (!currentQueryData?.pages) return currentQueryData;
-
-        let found = false;
-        return {
-          ...currentQueryData,
-          pages: currentQueryData.pages.map((page) => {
-            const response = page.data as GraphExecutionsPaginated;
-            const filteredExecutions = response.executions.filter(
-              (run) => run.id !== runID,
-            );
-            if (filteredExecutions.length < response.executions.length) {
-              found = true;
-            }
-
-            return {
-              ...page,
-              data: {
-                ...response,
-                executions: filteredExecutions,
-                pagination: {
-                  ...response.pagination,
-                  total_items:
-                    response.pagination.total_items - (found ? 1 : 0),
-                },
-              },
-            };
-          }),
-        };
-      },
-    );
-  };
-
-  return {
-    agentRuns: agentRuns as GraphExecutionMeta[],
-    refetchRuns,
-    agentRunCount,
-    agentRunsLoading: agentRunsLoading || agentRunsReloading,
-    hasMoreRuns,
-    fetchMoreRuns,
-    isFetchingMoreRuns,
-    upsertAgentRun,
-    removeAgentRun,
-  };
-};
-
-export type AgentRunsQuery = ReturnType<typeof useAgentRunsInfinite>;

autogpt_platform/frontend/src/app/(platform)/library/legacy/[id]/page.tsx

@@ -1,7 +0,0 @@
-"use client";
-
-import { OldAgentLibraryView } from "../../agents/[id]/components/OldAgentLibraryView/OldAgentLibraryView";
-
-export default function OldAgentLibraryPage() {
-  return <OldAgentLibraryView />;
-}

autogpt_platform/frontend/src/app/globals.css

@@ -180,3 +180,14 @@ body[data-google-picker-open="true"] [data-dialog-content] {
   z-index: 1 !important;
   pointer-events: none !important;
 }
+
+/* CoPilot chat table styling — remove left/right borders, increase padding */
+[data-streamdown="table-wrapper"] table {
+  border-left: none;
+  border-right: none;
+}
+
+[data-streamdown="table-wrapper"] th,
+[data-streamdown="table-wrapper"] td {
+  padding: 0.875rem 1rem; /* py-3.5 px-4 */
+}

autogpt_platform/frontend/src/components/contextual/CronScheduler/cron-scheduler-dialog.tsx

@@ -2,7 +2,7 @@ import { useEffect, useState } from "react";
 import { Input } from "@/components/__legacy__/ui/input";
 import { Button } from "@/components/__legacy__/ui/button";
 import { useToast } from "@/components/molecules/Toast/use-toast";
-import { CronScheduler } from "@/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/cron-scheduler";
+import { CronScheduler } from "@/components/contextual/CronScheduler/cron-scheduler";
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { getTimezoneDisplayName } from "@/lib/timezone-utils";
 import { useUserTimezone } from "@/lib/hooks/useUserTimezone";

autogpt_platform/frontend/src/components/contextual/OutputRenderers/renderers/MarkdownRenderer.tsx

@@ -226,7 +226,7 @@ function renderMarkdown(
           table: ({ children, ...props }) => (
             <div className="my-4 overflow-x-auto">
               <table
-                className="min-w-full divide-y divide-gray-200 rounded-lg border border-gray-200 dark:divide-gray-700 dark:border-gray-700"
+                className="min-w-full divide-y divide-gray-200 border-y border-gray-200 dark:divide-gray-700 dark:border-gray-700"
                 {...props}
               >
                 {children}
@@ -235,7 +235,7 @@ function renderMarkdown(
           ),
           th: ({ children, ...props }) => (
             <th
-              className="bg-gray-50 px-4 py-3 text-left text-xs font-semibold uppercase tracking-wider text-gray-700 dark:bg-gray-800 dark:text-gray-300"
+              className="bg-gray-50 px-4 py-3.5 text-left text-xs font-semibold uppercase tracking-wider text-gray-700 dark:bg-gray-800 dark:text-gray-300"
               {...props}
             >
               {children}
@@ -243,7 +243,7 @@ function renderMarkdown(
           ),
           td: ({ children, ...props }) => (
             <td
-              className="border-t border-gray-200 px-4 py-3 text-sm text-gray-600 dark:border-gray-700 dark:text-gray-400"
+              className="border-t border-gray-200 px-4 py-3.5 text-sm text-gray-600 dark:border-gray-700 dark:text-gray-400"
               {...props}
             >
               {children}

autogpt_platform/frontend/src/components/contextual/PublishAgentModal/components/AgentInfoStep/AgentInfoStep.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { CronExpressionDialog } from "@/app/(platform)/library/agents/[id]/components/OldAgentLibraryView/components/cron-scheduler-dialog";
+import { CronExpressionDialog } from "@/components/contextual/CronScheduler/cron-scheduler-dialog";
 import { Form, FormField } from "@/components/__legacy__/ui/form";
 import { Button } from "@/components/atoms/Button/Button";
 import { Input } from "@/components/atoms/Input/Input";

autogpt_platform/frontend/src/services/feature-flags/use-get-flag.ts

@@ -7,7 +7,6 @@ import { useFlags } from "launchdarkly-react-client-sdk";
 export enum Flag {
   BETA_BLOCKS = "beta-blocks",
   NEW_BLOCK_MENU = "new-block-menu",
-  NEW_AGENT_RUNS = "new-agent-runs",
   GRAPH_SEARCH = "graph-search",
   ENABLE_ENHANCED_OUTPUT_HANDLING = "enable-enhanced-output-handling",
   SHARE_EXECUTION_RESULTS = "share-execution-results",
@@ -22,7 +21,6 @@ const isPwMockEnabled = process.env.NEXT_PUBLIC_PW_TEST === "true";
 const defaultFlags = {
   [Flag.BETA_BLOCKS]: [],
   [Flag.NEW_BLOCK_MENU]: false,
-  [Flag.NEW_AGENT_RUNS]: false,
   [Flag.GRAPH_SEARCH]: false,
   [Flag.ENABLE_ENHANCED_OUTPUT_HANDLING]: false,
   [Flag.SHARE_EXECUTION_RESULTS]: false,

docs/integrations/block-integrations/llm.md

@@ -563,7 +563,7 @@ The block supports conversation continuation through three mechanisms:
 |--------|-------------|------|
 | error | Error message if execution failed | str |
 | response | The output/response from Claude Code execution | str |
-| files | List of text files created/modified by Claude Code during this execution. Each file has 'path', 'relative_path', 'name', and 'content' fields. | List[FileOutput] |
+| files | List of text files created/modified by Claude Code during this execution. Each file has 'path', 'relative_path', 'name', 'content', and 'workspace_ref' fields. workspace_ref contains a workspace:// URI if the file was stored to workspace. | List[SandboxFileOutput] |
 | conversation_history | Full conversation history including this turn. Pass this to conversation_history input to continue on a fresh sandbox if the previous sandbox timed out. | str |
 | session_id | Session ID for this conversation. Pass this back along with sandbox_id to continue the conversation. | str |
 | sandbox_id | ID of the sandbox instance. Pass this back along with session_id to continue the conversation. This is None if dispose_sandbox was True (sandbox was disposed). | str |

docs/integrations/block-integrations/misc.md

@@ -215,6 +215,7 @@ The sandbox includes pip and npm pre-installed. Set timeout to limit execution t
 | response | Text output (if any) of the main execution result | str |
 | stdout_logs | Standard output logs from execution | str |
 | stderr_logs | Standard error logs from execution | str |
+| files | Files created or modified during execution. Each file has path, name, content, and workspace_ref (if stored). | List[SandboxFileOutput] |
 
 ### Possible use case
 <!-- MANUAL: use_case -->