Merge branch 'dev' into claude/fix-queue-ordering-test-VgPU3

Add time.sleep(0.1) after publishing messages before consuming to ensure
all messages are fully committed to RabbitMQ. The test was flaky because
the 4th published message wasn't always visible in the queue when
consumption started immediately after publishing.

autogpt_platform/backend/backend/blocks/claude_code.py

@@ -1,631 +0,0 @@
-import json
-import shlex
-import uuid
-from typing import Literal, Optional
-
-from e2b import AsyncSandbox as BaseAsyncSandbox
-from pydantic import BaseModel, SecretStr
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
-
-# Test credentials for E2B
-TEST_E2B_CREDENTIALS = APIKeyCredentials(
-    id="01234567-89ab-cdef-0123-456789abcdef",
-    provider="e2b",
-    api_key=SecretStr("mock-e2b-api-key"),
-    title="Mock E2B API key",
-    expires_at=None,
-)
-TEST_E2B_CREDENTIALS_INPUT = {
-    "provider": TEST_E2B_CREDENTIALS.provider,
-    "id": TEST_E2B_CREDENTIALS.id,
-    "type": TEST_E2B_CREDENTIALS.type,
-    "title": TEST_E2B_CREDENTIALS.title,
-}
-
-# Test credentials for Anthropic
-TEST_ANTHROPIC_CREDENTIALS = APIKeyCredentials(
-    id="2e568a2b-b2ea-475a-8564-9a676bf31c56",
-    provider="anthropic",
-    api_key=SecretStr("mock-anthropic-api-key"),
-    title="Mock Anthropic API key",
-    expires_at=None,
-)
-TEST_ANTHROPIC_CREDENTIALS_INPUT = {
-    "provider": TEST_ANTHROPIC_CREDENTIALS.provider,
-    "id": TEST_ANTHROPIC_CREDENTIALS.id,
-    "type": TEST_ANTHROPIC_CREDENTIALS.type,
-    "title": TEST_ANTHROPIC_CREDENTIALS.title,
-}
-
-
-class ClaudeCodeBlock(Block):
-    """
-    Execute tasks using Claude Code (Anthropic's AI coding assistant) in an E2B sandbox.
-
-    Claude Code can create files, install tools, run commands, and perform complex
-    coding tasks autonomously within a secure sandbox environment.
-    """
-
-    # Use base template - we'll install Claude Code ourselves for latest version
-    DEFAULT_TEMPLATE = "base"
-
-    class Input(BlockSchemaInput):
-        e2b_credentials: CredentialsMetaInput[
-            Literal[ProviderName.E2B], Literal["api_key"]
-        ] = CredentialsField(
-            description=(
-                "API key for the E2B platform to create the sandbox. "
-                "Get one on the [e2b website](https://e2b.dev/docs)"
-            ),
-        )
-
-        anthropic_credentials: CredentialsMetaInput[
-            Literal[ProviderName.ANTHROPIC], Literal["api_key"]
-        ] = CredentialsField(
-            description=(
-                "API key for Anthropic to power Claude Code. "
-                "Get one at [Anthropic's website](https://console.anthropic.com)"
-            ),
-        )
-
-        prompt: str = SchemaField(
-            description=(
-                "The task or instruction for Claude Code to execute. "
-                "Claude Code can create files, install packages, run commands, "
-                "and perform complex coding tasks."
-            ),
-            placeholder="Create a hello world index.html file",
-            default="",
-            advanced=False,
-        )
-
-        timeout: int = SchemaField(
-            description=(
-                "Sandbox timeout in seconds. Claude Code tasks can take "
-                "a while, so set this appropriately for your task complexity. "
-                "Note: This only applies when creating a new sandbox. "
-                "When reconnecting to an existing sandbox via sandbox_id, "
-                "the original timeout is retained."
-            ),
-            default=300,  # 5 minutes default
-            advanced=True,
-        )
-
-        setup_commands: list[str] = SchemaField(
-            description=(
-                "Optional shell commands to run before executing Claude Code. "
-                "Useful for installing dependencies or setting up the environment."
-            ),
-            default_factory=list,
-            advanced=True,
-        )
-
-        working_directory: str = SchemaField(
-            description="Working directory for Claude Code to operate in.",
-            default="/home/user",
-            advanced=True,
-        )
-
-        # Session/continuation support
-        session_id: str = SchemaField(
-            description=(
-                "Session ID to resume a previous conversation. "
-                "Leave empty for a new conversation. "
-                "Use the session_id from a previous run to continue that conversation."
-            ),
-            default="",
-            advanced=True,
-        )
-
-        sandbox_id: str = SchemaField(
-            description=(
-                "Sandbox ID to reconnect to an existing sandbox. "
-                "Required when resuming a session (along with session_id). "
-                "Use the sandbox_id from a previous run where dispose_sandbox was False."
-            ),
-            default="",
-            advanced=True,
-        )
-
-        conversation_history: str = SchemaField(
-            description=(
-                "Previous conversation history to continue from. "
-                "Use this to restore context on a fresh sandbox if the previous one timed out. "
-                "Pass the conversation_history output from a previous run."
-            ),
-            default="",
-            advanced=True,
-        )
-
-        dispose_sandbox: bool = SchemaField(
-            description=(
-                "Whether to dispose of the sandbox immediately after execution. "
-                "Set to False if you want to continue the conversation later "
-                "(you'll need both sandbox_id and session_id from the output)."
-            ),
-            default=True,
-            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(
-            description=(
-                "List of text files created/modified by Claude Code during this execution. "
-                "Each file has 'path', 'relative_path', 'name', and 'content' fields."
-            )
-        )
-        conversation_history: str = SchemaField(
-            description=(
-                "Full conversation history including this turn. "
-                "Pass this to conversation_history input to continue on a fresh sandbox "
-                "if the previous sandbox timed out."
-            )
-        )
-        session_id: str = SchemaField(
-            description=(
-                "Session ID for this conversation. "
-                "Pass this back along with sandbox_id to continue the conversation."
-            )
-        )
-        sandbox_id: Optional[str] = SchemaField(
-            description=(
-                "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)."
-            ),
-            default=None,
-        )
-        error: str = SchemaField(description="Error message if execution failed")
-
-    def __init__(self):
-        super().__init__(
-            id="4e34f4a5-9b89-4326-ba77-2dd6750b7194",
-            description=(
-                "Execute tasks using Claude Code in an E2B sandbox. "
-                "Claude Code can create files, install tools, run commands, "
-                "and perform complex coding tasks autonomously."
-            ),
-            categories={BlockCategory.DEVELOPER_TOOLS, BlockCategory.AI},
-            input_schema=ClaudeCodeBlock.Input,
-            output_schema=ClaudeCodeBlock.Output,
-            test_credentials={
-                "e2b_credentials": TEST_E2B_CREDENTIALS,
-                "anthropic_credentials": TEST_ANTHROPIC_CREDENTIALS,
-            },
-            test_input={
-                "e2b_credentials": TEST_E2B_CREDENTIALS_INPUT,
-                "anthropic_credentials": TEST_ANTHROPIC_CREDENTIALS_INPUT,
-                "prompt": "Create a hello world HTML file",
-                "timeout": 300,
-                "setup_commands": [],
-                "working_directory": "/home/user",
-                "session_id": "",
-                "sandbox_id": "",
-                "conversation_history": "",
-                "dispose_sandbox": True,
-            },
-            test_output=[
-                ("response", "Created index.html with hello world content"),
-                (
-                    "files",
-                    [
-                        {
-                            "path": "/home/user/index.html",
-                            "relative_path": "index.html",
-                            "name": "index.html",
-                            "content": "<html>Hello World</html>",
-                        }
-                    ],
-                ),
-                (
-                    "conversation_history",
-                    "User: Create a hello world HTML file\n"
-                    "Claude: Created index.html with hello world content",
-                ),
-                ("session_id", str),
-                ("sandbox_id", None),  # None because dispose_sandbox=True in test_input
-            ],
-            test_mock={
-                "execute_claude_code": lambda *args, **kwargs: (
-                    "Created index.html with hello world content",  # response
-                    [
-                        ClaudeCodeBlock.FileOutput(
-                            path="/home/user/index.html",
-                            relative_path="index.html",
-                            name="index.html",
-                            content="<html>Hello World</html>",
-                        )
-                    ],  # files
-                    "User: Create a hello world HTML file\n"
-                    "Claude: Created index.html with hello world content",  # conversation_history
-                    "test-session-id",  # session_id
-                    "sandbox_id",  # sandbox_id
-                ),
-            },
-        )
-
-    async def execute_claude_code(
-        self,
-        e2b_api_key: str,
-        anthropic_api_key: str,
-        prompt: str,
-        timeout: int,
-        setup_commands: list[str],
-        working_directory: str,
-        session_id: str,
-        existing_sandbox_id: str,
-        conversation_history: str,
-        dispose_sandbox: bool,
-    ) -> tuple[str, list["ClaudeCodeBlock.FileOutput"], str, str, str]:
-        """
-        Execute Claude Code in an E2B sandbox.
-
-        Returns:
-            Tuple of (response, files, conversation_history, session_id, sandbox_id)
-        """
-
-        # Validate that sandbox_id is provided when resuming a session
-        if session_id and not existing_sandbox_id:
-            raise ValueError(
-                "sandbox_id is required when resuming a session with session_id. "
-                "The session state is stored in the original sandbox. "
-                "If the sandbox has timed out, use conversation_history instead "
-                "to restore context on a fresh sandbox."
-            )
-
-        sandbox = None
-
-        try:
-            # Either reconnect to existing sandbox or create a new one
-            if existing_sandbox_id:
-                # Reconnect to existing sandbox for conversation continuation
-                sandbox = await BaseAsyncSandbox.connect(
-                    sandbox_id=existing_sandbox_id,
-                    api_key=e2b_api_key,
-                )
-            else:
-                # Create new sandbox
-                sandbox = await BaseAsyncSandbox.create(
-                    template=self.DEFAULT_TEMPLATE,
-                    api_key=e2b_api_key,
-                    timeout=timeout,
-                    envs={"ANTHROPIC_API_KEY": anthropic_api_key},
-                )
-
-                # Install Claude Code from npm (ensures we get the latest version)
-                install_result = await sandbox.commands.run(
-                    "npm install -g @anthropic-ai/claude-code@latest",
-                    timeout=120,  # 2 min timeout for install
-                )
-                if install_result.exit_code != 0:
-                    raise Exception(
-                        f"Failed to install Claude Code: {install_result.stderr}"
-                    )
-
-                # Run any user-provided setup commands
-                for cmd in setup_commands:
-                    setup_result = await sandbox.commands.run(cmd)
-                    if setup_result.exit_code != 0:
-                        raise Exception(
-                            f"Setup command failed: {cmd}\n"
-                            f"Exit code: {setup_result.exit_code}\n"
-                            f"Stdout: {setup_result.stdout}\n"
-                            f"Stderr: {setup_result.stderr}"
-                        )
-
-            # Generate or use provided session ID
-            current_session_id = session_id if session_id else str(uuid.uuid4())
-
-            # Build base Claude flags
-            base_flags = "-p --dangerously-skip-permissions --output-format json"
-
-            # Add conversation history context if provided (for fresh sandbox continuation)
-            history_flag = ""
-            if conversation_history and not session_id:
-                # Inject previous conversation as context via system prompt
-                # Use consistent escaping via _escape_prompt helper
-                escaped_history = self._escape_prompt(
-                    f"Previous conversation context: {conversation_history}"
-                )
-                history_flag = f" --append-system-prompt {escaped_history}"
-
-            # Build Claude command based on whether we're resuming or starting new
-            # Use shlex.quote for working_directory and session IDs to prevent injection
-            safe_working_dir = shlex.quote(working_directory)
-            if session_id:
-                # Resuming existing session (sandbox still alive)
-                safe_session_id = shlex.quote(session_id)
-                claude_command = (
-                    f"cd {safe_working_dir} && "
-                    f"echo {self._escape_prompt(prompt)} | "
-                    f"claude --resume {safe_session_id} {base_flags}"
-                )
-            else:
-                # New session with specific ID
-                safe_current_session_id = shlex.quote(current_session_id)
-                claude_command = (
-                    f"cd {safe_working_dir} && "
-                    f"echo {self._escape_prompt(prompt)} | "
-                    f"claude --session-id {safe_current_session_id} {base_flags}{history_flag}"
-                )
-
-            # Capture timestamp before running Claude Code to filter files later
-            # Capture timestamp 1 second in the past to avoid race condition with file creation
-            timestamp_result = await sandbox.commands.run(
-                "date -u -d '1 second ago' +%Y-%m-%dT%H:%M:%S"
-            )
-            if timestamp_result.exit_code != 0:
-                raise RuntimeError(
-                    f"Failed to capture timestamp: {timestamp_result.stderr}"
-                )
-            start_timestamp = (
-                timestamp_result.stdout.strip() if timestamp_result.stdout else None
-            )
-
-            result = await sandbox.commands.run(
-                claude_command,
-                timeout=0,  # No command timeout - let sandbox timeout handle it
-            )
-
-            # Check for command failure
-            if result.exit_code != 0:
-                error_msg = result.stderr or result.stdout or "Unknown error"
-                raise Exception(
-                    f"Claude Code command failed with exit code {result.exit_code}:\n"
-                    f"{error_msg}"
-                )
-
-            raw_output = result.stdout or ""
-            sandbox_id = sandbox.sandbox_id
-
-            # Parse JSON output to extract response and build conversation history
-            response = ""
-            new_conversation_history = conversation_history or ""
-
-            try:
-                # The JSON output contains the result
-                output_data = json.loads(raw_output)
-                response = output_data.get("result", raw_output)
-
-                # Build conversation history entry
-                turn_entry = f"User: {prompt}\nClaude: {response}"
-                if new_conversation_history:
-                    new_conversation_history = (
-                        f"{new_conversation_history}\n\n{turn_entry}"
-                    )
-                else:
-                    new_conversation_history = turn_entry
-
-            except json.JSONDecodeError:
-                # If not valid JSON, use raw output
-                response = raw_output
-                turn_entry = f"User: {prompt}\nClaude: {response}"
-                if new_conversation_history:
-                    new_conversation_history = (
-                        f"{new_conversation_history}\n\n{turn_entry}"
-                    )
-                else:
-                    new_conversation_history = turn_entry
-
-            # Extract files created/modified during this run
-            files = await self._extract_files(
-                sandbox, working_directory, start_timestamp
-            )
-
-            return (
-                response,
-                files,
-                new_conversation_history,
-                current_session_id,
-                sandbox_id,
-            )
-
-        finally:
-            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
-        escaped = prompt.replace("'", "'\"'\"'")
-        return f"'{escaped}'"
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        e2b_credentials: APIKeyCredentials,
-        anthropic_credentials: APIKeyCredentials,
-        **kwargs,
-    ) -> BlockOutput:
-        try:
-            (
-                response,
-                files,
-                conversation_history,
-                session_id,
-                sandbox_id,
-            ) = await self.execute_claude_code(
-                e2b_api_key=e2b_credentials.api_key.get_secret_value(),
-                anthropic_api_key=anthropic_credentials.api_key.get_secret_value(),
-                prompt=input_data.prompt,
-                timeout=input_data.timeout,
-                setup_commands=input_data.setup_commands,
-                working_directory=input_data.working_directory,
-                session_id=input_data.session_id,
-                existing_sandbox_id=input_data.sandbox_id,
-                conversation_history=input_data.conversation_history,
-                dispose_sandbox=input_data.dispose_sandbox,
-            )
-
-            yield "response", response
-            # Always yield files (empty list if none) to match Output schema
-            yield "files", [f.model_dump() for f in files]
-            # Always yield conversation_history so user can restore context on fresh sandbox
-            yield "conversation_history", conversation_history
-            # Always yield session_id so user can continue conversation
-            yield "session_id", session_id
-            # Always yield sandbox_id (None if disposed) to match Output schema
-            yield "sandbox_id", sandbox_id if not input_data.dispose_sandbox else None
-
-        except Exception as e:
-            yield "error", str(e)

autogpt_platform/backend/backend/blocks/search.py

@@ -18,7 +18,6 @@ from backend.data.model import (
     SchemaField,
 )
 from backend.integrations.providers import ProviderName
-from backend.util.request import DEFAULT_USER_AGENT
 
 
 class GetWikipediaSummaryBlock(Block, GetRequest):
@@ -40,27 +39,17 @@ class GetWikipediaSummaryBlock(Block, GetRequest):
             output_schema=GetWikipediaSummaryBlock.Output,
             test_input={"topic": "Artificial Intelligence"},
             test_output=("summary", "summary content"),
-            test_mock={
-                "get_request": lambda url, headers, json: {"extract": "summary content"}
-            },
+            test_mock={"get_request": lambda url, json: {"extract": "summary content"}},
         )
 
     async def run(self, input_data: Input, **kwargs) -> BlockOutput:
         topic = input_data.topic
-        # URL-encode the topic to handle spaces and special characters
-        encoded_topic = quote(topic, safe="")
-        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{encoded_topic}"
-
-        # Set headers per Wikimedia robot policy (https://w.wiki/4wJS)
-        # - User-Agent: Required, must identify the bot
-        # - Accept-Encoding: gzip recommended to reduce bandwidth
-        headers = {
-            "User-Agent": DEFAULT_USER_AGENT,
-            "Accept-Encoding": "gzip, deflate",
-        }
+        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{topic}"
 
+        # Note: User-Agent is now automatically set by the request library
+        # to comply with Wikimedia's robot policy (https://w.wiki/4wJS)
         try:
-            response = await self.get_request(url, headers=headers, json=True)
+            response = await self.get_request(url, json=True)
             if "extract" not in response:
                 raise ValueError(f"Unable to parse Wikipedia response: {response}")
             yield "summary", response["extract"]

autogpt_platform/backend/backend/blocks/smart_decision_maker.py

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

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

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

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

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

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

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

autogpt_platform/backend/backend/blocks/wordpress/__init__.py

@@ -1,3 +1,3 @@
-from .blog import WordPressCreatePostBlock, WordPressGetAllPostsBlock
+from .blog import WordPressCreatePostBlock
 
-__all__ = ["WordPressCreatePostBlock", "WordPressGetAllPostsBlock"]
+__all__ = ["WordPressCreatePostBlock"]

autogpt_platform/backend/backend/blocks/wordpress/_api.py

@@ -161,7 +161,7 @@ async def oauth_exchange_code_for_tokens(
         grant_type="authorization_code",
     ).model_dump(exclude_none=True)
 
-    response = await Requests(raise_for_status=False).post(
+    response = await Requests().post(
         f"{WORDPRESS_BASE_URL}oauth2/token",
         headers=headers,
         data=data,
@@ -205,7 +205,7 @@ async def oauth_refresh_tokens(
         grant_type="refresh_token",
     ).model_dump(exclude_none=True)
 
-    response = await Requests(raise_for_status=False).post(
+    response = await Requests().post(
         f"{WORDPRESS_BASE_URL}oauth2/token",
         headers=headers,
         data=data,
@@ -252,7 +252,7 @@ async def validate_token(
         "token": token,
     }
 
-    response = await Requests(raise_for_status=False).get(
+    response = await Requests().get(
         f"{WORDPRESS_BASE_URL}oauth2/token-info",
         params=params,
     )
@@ -296,7 +296,7 @@ async def make_api_request(
 
     url = f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}"
 
-    request_method = getattr(Requests(raise_for_status=False), method.lower())
+    request_method = getattr(Requests(), method.lower())
     response = await request_method(
         url,
         headers=headers,
@@ -476,7 +476,6 @@ async def create_post(
         data["tags"] = ",".join(str(t) for t in data["tags"])
 
     # Make the API request
-    site = normalize_site(site)
     endpoint = f"/rest/v1.1/sites/{site}/posts/new"
 
     headers = {
@@ -484,7 +483,7 @@ async def create_post(
         "Content-Type": "application/x-www-form-urlencoded",
     }
 
-    response = await Requests(raise_for_status=False).post(
+    response = await Requests().post(
         f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}",
         headers=headers,
         data=data,
@@ -500,132 +499,3 @@ async def create_post(
     )
     error_message = error_data.get("message", response.text)
     raise ValueError(f"Failed to create post: {response.status} - {error_message}")
-
-
-class Post(BaseModel):
-    """Response model for individual posts in a posts list response.
-
-    This is a simplified version compared to PostResponse, as the list endpoint
-    returns less detailed information than the create/get single post endpoints.
-    """
-
-    ID: int
-    site_ID: int
-    author: PostAuthor
-    date: datetime
-    modified: datetime
-    title: str
-    URL: str
-    short_URL: str
-    content: str | None = None
-    excerpt: str | None = None
-    slug: str
-    guid: str
-    status: str
-    sticky: bool
-    password: str | None = ""
-    parent: Union[Dict[str, Any], bool, None] = None
-    type: str
-    discussion: Dict[str, Union[str, bool, int]] | None = None
-    likes_enabled: bool | None = None
-    sharing_enabled: bool | None = None
-    like_count: int | None = None
-    i_like: bool | None = None
-    is_reblogged: bool | None = None
-    is_following: bool | None = None
-    global_ID: str | None = None
-    featured_image: str | None = None
-    post_thumbnail: Dict[str, Any] | None = None
-    format: str | None = None
-    geo: Union[Dict[str, Any], bool, None] = None
-    menu_order: int | None = None
-    page_template: str | None = None
-    publicize_URLs: List[str] | None = None
-    terms: Dict[str, Dict[str, Any]] | None = None
-    tags: Dict[str, Dict[str, Any]] | None = None
-    categories: Dict[str, Dict[str, Any]] | None = None
-    attachments: Dict[str, Dict[str, Any]] | None = None
-    attachment_count: int | None = None
-    metadata: List[Dict[str, Any]] | None = None
-    meta: Dict[str, Any] | None = None
-    capabilities: Dict[str, bool] | None = None
-    revisions: List[int] | None = None
-    other_URLs: Dict[str, Any] | None = None
-
-
-class PostsResponse(BaseModel):
-    """Response model for WordPress posts list."""
-
-    found: int
-    posts: List[Post]
-    meta: Dict[str, Any]
-
-
-def normalize_site(site: str) -> str:
-    """
-    Normalize a site identifier by stripping protocol and trailing slashes.
-
-    Args:
-        site: Site URL, domain, or ID (e.g., "https://myblog.wordpress.com/", "myblog.wordpress.com", "123456789")
-
-    Returns:
-        Normalized site identifier (domain or ID only)
-    """
-    site = site.strip()
-    if site.startswith("https://"):
-        site = site[8:]
-    elif site.startswith("http://"):
-        site = site[7:]
-    return site.rstrip("/")
-
-
-async def get_posts(
-    credentials: Credentials,
-    site: str,
-    status: PostStatus | None = None,
-    number: int = 100,
-    offset: int = 0,
-) -> PostsResponse:
-    """
-    Get posts from a WordPress site.
-
-    Args:
-        credentials: OAuth credentials
-        site: Site ID or domain (e.g., "myblog.wordpress.com" or "123456789")
-        status: Filter by post status using PostStatus enum, or None for all
-        number: Number of posts to retrieve (max 100)
-        offset: Number of posts to skip (for pagination)
-
-    Returns:
-        PostsResponse with the list of posts
-    """
-    site = normalize_site(site)
-    endpoint = f"/rest/v1.1/sites/{site}/posts"
-
-    headers = {
-        "Authorization": credentials.auth_header(),
-    }
-
-    params: Dict[str, Any] = {
-        "number": max(1, min(number, 100)),  # 1–100 posts per request
-        "offset": offset,
-    }
-
-    if status:
-        params["status"] = status.value
-    response = await Requests(raise_for_status=False).get(
-        f"{WORDPRESS_BASE_URL.rstrip('/')}{endpoint}",
-        headers=headers,
-        params=params,
-    )
-
-    if response.ok:
-        return PostsResponse.model_validate(response.json())
-
-    error_data = (
-        response.json()
-        if response.headers.get("content-type", "").startswith("application/json")
-        else {}
-    )
-    error_message = error_data.get("message", response.text)
-    raise ValueError(f"Failed to get posts: {response.status} - {error_message}")

autogpt_platform/backend/backend/blocks/wordpress/blog.py

@@ -9,15 +9,7 @@ from backend.sdk import (
     SchemaField,
 )
 
-from ._api import (
-    CreatePostRequest,
-    Post,
-    PostResponse,
-    PostsResponse,
-    PostStatus,
-    create_post,
-    get_posts,
-)
+from ._api import CreatePostRequest, PostResponse, PostStatus, create_post
 from ._config import wordpress
 
 
@@ -57,15 +49,8 @@ class WordPressCreatePostBlock(Block):
         media_urls: list[str] = SchemaField(
             description="URLs of images to sideload and attach to the post", default=[]
         )
-        publish_as_draft: bool = SchemaField(
-            description="If True, publishes the post as a draft. If False, publishes it publicly.",
-            default=False,
-        )
 
     class Output(BlockSchemaOutput):
-        site: str = SchemaField(
-            description="The site ID or domain (pass-through for chaining with other blocks)"
-        )
         post_id: int = SchemaField(description="The ID of the created post")
         post_url: str = SchemaField(description="The full URL of the created post")
         short_url: str = SchemaField(description="The shortened wp.me URL")
@@ -93,9 +78,7 @@ class WordPressCreatePostBlock(Block):
             tags=input_data.tags,
             featured_image=input_data.featured_image,
             media_urls=input_data.media_urls,
-            status=(
-                PostStatus.DRAFT if input_data.publish_as_draft else PostStatus.PUBLISH
-            ),
+            status=PostStatus.PUBLISH,
         )
 
         post_response: PostResponse = await create_post(
@@ -104,69 +87,7 @@ class WordPressCreatePostBlock(Block):
             post_data=post_request,
         )
 
-        yield "site", input_data.site
         yield "post_id", post_response.ID
         yield "post_url", post_response.URL
         yield "short_url", post_response.short_URL
         yield "post_data", post_response.model_dump()
-
-
-class WordPressGetAllPostsBlock(Block):
-    """
-    Fetches all posts from a WordPress.com site or Jetpack-enabled site.
-    Supports filtering by status and pagination.
-    """
-
-    class Input(BlockSchemaInput):
-        credentials: CredentialsMetaInput = wordpress.credentials_field()
-        site: str = SchemaField(
-            description="Site ID or domain (e.g., 'myblog.wordpress.com' or '123456789')"
-        )
-        status: PostStatus | None = SchemaField(
-            description="Filter by post status, or None for all",
-            default=None,
-        )
-        number: int = SchemaField(
-            description="Number of posts to retrieve (max 100 per request)", default=20
-        )
-        offset: int = SchemaField(
-            description="Number of posts to skip (for pagination)", default=0
-        )
-
-    class Output(BlockSchemaOutput):
-        site: str = SchemaField(
-            description="The site ID or domain (pass-through for chaining with other blocks)"
-        )
-        found: int = SchemaField(description="Total number of posts found")
-        posts: list[Post] = SchemaField(
-            description="List of post objects with their details"
-        )
-        post: Post = SchemaField(
-            description="Individual post object (yielded for each post)"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="97728fa7-7f6f-4789-ba0c-f2c114119536",
-            description="Fetch all posts from WordPress.com or Jetpack sites",
-            categories={BlockCategory.SOCIAL},
-            input_schema=self.Input,
-            output_schema=self.Output,
-        )
-
-    async def run(
-        self, input_data: Input, *, credentials: Credentials, **kwargs
-    ) -> BlockOutput:
-        posts_response: PostsResponse = await get_posts(
-            credentials=credentials,
-            site=input_data.site,
-            status=input_data.status,
-            number=input_data.number,
-            offset=input_data.offset,
-        )
-
-        yield "site", input_data.site
-        yield "found", posts_response.found
-        yield "posts", posts_response.posts
-        for post in posts_response.posts:
-            yield "post", post

autogpt_platform/backend/test_requeue_integration.py

@@ -167,6 +167,9 @@ def test_queue_ordering_behavior():
         tester.publish_message(msg_b)
         tester.publish_message(msg_c)
 
+        # Give RabbitMQ time to process all published messages before consuming
+        time.sleep(0.1)
+
         # Consume and verify FIFO order: A, B, C
         tester.received_messages = []
         tester.stop_consuming.clear()
@@ -204,6 +207,9 @@ def test_queue_ordering_behavior():
         # This is what happens in manager.py when requeue_by_republishing=True
         tester.publish_message(user1_msg)  # Goes to back via our method
 
+        # Give RabbitMQ time to process all published messages before consuming
+        time.sleep(0.1)
+
         # Expected order: RATE-LIMITED, USER2-1, USER2-2, RATE-LIMITED (republished to back)
         # This shows that user2 messages get processed instead of being blocked
         tester.received_messages = []
@@ -234,6 +240,9 @@ def test_queue_ordering_behavior():
         # Republish X (simulates requeue using our method)
         tester.publish_message(msg_x)
 
+        # Give RabbitMQ time to process all published messages before consuming
+        time.sleep(0.1)
+
         # Expected: X, Y, X (X was republished to back)
         tester.received_messages = []
         tester.stop_consuming.clear()

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

@@ -68,10 +68,7 @@ export const NodeHeader = ({ data, nodeId }: Props) => {
                 <Tooltip>
                   <TooltipTrigger asChild>
                     <div>
-                      <Text
-                        variant="large-semibold"
-                        className="line-clamp-1 hover:cursor-text"
-                      >
+                      <Text variant="large-semibold" className="line-clamp-1">
                         {beautifyString(title).replace("Block", "").trim()}
                       </Text>
                     </div>

autogpt_platform/frontend/src/app/(platform)/build/components/FlowEditor/nodes/helpers.ts

@@ -89,18 +89,6 @@ export function extractOptions(
 
 // get display type and color for schema types [need for type display next to field name]
 export const getTypeDisplayInfo = (schema: any) => {
-  if (
-    schema?.type === "array" &&
-    "format" in schema &&
-    schema.format === "table"
-  ) {
-    return {
-      displayType: "table",
-      colorClass: "!text-indigo-500",
-      hexColor: "#6366f1",
-    };
-  }
-
   if (schema?.type === "string" && schema?.format) {
     const formatMap: Record<
       string,

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

@@ -36,7 +36,6 @@ type Props = {
   readOnly?: boolean;
   isOptional?: boolean;
   showTitle?: boolean;
-  variant?: "default" | "node";
 };
 
 export function CredentialsInput({
@@ -49,7 +48,6 @@ export function CredentialsInput({
   readOnly = false,
   isOptional = false,
   showTitle = true,
-  variant = "default",
 }: Props) {
   const hookData = useCredentialsInput({
     schema,
@@ -125,7 +123,6 @@ export function CredentialsInput({
               onClearCredential={() => onSelectCredential(undefined)}
               readOnly={readOnly}
               allowNone={isOptional}
-              variant={variant}
             />
           ) : (
             <div className="mb-4 space-y-2">

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

@@ -30,8 +30,6 @@ type CredentialRowProps = {
   readOnly?: boolean;
   showCaret?: boolean;
   asSelectTrigger?: boolean;
-  /** When "node", applies compact styling for node context */
-  variant?: "default" | "node";
 };
 
 export function CredentialRow({
@@ -43,22 +41,14 @@ export function CredentialRow({
   readOnly = false,
   showCaret = false,
   asSelectTrigger = false,
-  variant = "default",
 }: CredentialRowProps) {
   const ProviderIcon = providerIcons[provider] || fallbackIcon;
-  const isNodeVariant = variant === "node";
 
   return (
     <div
       className={cn(
         "flex items-center gap-3 rounded-medium border border-zinc-200 bg-white p-3 transition-colors",
-        asSelectTrigger && isNodeVariant
-          ? "min-w-0 flex-1 overflow-hidden border-0 bg-transparent"
-          : asSelectTrigger
-            ? "border-0 bg-transparent"
-            : readOnly
-              ? "w-fit"
-              : "",
+        asSelectTrigger ? "border-0 bg-transparent" : readOnly ? "w-fit" : "",
       )}
       onClick={readOnly || showCaret || asSelectTrigger ? undefined : onSelect}
       style={
@@ -71,31 +61,19 @@ export function CredentialRow({
         <ProviderIcon className="h-3 w-3 text-white" />
       </div>
       <IconKey className="h-5 w-5 shrink-0 text-zinc-800" />
-      <div
-        className={cn(
-          "flex min-w-0 flex-1 flex-nowrap items-center gap-4",
-          isNodeVariant && "overflow-hidden",
-        )}
-      >
+      <div className="flex min-w-0 flex-1 flex-nowrap items-center gap-4">
         <Text
           variant="body"
-          className={cn(
-            "tracking-tight",
-            isNodeVariant
-              ? "truncate"
-              : "line-clamp-1 flex-[0_0_50%] text-ellipsis",
-          )}
+          className="line-clamp-1 flex-[0_0_50%] text-ellipsis tracking-tight"
         >
           {getCredentialDisplayName(credential, displayName)}
         </Text>
-        {!(asSelectTrigger && isNodeVariant) && (
-          <Text
-            variant="large"
-            className="relative top-1 hidden overflow-hidden whitespace-nowrap font-mono tracking-tight md:block"
-          >
-            {"*".repeat(MASKED_KEY_LENGTH)}
-          </Text>
-        )}
+        <Text
+          variant="large"
+          className="lex-[0_0_40%] relative top-1 hidden overflow-hidden whitespace-nowrap font-mono tracking-tight md:block"
+        >
+          {"*".repeat(MASKED_KEY_LENGTH)}
+        </Text>
       </div>
       {showCaret && !asSelectTrigger && (
         <CaretDown className="h-4 w-4 shrink-0 text-gray-400" />

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

@@ -7,7 +7,6 @@ import {
 } from "@/components/__legacy__/ui/select";
 import { Text } from "@/components/atoms/Text/Text";
 import { CredentialsMetaInput } from "@/lib/autogpt-server-api/types";
-import { cn } from "@/lib/utils";
 import { useEffect } from "react";
 import { getCredentialDisplayName } from "../../helpers";
 import { CredentialRow } from "../CredentialRow/CredentialRow";
@@ -27,8 +26,6 @@ interface Props {
   onClearCredential?: () => void;
   readOnly?: boolean;
   allowNone?: boolean;
-  /** When "node", applies compact styling for node context */
-  variant?: "default" | "node";
 }
 
 export function CredentialsSelect({
@@ -40,7 +37,6 @@ export function CredentialsSelect({
   onClearCredential,
   readOnly = false,
   allowNone = true,
-  variant = "default",
 }: Props) {
   // Auto-select first credential if none is selected (only if allowNone is false)
   useEffect(() => {
@@ -63,12 +59,7 @@ export function CredentialsSelect({
         value={selectedCredentials?.id || (allowNone ? "__none__" : "")}
         onValueChange={handleValueChange}
       >
-        <SelectTrigger
-          className={cn(
-            "h-auto min-h-12 w-full rounded-medium border-zinc-200 p-0 pr-4 shadow-none",
-            variant === "node" && "overflow-hidden",
-          )}
-        >
+        <SelectTrigger className="h-auto min-h-12 w-full rounded-medium border-zinc-200 p-0 pr-4 shadow-none">
           {selectedCredentials ? (
             <SelectValue key={selectedCredentials.id} asChild>
               <CredentialRow
@@ -84,7 +75,6 @@ export function CredentialsSelect({
                 onDelete={() => {}}
                 readOnly={readOnly}
                 asSelectTrigger={true}
-                variant={variant}
               />
             </SelectValue>
           ) : (

autogpt_platform/frontend/src/components/molecules/Table/Table.stories.tsx

@@ -1,116 +0,0 @@
-import type { Meta, StoryObj } from "@storybook/nextjs";
-import { TooltipProvider } from "@/components/atoms/Tooltip/BaseTooltip";
-import { Table } from "./Table";
-
-const meta = {
-  title: "Molecules/Table",
-  component: Table,
-  decorators: [
-    (Story) => (
-      <TooltipProvider>
-        <Story />
-      </TooltipProvider>
-    ),
-  ],
-  parameters: {
-    layout: "centered",
-  },
-  tags: ["autodocs"],
-  argTypes: {
-    allowAddRow: {
-      control: "boolean",
-      description: "Whether to show the Add row button",
-    },
-    allowDeleteRow: {
-      control: "boolean",
-      description: "Whether to show delete buttons for each row",
-    },
-    readOnly: {
-      control: "boolean",
-      description:
-        "Whether the table is read-only (renders text instead of inputs)",
-    },
-    addRowLabel: {
-      control: "text",
-      description: "Label for the Add row button",
-    },
-  },
-} satisfies Meta<typeof Table>;
-
-export default meta;
-type Story = StoryObj<typeof meta>;
-
-export const Default: Story = {
-  args: {
-    columns: ["name", "email", "role"],
-    allowAddRow: true,
-    allowDeleteRow: true,
-  },
-};
-
-export const WithDefaultValues: Story = {
-  args: {
-    columns: ["name", "email", "role"],
-    defaultValues: [
-      { name: "John Doe", email: "john@example.com", role: "Admin" },
-      { name: "Jane Smith", email: "jane@example.com", role: "User" },
-      { name: "Bob Wilson", email: "bob@example.com", role: "Editor" },
-    ],
-    allowAddRow: true,
-    allowDeleteRow: true,
-  },
-};
-
-export const ReadOnly: Story = {
-  args: {
-    columns: ["name", "email"],
-    defaultValues: [
-      { name: "John Doe", email: "john@example.com" },
-      { name: "Jane Smith", email: "jane@example.com" },
-    ],
-    readOnly: true,
-  },
-};
-
-export const NoAddOrDelete: Story = {
-  args: {
-    columns: ["name", "email"],
-    defaultValues: [
-      { name: "John Doe", email: "john@example.com" },
-      { name: "Jane Smith", email: "jane@example.com" },
-    ],
-    allowAddRow: false,
-    allowDeleteRow: false,
-  },
-};
-
-export const SingleColumn: Story = {
-  args: {
-    columns: ["item"],
-    allowAddRow: true,
-    allowDeleteRow: true,
-    addRowLabel: "Add item",
-  },
-};
-
-export const CustomAddLabel: Story = {
-  args: {
-    columns: ["key", "value"],
-    allowAddRow: true,
-    allowDeleteRow: true,
-    addRowLabel: "Add new entry",
-  },
-};
-
-export const KeyValuePairs: Story = {
-  args: {
-    columns: ["key", "value"],
-    defaultValues: [
-      { key: "API_KEY", value: "sk-..." },
-      { key: "DATABASE_URL", value: "postgres://..." },
-    ],
-    allowAddRow: true,
-    allowDeleteRow: true,
-    addRowLabel: "Add variable",
-  },
-};

autogpt_platform/frontend/src/components/molecules/Table/Table.tsx

@@ -1,133 +0,0 @@
-import * as React from "react";
-import {
-  Table as BaseTable,
-  TableBody,
-  TableCell,
-  TableHead,
-  TableHeader,
-  TableRow,
-} from "@/components/__legacy__/ui/table";
-import { Button } from "@/components/atoms/Button/Button";
-import { Input } from "@/components/atoms/Input/Input";
-import { Text } from "@/components/atoms/Text/Text";
-import { Plus, Trash2 } from "lucide-react";
-import { cn } from "@/lib/utils";
-import { useTable, RowData } from "./useTable";
-import { formatColumnTitle, formatPlaceholder } from "./helpers";
-
-export interface TableProps {
-  columns: string[];
-  defaultValues?: RowData[];
-  onChange?: (rows: RowData[]) => void;
-  allowAddRow?: boolean;
-  allowDeleteRow?: boolean;
-  addRowLabel?: string;
-  className?: string;
-  readOnly?: boolean;
-}
-
-export function Table({
-  columns,
-  defaultValues,
-  onChange,
-  allowAddRow = true,
-  allowDeleteRow = true,
-  addRowLabel = "Add row",
-  className,
-  readOnly = false,
-}: TableProps) {
-  const { rows, handleAddRow, handleDeleteRow, handleCellChange } = useTable({
-    columns,
-    defaultValues,
-    onChange,
-  });
-
-  const showDeleteColumn = allowDeleteRow && !readOnly;
-  const showAddButton = allowAddRow && !readOnly;
-
-  return (
-    <div className={cn("flex flex-col gap-3", className)}>
-      <div className="overflow-hidden rounded-xl border border-zinc-200 bg-white">
-        <BaseTable>
-          <TableHeader>
-            <TableRow className="border-b border-zinc-100 bg-zinc-50/50">
-              {columns.map((column) => (
-                <TableHead
-                  key={column}
-                  className="h-10 px-3 text-sm font-medium text-zinc-600"
-                >
-                  {formatColumnTitle(column)}
-                </TableHead>
-              ))}
-              {showDeleteColumn && <TableHead className="w-[50px]" />}
-            </TableRow>
-          </TableHeader>
-          <TableBody>
-            {rows.map((row, rowIndex) => (
-              <TableRow key={rowIndex} className="border-none">
-                {columns.map((column) => (
-                  <TableCell key={`${rowIndex}-${column}`} className="p-2">
-                    {readOnly ? (
-                      <Text
-                        variant="body"
-                        className="px-3 py-2 text-sm text-zinc-800"
-                      >
-                        {row[column] || "-"}
-                      </Text>
-                    ) : (
-                      <Input
-                        id={`table-${rowIndex}-${column}`}
-                        label={formatColumnTitle(column)}
-                        hideLabel
-                        value={row[column] ?? ""}
-                        onChange={(e) =>
-                          handleCellChange(rowIndex, column, e.target.value)
-                        }
-                        placeholder={formatPlaceholder(column)}
-                        size="small"
-                        wrapperClassName="mb-0"
-                      />
-                    )}
-                  </TableCell>
-                ))}
-                {showDeleteColumn && (
-                  <TableCell className="p-2">
-                    <Button
-                      variant="icon"
-                      size="icon"
-                      onClick={() => handleDeleteRow(rowIndex)}
-                      aria-label="Delete row"
-                      className="text-zinc-400 transition-colors hover:text-red-500"
-                    >
-                      <Trash2 className="h-4 w-4" />
-                    </Button>
-                  </TableCell>
-                )}
-              </TableRow>
-            ))}
-            {showAddButton && (
-              <TableRow>
-                <TableCell
-                  colSpan={columns.length + (showDeleteColumn ? 1 : 0)}
-                  className="p-2"
-                >
-                  <Button
-                    variant="outline"
-                    size="small"
-                    onClick={handleAddRow}
-                    leftIcon={<Plus className="h-4 w-4" />}
-                    className="w-fit"
-                  >
-                    {addRowLabel}
-                  </Button>
-                </TableCell>
-              </TableRow>
-            )}
-          </TableBody>
-        </BaseTable>
-      </div>
-    </div>
-  );
-}
-
-export { type RowData } from "./useTable";

autogpt_platform/frontend/src/components/molecules/Table/helpers.ts

@@ -1,7 +0,0 @@
-export const formatColumnTitle = (key: string): string => {
-  return key.charAt(0).toUpperCase() + key.slice(1);
-};
-
-export const formatPlaceholder = (key: string): string => {
-  return `Enter ${key.toLowerCase()}`;
-};

autogpt_platform/frontend/src/components/molecules/Table/useTable.ts

@@ -1,81 +0,0 @@
-import { useState, useEffect } from "react";
-
-export type RowData = Record<string, string>;
-
-interface UseTableOptions {
-  columns: string[];
-  defaultValues?: RowData[];
-  onChange?: (rows: RowData[]) => void;
-}
-
-export function useTable({
-  columns,
-  defaultValues,
-  onChange,
-}: UseTableOptions) {
-  const createEmptyRow = (): RowData => {
-    const emptyRow: RowData = {};
-    columns.forEach((column) => {
-      emptyRow[column] = "";
-    });
-    return emptyRow;
-  };
-
-  const [rows, setRows] = useState<RowData[]>(() => {
-    if (defaultValues && defaultValues.length > 0) {
-      return defaultValues;
-    }
-    return [];
-  });
-
-  useEffect(() => {
-    if (defaultValues !== undefined) {
-      setRows(defaultValues);
-    }
-  }, [defaultValues]);
-
-  const updateRows = (newRows: RowData[]) => {
-    setRows(newRows);
-    onChange?.(newRows);
-  };
-
-  const handleAddRow = () => {
-    const newRows = [...rows, createEmptyRow()];
-    updateRows(newRows);
-  };
-
-  const handleDeleteRow = (rowIndex: number) => {
-    const newRows = rows.filter((_, index) => index !== rowIndex);
-    updateRows(newRows);
-  };
-
-  const handleCellChange = (
-    rowIndex: number,
-    columnKey: string,
-    value: string,
-  ) => {
-    const newRows = rows.map((row, index) => {
-      if (index === rowIndex) {
-        return {
-          ...row,
-          [columnKey]: value,
-        };
-      }
-      return row;
-    });
-    updateRows(newRows);
-  };
-
-  const clearAll = () => {
-    updateRows([]);
-  };
-
-  return {
-    rows,
-    handleAddRow,
-    handleDeleteRow,
-    handleCellChange,
-    clearAll,
-    createEmptyRow,
-  };
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/FormRenderer.tsx

@@ -30,8 +30,6 @@ export const FormRenderer = ({
     return generateUiSchemaForCustomFields(preprocessedSchema, uiSchema);
   }, [preprocessedSchema, uiSchema]);
 
-  console.log("preprocessedSchema", preprocessedSchema);
-
   return (
     <div className={"mb-6 mt-4"}>
       <Form

autogpt_platform/frontend/src/components/renderers/InputRenderer/base/anyof/AnyOfField.tsx

@@ -5,14 +5,19 @@ import { useAnyOfField } from "./useAnyOfField";
 import { getHandleId, updateUiOption } from "../../helpers";
 import { useEdgeStore } from "@/app/(platform)/build/stores/edgeStore";
 import { ANY_OF_FLAG } from "../../constants";
-import { findCustomFieldId } from "../../registry";
 
 export const AnyOfField = (props: FieldProps) => {
   const { registry, schema } = props;
   const { fields } = registry;
   const { SchemaField: _SchemaField } = fields;
   const { nodeId } = registry.formContext;
+
   const { isInputConnected } = useEdgeStore();
+
+  const uiOptions = getUiOptions(props.uiSchema, props.globalUiOptions);
+
+  const Widget = getWidget({ type: "string" }, "select", registry.widgets);
+
   const {
     handleOptionChange,
     enumOptions,
@@ -21,15 +26,6 @@ export const AnyOfField = (props: FieldProps) => {
     field_id,
   } = useAnyOfField(props);
 
-  const parentCustomFieldId = findCustomFieldId(schema);
-  if (parentCustomFieldId) {
-    return null;
-  }
-
-  const uiOptions = getUiOptions(props.uiSchema, props.globalUiOptions);
-
-  const Widget = getWidget({ type: "string" }, "select", registry.widgets);
-
   const handleId = getHandleId({
     uiOptions,
     id: field_id + ANY_OF_FLAG,
@@ -44,21 +40,12 @@ export const AnyOfField = (props: FieldProps) => {
 
   const isHandleConnected = isInputConnected(nodeId, handleId);
 
-  // Now anyOf can render - custom fields if the option schema matches a custom field
-  const optionCustomFieldId = optionSchema
-    ? findCustomFieldId(optionSchema)
-    : null;
-
-  const optionUiSchema = optionCustomFieldId
-    ? { ...updatedUiSchema, "ui:field": optionCustomFieldId }
-    : updatedUiSchema;
-
   const optionsSchemaField =
     (optionSchema && optionSchema.type !== "null" && (
       <_SchemaField
         {...props}
         schema={optionSchema}
-        uiSchema={optionUiSchema}
+        uiSchema={updatedUiSchema}
       />
     )) ||
     null;

autogpt_platform/frontend/src/components/renderers/InputRenderer/base/standard/widgets/TextInput/TextInputExpanderModal.tsx

@@ -17,7 +17,6 @@ interface InputExpanderModalProps {
   defaultValue: string;
   description?: string;
   placeholder?: string;
-  inputType?: "text" | "json";
 }
 
 export const InputExpanderModal: FC<InputExpanderModalProps> = ({
@@ -28,7 +27,6 @@ export const InputExpanderModal: FC<InputExpanderModalProps> = ({
   defaultValue,
   description,
   placeholder,
-  inputType = "text",
 }) => {
   const [tempValue, setTempValue] = useState(defaultValue);
   const [isCopied, setIsCopied] = useState(false);
@@ -80,10 +78,7 @@ export const InputExpanderModal: FC<InputExpanderModalProps> = ({
             hideLabel
             id="input-expander-modal"
             value={tempValue}
-            className={cn(
-              "!min-h-[300px] rounded-2xlarge",
-              inputType === "json" && "font-mono text-sm",
-            )}
+            className="!min-h-[300px] rounded-2xlarge"
             onChange={(e) => setTempValue(e.target.value)}
             placeholder={placeholder || "Enter text..."}
             autoFocus

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/CredentialField/CredentialField.tsx

@@ -88,8 +88,6 @@ export const CredentialsField = (props: FieldProps) => {
         showTitle={false}
         readOnly={formContext?.readOnly}
         isOptional={!isRequired}
-        className="w-full"
-        variant="node"
       />
 
       {/* Optional credentials toggle - only show in builder canvas, not run dialogs */}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/JsonTextField/JsonTextField.tsx

@@ -1,124 +0,0 @@
-"use client";
-
-import { FieldProps, getTemplate, getUiOptions } from "@rjsf/utils";
-import { Input } from "@/components/atoms/Input/Input";
-import { Button } from "@/components/atoms/Button/Button";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from "@/components/atoms/Tooltip/BaseTooltip";
-import { ArrowsOutIcon } from "@phosphor-icons/react";
-import { InputExpanderModal } from "../../base/standard/widgets/TextInput/TextInputExpanderModal";
-import { getHandleId, updateUiOption } from "../../helpers";
-import { useJsonTextField } from "./useJsonTextField";
-import { getPlaceholder } from "./helpers";
-
-export const JsonTextField = (props: FieldProps) => {
-  const {
-    formData,
-    onChange,
-    schema,
-    registry,
-    uiSchema,
-    required,
-    name,
-    fieldPathId,
-  } = props;
-
-  const uiOptions = getUiOptions(uiSchema);
-
-  const TitleFieldTemplate = getTemplate(
-    "TitleFieldTemplate",
-    registry,
-    uiOptions,
-  );
-
-  const fieldId = fieldPathId?.$id ?? props.id ?? "json-field";
-
-  const handleId = getHandleId({
-    uiOptions,
-    id: fieldId,
-    schema: schema,
-  });
-
-  const updatedUiSchema = updateUiOption(uiSchema, {
-    handleId: handleId,
-  });
-
-  const {
-    textValue,
-    isModalOpen,
-    handleChange,
-    handleModalOpen,
-    handleModalClose,
-    handleModalSave,
-  } = useJsonTextField({
-    formData,
-    onChange,
-    path: fieldPathId?.path,
-  });
-
-  const placeholder = getPlaceholder(schema);
-  const title = schema.title || name || "JSON Value";
-
-  return (
-    <div className="flex flex-col gap-2">
-      <TitleFieldTemplate
-        id={fieldId}
-        title={title}
-        required={required}
-        schema={schema}
-        uiSchema={updatedUiSchema}
-        registry={registry}
-      />
-      <div className="nodrag relative flex items-center gap-2">
-        <Input
-          id={fieldId}
-          hideLabel={true}
-          type="textarea"
-          label=""
-          size="small"
-          wrapperClassName="mb-0 flex-1 "
-          value={textValue}
-          onChange={handleChange}
-          placeholder={placeholder}
-          required={required}
-          disabled={props.disabled}
-          className="min-h-[60px] pr-8 font-mono text-xs"
-        />
-
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button
-              variant="ghost"
-              size="icon"
-              onClick={handleModalOpen}
-              type="button"
-              className="p-1"
-            >
-              <ArrowsOutIcon className="size-4" />
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent>Expand input</TooltipContent>
-        </Tooltip>
-      </div>
-      {schema.description && (
-        <span className="text-xs text-gray-500">{schema.description}</span>
-      )}
-
-      <InputExpanderModal
-        isOpen={isModalOpen}
-        onClose={handleModalClose}
-        onSave={handleModalSave}
-        title={`Edit ${title}`}
-        description={schema.description || "Enter valid JSON"}
-        defaultValue={textValue}
-        placeholder={placeholder}
-        inputType="json"
-      />
-    </div>
-  );
-};
-
-export default JsonTextField;

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/JsonTextField/helpers.ts

@@ -1,67 +0,0 @@
-import { RJSFSchema } from "@rjsf/utils";
-
-/**
- * Converts form data to a JSON string for display
- * @param formData - The data to stringify
- * @returns JSON string or empty string if data is null/undefined
- */
-export function stringifyFormData(formData: unknown): string {
-  if (formData === undefined || formData === null) {
-    return "";
-  }
-  try {
-    return JSON.stringify(formData, null, 2);
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Parses a JSON string into an object/array
- * @param value - The JSON string to parse
- * @returns Parsed value or undefined if parsing fails or empty
- */
-export function parseJsonValue(value: string): unknown | undefined {
-  const trimmed = value.trim();
-  if (trimmed === "") {
-    return undefined;
-  }
-
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Gets the appropriate placeholder text based on schema type
- * @param schema - The JSON schema
- * @returns Placeholder string
- */
-export function getPlaceholder(schema: RJSFSchema): string {
-  if (schema.type === "array") {
-    return '["item1", "item2"] or [{"key": "value"}]';
-  }
-  if (schema.type === "object") {
-    return '{"key": "value"}';
-  }
-  return "Enter JSON value...";
-}
-
-/**
- * Checks if a JSON string is valid
- * @param value - The JSON string to validate
- * @returns true if valid JSON, false otherwise
- */
-export function isValidJson(value: string): boolean {
-  if (value.trim() === "") {
-    return true; // Empty is considered valid (will be undefined)
-  }
-  try {
-    JSON.parse(value);
-    return true;
-  } catch {
-    return false;
-  }
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/JsonTextField/useJsonTextField.ts

@@ -1,107 +0,0 @@
-import { useState, useEffect, useCallback } from "react";
-import { FieldProps } from "@rjsf/utils";
-import { stringifyFormData, parseJsonValue, isValidJson } from "./helpers";
-
-type FieldOnChange = FieldProps["onChange"];
-type FieldPathId = FieldProps["fieldPathId"];
-
-interface UseJsonTextFieldOptions {
-  formData: unknown;
-  onChange: FieldOnChange;
-  path?: FieldPathId["path"];
-}
-
-interface UseJsonTextFieldReturn {
-  textValue: string;
-  isModalOpen: boolean;
-  hasError: boolean;
-  handleChange: (
-    e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
-  ) => void;
-  handleModalOpen: () => void;
-  handleModalClose: () => void;
-  handleModalSave: (value: string) => void;
-}
-
-/**
- * Custom hook for managing JSON text field state and handlers
- */
-export function useJsonTextField({
-  formData,
-  onChange,
-  path,
-}: UseJsonTextFieldOptions): UseJsonTextFieldReturn {
-  const [textValue, setTextValue] = useState(() => stringifyFormData(formData));
-  const [isModalOpen, setIsModalOpen] = useState(false);
-  const [hasError, setHasError] = useState(false);
-
-  // Update text value when formData changes externally
-  useEffect(() => {
-    const newValue = stringifyFormData(formData);
-    setTextValue(newValue);
-    setHasError(false);
-  }, [formData]);
-
-  const handleChange = useCallback(
-    (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
-      const value = e.target.value;
-      setTextValue(value);
-
-      // Validate JSON and update error state
-      const valid = isValidJson(value);
-      setHasError(!valid);
-
-      // Try to parse and update formData
-      if (value.trim() === "") {
-        onChange(undefined, path ?? []);
-        return;
-      }
-
-      const parsed = parseJsonValue(value);
-      if (parsed !== undefined) {
-        onChange(parsed, path ?? []);
-      }
-    },
-    [onChange, path],
-  );
-
-  const handleModalOpen = useCallback(() => {
-    setIsModalOpen(true);
-  }, []);
-
-  const handleModalClose = useCallback(() => {
-    setIsModalOpen(false);
-  }, []);
-
-  const handleModalSave = useCallback(
-    (value: string) => {
-      setTextValue(value);
-      setIsModalOpen(false);
-
-      // Validate and update
-      const valid = isValidJson(value);
-      setHasError(!valid);
-
-      if (value.trim() === "") {
-        onChange(undefined, path ?? []);
-        return;
-      }
-
-      const parsed = parseJsonValue(value);
-      if (parsed !== undefined) {
-        onChange(parsed, path ?? []);
-      }
-    },
-    [onChange, path],
-  );
-
-  return {
-    textValue,
-    isModalOpen,
-    hasError,
-    handleChange,
-    handleModalOpen,
-    handleModalClose,
-    handleModalSave,
-  };
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/MultiSelectField/MultiSelectField.tsx

@@ -1,57 +0,0 @@
-import React from "react";
-import { FieldProps, getUiOptions } from "@rjsf/utils";
-import { BlockIOObjectSubSchema } from "@/lib/autogpt-server-api/types";
-import {
-  MultiSelector,
-  MultiSelectorContent,
-  MultiSelectorInput,
-  MultiSelectorItem,
-  MultiSelectorList,
-  MultiSelectorTrigger,
-} from "@/components/__legacy__/ui/multiselect";
-import { cn } from "@/lib/utils";
-import { useMultiSelectField } from "./useMultiSelectField";
-
-export const MultiSelectField = (props: FieldProps) => {
-  const { schema, formData, onChange, fieldPathId } = props;
-  const uiOptions = getUiOptions(props.uiSchema);
-
-  const { optionSchema, options, selection, createChangeHandler } =
-    useMultiSelectField({
-      schema: schema as BlockIOObjectSubSchema,
-      formData,
-    });
-
-  const handleValuesChange = createChangeHandler(onChange, fieldPathId);
-
-  const displayName = schema.title || "options";
-
-  return (
-    <div className={cn("flex flex-col", uiOptions.className)}>
-      <MultiSelector
-        className="nodrag"
-        values={selection}
-        onValuesChange={handleValuesChange}
-      >
-        <MultiSelectorTrigger className="rounded-3xl border border-zinc-200 bg-white px-2 shadow-none">
-          <MultiSelectorInput
-            placeholder={
-              (schema as any).placeholder ?? `Select ${displayName}...`
-            }
-          />
-        </MultiSelectorTrigger>
-        <MultiSelectorContent className="nowheel">
-          <MultiSelectorList>
-            {options
-              .map((key) => ({ ...optionSchema[key], key }))
-              .map(({ key, title, description }) => (
-                <MultiSelectorItem key={key} value={key} title={description}>
-                  {title ?? key}
-                </MultiSelectorItem>
-              ))}
-          </MultiSelectorList>
-        </MultiSelectorContent>
-      </MultiSelector>
-    </div>
-  );
-};

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/MultiSelectField/index.ts

@@ -1 +0,0 @@
-export { MultiSelectField } from "./MultiSelectField";

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/MultiSelectField/useMultiSelectField.ts

@@ -1,65 +0,0 @@
-import { FieldProps } from "@rjsf/utils";
-import { BlockIOObjectSubSchema } from "@/lib/autogpt-server-api/types";
-
-type FormData = Record<string, boolean> | null | undefined;
-
-interface UseMultiSelectFieldOptions {
-  schema: BlockIOObjectSubSchema;
-  formData: FormData;
-}
-
-export function useMultiSelectField({
-  schema,
-  formData,
-}: UseMultiSelectFieldOptions) {
-  const getOptionSchema = (): Record<string, BlockIOObjectSubSchema> => {
-    if (schema.properties) {
-      return schema.properties as Record<string, BlockIOObjectSubSchema>;
-    }
-    if (
-      "anyOf" in schema &&
-      Array.isArray(schema.anyOf) &&
-      schema.anyOf.length > 0 &&
-      "properties" in schema.anyOf[0]
-    ) {
-      return (schema.anyOf[0] as BlockIOObjectSubSchema).properties as Record<
-        string,
-        BlockIOObjectSubSchema
-      >;
-    }
-    return {};
-  };
-
-  const optionSchema = getOptionSchema();
-  const options = Object.keys(optionSchema);
-
-  const getSelection = (): string[] => {
-    if (!formData || typeof formData !== "object") {
-      return [];
-    }
-    return Object.entries(formData)
-      .filter(([_, value]) => value === true)
-      .map(([key]) => key);
-  };
-
-  const selection = getSelection();
-
-  const createChangeHandler =
-    (
-      onChange: FieldProps["onChange"],
-      fieldPathId: FieldProps["fieldPathId"],
-    ) =>
-    (values: string[]) => {
-      const newValue = Object.fromEntries(
-        options.map((opt) => [opt, values.includes(opt)]),
-      );
-      onChange(newValue, fieldPathId?.path);
-    };
-
-  return {
-    optionSchema,
-    options,
-    selection,
-    createChangeHandler,
-  };
-}

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/TableField/TableField.tsx

@@ -1,52 +0,0 @@
-import { descriptionId, FieldProps, getTemplate, titleId } from "@rjsf/utils";
-import { Table, RowData } from "@/components/molecules/Table/Table";
-import { useMemo } from "react";
-
-export const TableField = (props: FieldProps) => {
-  const { schema, formData, onChange, fieldPathId, registry, uiSchema } = props;
-
-  const itemSchema = schema.items as any;
-  const properties = itemSchema?.properties || {};
-
-  const columns: string[] = useMemo(() => {
-    return Object.keys(properties);
-  }, [properties]);
-
-  const handleChange = (rows: RowData[]) => {
-    onChange(rows, fieldPathId?.path.slice(0, -1));
-  };
-
-  const TitleFieldTemplate = getTemplate("TitleFieldTemplate", registry);
-  const DescriptionFieldTemplate = getTemplate(
-    "DescriptionFieldTemplate",
-    registry,
-  );
-
-  return (
-    <div className="flex flex-col gap-2">
-      <TitleFieldTemplate
-        id={titleId(fieldPathId)}
-        title={schema.title || ""}
-        required={true}
-        schema={schema}
-        uiSchema={uiSchema}
-        registry={registry}
-      />
-      <DescriptionFieldTemplate
-        id={descriptionId(fieldPathId)}
-        description={schema.description || ""}
-        schema={schema}
-        registry={registry}
-      />
-
-      <Table
-        columns={columns}
-        defaultValues={formData}
-        onChange={handleChange}
-        allowAddRow={true}
-        allowDeleteRow={true}
-        addRowLabel="Add row"
-      />
-    </div>
-  );
-};

autogpt_platform/frontend/src/components/renderers/InputRenderer/custom/custom-registry.ts

@@ -1,10 +1,6 @@
 import { FieldProps, RJSFSchema, RegistryFieldsType } from "@rjsf/utils";
 import { CredentialsField } from "./CredentialField/CredentialField";
 import { GoogleDrivePickerField } from "./GoogleDrivePickerField/GoogleDrivePickerField";
-import { JsonTextField } from "./JsonTextField/JsonTextField";
-import { MultiSelectField } from "./MultiSelectField/MultiSelectField";
-import { isMultiSelectSchema } from "../utils/schema-utils";
-import { TableField } from "./TableField/TableField";
 
 export interface CustomFieldDefinition {
   id: string;
@@ -12,9 +8,6 @@ export interface CustomFieldDefinition {
   component: (props: FieldProps<any, RJSFSchema, any>) => JSX.Element | null;
 }
 
-/** Field ID for JsonTextField - used to render nested complex types as text input */
-export const JSON_TEXT_FIELD_ID = "custom/json_text_field";
-
 export const CUSTOM_FIELDS: CustomFieldDefinition[] = [
   {
     id: "custom/credential_field",
@@ -37,28 +30,6 @@ export const CUSTOM_FIELDS: CustomFieldDefinition[] = [
     },
     component: GoogleDrivePickerField,
   },
-  {
-    id: "custom/json_text_field",
-    // Not matched by schema - assigned via uiSchema for nested complex types
-    matcher: () => false,
-    component: JsonTextField,
-  },
-  {
-    id: "custom/multi_select_field",
-    matcher: isMultiSelectSchema,
-    component: MultiSelectField,
-  },
-  {
-    id: "custom/table_field",
-    matcher: (schema: any) => {
-      return (
-        schema.type === "array" &&
-        "format" in schema &&
-        schema.format === "table"
-      );
-    },
-    component: TableField,
-  },
 ];
 
 export function findCustomFieldId(schema: any): string | null {

autogpt_platform/frontend/src/components/renderers/InputRenderer/utils/generate-ui-schema.ts

@@ -1,46 +1,19 @@
 import { RJSFSchema, UiSchema } from "@rjsf/utils";
-import {
-  findCustomFieldId,
-  JSON_TEXT_FIELD_ID,
-} from "../custom/custom-registry";
-
-function isComplexType(schema: RJSFSchema): boolean {
-  return schema.type === "object" || schema.type === "array";
-}
-
-function hasComplexAnyOfOptions(schema: RJSFSchema): boolean {
-  const options = schema.anyOf || schema.oneOf;
-  if (!Array.isArray(options)) return false;
-  return options.some(
-    (opt: any) =>
-      opt &&
-      typeof opt === "object" &&
-      (opt.type === "object" || opt.type === "array"),
-  );
-}
+import { findCustomFieldId } from "../custom/custom-registry";
 
 /**
  * Generates uiSchema with ui:field settings for custom fields based on schema matchers.
  * This is the standard RJSF way to route fields to custom components.
- *
- * Nested complex types (arrays/objects inside arrays/objects) are rendered as JsonTextField
- * to avoid deeply nested form UIs. Users can enter raw JSON for these fields.
- *
- * @param schema - The JSON schema
- * @param existingUiSchema - Existing uiSchema to merge with
- * @param insideComplexType - Whether we're already inside a complex type (object/array)
  */
 export function generateUiSchemaForCustomFields(
   schema: RJSFSchema,
   existingUiSchema: UiSchema = {},
-  insideComplexType: boolean = false,
 ): UiSchema {
   const uiSchema: UiSchema = { ...existingUiSchema };
 
   if (schema.properties) {
     for (const [key, propSchema] of Object.entries(schema.properties)) {
       if (propSchema && typeof propSchema === "object") {
-        // First check for custom field matchers (credentials, google drive, etc.)
         const customFieldId = findCustomFieldId(propSchema);
 
         if (customFieldId) {
@@ -48,33 +21,8 @@ export function generateUiSchemaForCustomFields(
             ...(uiSchema[key] as object),
             "ui:field": customFieldId,
           };
-          // Skip further processing for custom fields
-          continue;
         }
 
-        // Handle nested complex types - render as JsonTextField
-        if (insideComplexType && isComplexType(propSchema as RJSFSchema)) {
-          uiSchema[key] = {
-            ...(uiSchema[key] as object),
-            "ui:field": JSON_TEXT_FIELD_ID,
-          };
-          // Don't recurse further - this field is now a text input
-          continue;
-        }
-
-        // Handle anyOf/oneOf inside complex types
-        if (
-          insideComplexType &&
-          hasComplexAnyOfOptions(propSchema as RJSFSchema)
-        ) {
-          uiSchema[key] = {
-            ...(uiSchema[key] as object),
-            "ui:field": JSON_TEXT_FIELD_ID,
-          };
-          continue;
-        }
-
-        // Recurse into object properties
         if (
           propSchema.type === "object" &&
           propSchema.properties &&
@@ -83,7 +31,6 @@ export function generateUiSchemaForCustomFields(
           const nestedUiSchema = generateUiSchemaForCustomFields(
             propSchema as RJSFSchema,
             (uiSchema[key] as UiSchema) || {},
-            true, // Now inside a complex type
           );
           uiSchema[key] = {
             ...(uiSchema[key] as object),
@@ -91,11 +38,9 @@ export function generateUiSchemaForCustomFields(
           };
         }
 
-        // Handle arrays
         if (propSchema.type === "array" && propSchema.items) {
           const itemsSchema = propSchema.items as RJSFSchema;
           if (itemsSchema && typeof itemsSchema === "object") {
-            // Check for custom field on array items
             const itemsCustomFieldId = findCustomFieldId(itemsSchema);
             if (itemsCustomFieldId) {
               uiSchema[key] = {
@@ -104,28 +49,10 @@ export function generateUiSchemaForCustomFields(
                   "ui:field": itemsCustomFieldId,
                 },
               };
-            } else if (isComplexType(itemsSchema)) {
-              // Array items that are complex types become JsonTextField
-              uiSchema[key] = {
-                ...(uiSchema[key] as object),
-                items: {
-                  "ui:field": JSON_TEXT_FIELD_ID,
-                },
-              };
-            } else if (hasComplexAnyOfOptions(itemsSchema)) {
-              // Array items with anyOf containing complex types become JsonTextField
-              uiSchema[key] = {
-                ...(uiSchema[key] as object),
-                items: {
-                  "ui:field": JSON_TEXT_FIELD_ID,
-                },
-              };
             } else if (itemsSchema.properties) {
-              // Recurse into object items (but they're now inside a complex type)
               const itemsUiSchema = generateUiSchemaForCustomFields(
                 itemsSchema,
                 ((uiSchema[key] as UiSchema)?.items as UiSchema) || {},
-                true, // Inside complex type (array)
               );
               if (Object.keys(itemsUiSchema).length > 0) {
                 uiSchema[key] = {
@@ -136,61 +63,6 @@ export function generateUiSchemaForCustomFields(
             }
           }
         }
-
-        // Handle anyOf/oneOf at root level - process complex options
-        if (!insideComplexType) {
-          const anyOfOptions = propSchema.anyOf || propSchema.oneOf;
-
-          if (Array.isArray(anyOfOptions)) {
-            for (let i = 0; i < anyOfOptions.length; i++) {
-              const option = anyOfOptions[i] as RJSFSchema;
-              if (option && typeof option === "object") {
-                // Handle anyOf array options with complex items
-                if (option.type === "array" && option.items) {
-                  const itemsSchema = option.items as RJSFSchema;
-                  if (itemsSchema && typeof itemsSchema === "object") {
-                    // Array items that are complex types become JsonTextField
-                    if (isComplexType(itemsSchema)) {
-                      uiSchema[key] = {
-                        ...(uiSchema[key] as object),
-                        items: {
-                          "ui:field": JSON_TEXT_FIELD_ID,
-                        },
-                      };
-                    } else if (hasComplexAnyOfOptions(itemsSchema)) {
-                      uiSchema[key] = {
-                        ...(uiSchema[key] as object),
-                        items: {
-                          "ui:field": JSON_TEXT_FIELD_ID,
-                        },
-                      };
-                    }
-                  }
-                }
-
-                // Recurse into anyOf object options with properties
-                if (
-                  option.type === "object" &&
-                  option.properties &&
-                  typeof option.properties === "object"
-                ) {
-                  const optionUiSchema = generateUiSchemaForCustomFields(
-                    option,
-                    {},
-                    true, // Inside complex type (anyOf object option)
-                  );
-                  if (Object.keys(optionUiSchema).length > 0) {
-                    // Store under the property key - RJSF will apply it
-                    uiSchema[key] = {
-                      ...(uiSchema[key] as object),
-                      ...optionUiSchema,
-                    };
-                  }
-                }
-              }
-            }
-          }
-        }
       }
     }
   }

autogpt_platform/frontend/src/components/renderers/InputRenderer/utils/schema-utils.ts

@@ -1,11 +1,7 @@
 import { getUiOptions, RJSFSchema, UiSchema } from "@rjsf/utils";
 
 export function isAnyOfSchema(schema: RJSFSchema | undefined): boolean {
-  return (
-    Array.isArray(schema?.anyOf) &&
-    schema!.anyOf.length > 0 &&
-    schema?.enum === undefined
-  );
+  return Array.isArray(schema?.anyOf) && schema!.anyOf.length > 0;
 }
 
 export const isAnyOfChild = (
@@ -37,21 +33,3 @@ export function isOptionalType(schema: RJSFSchema | undefined): {
 export function isAnyOfSelector(name: string) {
   return name.includes("anyof_select");
 }
-
-export function isMultiSelectSchema(schema: RJSFSchema | undefined): boolean {
-  if (typeof schema !== "object" || schema === null) {
-    return false;
-  }
-
-  if ("anyOf" in schema || "oneOf" in schema) {
-    return false;
-  }
-
-  return !!(
-    schema.type === "object" &&
-    schema.properties &&
-    Object.values(schema.properties).every(
-      (prop: any) => prop.type === "boolean",
-    )
-  );
-}