AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
refactor(backend): optimize find_block response size by removing raw JSON schemas (#12020)
Swiftyab0b537cc7d1
diff --git a/autogpt_platform/CLAUDE.md b/autogpt_platform/CLAUDE.mdindex 62adbdaefa..021b7c27e4 100644--- a/autogpt_platform/CLAUDE.md+++ b/autogpt_platform/CLAUDE.md@@ -45,6 +45,11 @@ AutoGPT Platform is a monorepo containing:- Backend/Frontend services use YAML anchors for consistent configuration- Supabase services (`db/docker/docker-compose.yml`) follow the same pattern+### Branching Strategy++- **`dev`** is the main development branch. All PRs should target `dev`.+- **`master`** is the production branch. Only used for production releases.+### Creating Pull Requests- Create the PR against the `dev` branch of the repository.diff --git a/autogpt_platform/backend/backend/api/features/chat/routes.py b/autogpt_platform/backend/backend/api/features/chat/routes.pyindex c6f37569b7..0d8b12b0b7 100644--- a/autogpt_platform/backend/backend/api/features/chat/routes.py+++ b/autogpt_platform/backend/backend/api/features/chat/routes.py@@ -24,6 +24,7 @@ from .tools.models import (AgentPreviewResponse,AgentSavedResponse,AgentsFoundResponse,+ BlockDetailsResponse,BlockListResponse,BlockOutputResponse,ClarificationNeededResponse,@@ -971,6 +972,7 @@ ToolResponseUnion = (| AgentSavedResponse| ClarificationNeededResponse| BlockListResponse+ | BlockDetailsResponse| BlockOutputResponse| DocSearchResultsResponse| DocPageResponsediff --git a/autogpt_platform/backend/backend/api/features/chat/tools/find_block.py b/autogpt_platform/backend/backend/api/features/chat/tools/find_block.pyindex 6a8cfa9bbc..55b1c0d510 100644--- a/autogpt_platform/backend/backend/api/features/chat/tools/find_block.py+++ b/autogpt_platform/backend/backend/api/features/chat/tools/find_block.py@@ -7,7 +7,6 @@ from backend.api.features.chat.model import ChatSessionfrom backend.api.features.chat.tools.base import BaseTool, ToolResponseBasefrom backend.api.features.chat.tools.models import (BlockInfoSummary,- BlockInputFieldInfo,BlockListResponse,ErrorResponse,NoResultsResponse,@@ -55,7 +54,8 @@ class FindBlockTool(BaseTool):"Blocks are reusable components that perform specific tasks like ""sending emails, making API calls, processing text, etc. ""IMPORTANT: Use this tool FIRST to get the block's 'id' before calling run_block. "- "The response includes each block's id, required_inputs, and input_schema."+ "The response includes each block's id, name, and description. "+ "Call run_block with the block's id **with no inputs** to see detailed inputs/outputs and execute it.")@property@@ -124,7 +124,7 @@ class FindBlockTool(BaseTool):session_id=session_id,)- # Enrich results with full block information+ # Enrich results with block informationblocks: list[BlockInfoSummary] = []for result in results:block_id = result["content_id"]@@ -141,65 +141,11 @@ class FindBlockTool(BaseTool):):continue- # Get input/output schemas- input_schema = {}- output_schema = {}- try:- input_schema = block.input_schema.jsonschema()- except Exception as e:- logger.debug(- "Failed to generate input schema for block %s: %s",- block_id,- e,- )- try:- output_schema = block.output_schema.jsonschema()- except Exception as e:- logger.debug(- "Failed to generate output schema for block %s: %s",- block_id,- e,- )-- # Get categories from block instance- categories = []- if hasattr(block, "categories") and block.categories:- categories = [cat.value for cat in block.categories]-- # Extract required inputs for easier use- required_inputs: list[BlockInputFieldInfo] = []- if input_schema:- properties = input_schema.get("properties", {})- required_fields = set(input_schema.get("required", []))- # Get credential field names to exclude from required inputs- credentials_fields = set(- block.input_schema.get_credentials_fields().keys()- )-- for field_name, field_schema in properties.items():- # Skip credential fields - they're handled separately- if field_name in credentials_fields:- continue-- required_inputs.append(- BlockInputFieldInfo(- name=field_name,- type=field_schema.get("type", "string"),- description=field_schema.get("description", ""),- required=field_name in required_fields,- default=field_schema.get("default"),- )- )-blocks.append(BlockInfoSummary(id=block_id,name=block.name,description=block.description or "",- categories=categories,- input_schema=input_schema,- output_schema=output_schema,- required_inputs=required_inputs,))@@ -228,8 +174,7 @@ class FindBlockTool(BaseTool):return BlockListResponse(message=(f"Found {len(blocks)} block(s) matching '{query}'. "- "To execute a block, use run_block with the block's 'id' field "- "and provide 'input_data' matching the block's input_schema."+ "To see a block's inputs/outputs and execute it, use run_block with the block's 'id' - providing no inputs."),blocks=blocks,count=len(blocks),diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/find_block_test.py b/autogpt_platform/backend/backend/api/features/chat/tools/find_block_test.pyindex d567a89bbe..44606f81c3 100644--- a/autogpt_platform/backend/backend/api/features/chat/tools/find_block_test.py+++ b/autogpt_platform/backend/backend/api/features/chat/tools/find_block_test.py@@ -18,7 +18,13 @@ _TEST_USER_ID = "test-user-find-block"def make_mock_block(- block_id: str, name: str, block_type: BlockType, disabled: bool = False+ block_id: str,+ name: str,+ block_type: BlockType,+ disabled: bool = False,+ input_schema: dict | None = None,+ output_schema: dict | None = None,+ credentials_fields: dict | None = None,):"""Create a mock block for testing."""mock = MagicMock()@@ -28,10 +34,13 @@ def make_mock_block(mock.block_type = block_typemock.disabled = disabledmock.input_schema = MagicMock()- mock.input_schema.jsonschema.return_value = {"properties": {}, "required": []}- mock.input_schema.get_credentials_fields.return_value = {}+ mock.input_schema.jsonschema.return_value = input_schema or {+ "properties": {},+ "required": [],+ }+ mock.input_schema.get_credentials_fields.return_value = credentials_fields or {}mock.output_schema = MagicMock()- mock.output_schema.jsonschema.return_value = {}+ mock.output_schema.jsonschema.return_value = output_schema or {}mock.categories = []return mock@@ -137,3 +146,241 @@ class TestFindBlockFiltering:assert isinstance(response, BlockListResponse)assert len(response.blocks) == 1assert response.blocks[0].id == "normal-block-id"++ @pytest.mark.asyncio(loop_scope="session")+ async def test_response_size_average_chars_per_block(self):+ """Measure average chars per block in the serialized response."""+ session = make_session(user_id=_TEST_USER_ID)++ # Realistic block definitions modeled after real blocks+ block_defs = [+ {+ "id": "http-block-id",+ "name": "Send Web Request",+ "input_schema": {+ "properties": {+ "url": {+ "type": "string",+ "description": "The URL to send the request to",+ },+ "method": {+ "type": "string",+ "description": "The HTTP method to use",+ },+ "headers": {+ "type": "object",+ "description": "Headers to include in the request",+ },+ "json_format": {+ "type": "boolean",+ "description": "If true, send the body as JSON",+ },+ "body": {+ "type": "object",+ "description": "Form/JSON body payload",+ },+ "credentials": {+ "type": "object",+ "description": "HTTP credentials",+ },+ },+ "required": ["url", "method"],+ },+ "output_schema": {+ "properties": {+ "response": {+ "type": "object",+ "description": "The response from the server",+ },+ "client_error": {+ "type": "object",+ "description": "Errors on 4xx status codes",+ },+ "server_error": {+ "type": "object",+ "description": "Errors on 5xx status codes",+ },+ "error": {+ "type": "string",+ "description": "Errors for all other exceptions",+ },+ },+ },+ "credentials_fields": {"credentials": True},+ },+ {+ "id": "email-block-id",+ "name": "Send Email",+ "input_schema": {+ "properties": {+ "to_email": {+ "type": "string",+ "description": "Recipient email address",+ },+ "subject": {+ "type": "string",+ "description": "Subject of the email",+ },+ "body": {+ "type": "string",+ "description": "Body of the email",+ },+ "config": {+ "type": "object",+ "description": "SMTP Config",+ },+ "credentials": {+ "type": "object",+ "description": "SMTP credentials",+ },+ },+ "required": ["to_email", "subject", "body", "credentials"],+ },+ "output_schema": {+ "properties": {+ "status": {+ "type": "string",+ "description": "Status of the email sending operation",+ },+ "error": {+ "type": "string",+ "description": "Error message if sending failed",+ },+ },+ },+ "credentials_fields": {"credentials": True},+ },+ {+ "id": "claude-code-block-id",+ "name": "Claude Code",+ "input_schema": {+ "properties": {+ "e2b_credentials": {+ "type": "object",+ "description": "API key for E2B platform",+ },+ "anthropic_credentials": {+ "type": "object",+ "description": "API key for Anthropic",+ },+ "prompt": {+ "type": "string",+ "description": "Task or instruction for Claude Code",+ },+ "timeout": {+ "type": "integer",+ "description": "Sandbox timeout in seconds",+ },+ "setup_commands": {+ "type": "array",+ "description": "Shell commands to run before execution",+ },+ "working_directory": {+ "type": "string",+ "description": "Working directory for Claude Code",+ },+ "session_id": {+ "type": "string",+ "description": "Session ID to resume a conversation",+ },+ "sandbox_id": {+ "type": "string",+ "description": "Sandbox ID to reconnect to",+ },+ "conversation_history": {+ "type": "string",+ "description": "Previous conversation history",+ },+ "dispose_sandbox": {+ "type": "boolean",+ "description": "Whether to dispose sandbox after execution",+ },+ },+ "required": [+ "e2b_credentials",+ "anthropic_credentials",+ "prompt",+ ],+ },+ "output_schema": {+ "properties": {+ "response": {+ "type": "string",+ "description": "Output from Claude Code execution",+ },+ "files": {+ "type": "array",+ "description": "Files created/modified by Claude Code",+ },+ "conversation_history": {+ "type": "string",+ "description": "Full conversation history",+ },+ "session_id": {+ "type": "string",+ "description": "Session ID for this conversation",+ },+ "sandbox_id": {+ "type": "string",+ "description": "ID of the sandbox instance",+ },+ "error": {+ "type": "string",+ "description": "Error message if execution failed",+ },+ },+ },+ "credentials_fields": {+ "e2b_credentials": True,+ "anthropic_credentials": True,+ },+ },+ ]++ search_results = [+ {"content_id": d["id"], "score": 0.9 - i * 0.1}+ for i, d in enumerate(block_defs)+ ]+ mock_blocks = {+ d["id"]: make_mock_block(+ block_id=d["id"],+ name=d["name"],+ block_type=BlockType.STANDARD,+ input_schema=d["input_schema"],+ output_schema=d["output_schema"],+ credentials_fields=d["credentials_fields"],+ )+ for d in block_defs+ }++ with patch(+ "backend.api.features.chat.tools.find_block.unified_hybrid_search",+ new_callable=AsyncMock,+ return_value=(search_results, len(search_results)),+ ), patch(+ "backend.api.features.chat.tools.find_block.get_block",+ side_effect=lambda bid: mock_blocks.get(bid),+ ):+ tool = FindBlockTool()+ response = await tool._execute(+ user_id=_TEST_USER_ID, session=session, query="test"+ )++ assert isinstance(response, BlockListResponse)+ assert response.count == len(block_defs)++ total_chars = len(response.model_dump_json())+ avg_chars = total_chars // response.count++ # Print for visibility in test output+ print(f"\nTotal response size: {total_chars} chars")+ print(f"Number of blocks: {response.count}")+ print(f"Average chars per block: {avg_chars}")++ # The old response was ~90K for 10 blocks (~9K per block).+ # Previous optimization reduced it to ~1.5K per block (no raw JSON schemas).+ # Now with only id/name/description, we expect ~300 chars per block.+ assert avg_chars < 500, (+ f"Average chars per block ({avg_chars}) exceeds 500. "+ f"Total response: {total_chars} chars for {response.count} blocks."+ )diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/models.py b/autogpt_platform/backend/backend/api/features/chat/tools/models.pyindex 69c8c6c684..bd19d590a6 100644--- a/autogpt_platform/backend/backend/api/features/chat/tools/models.py+++ b/autogpt_platform/backend/backend/api/features/chat/tools/models.py@@ -25,6 +25,7 @@ class ResponseType(str, Enum):AGENT_SAVED = "agent_saved"CLARIFICATION_NEEDED = "clarification_needed"BLOCK_LIST = "block_list"+ BLOCK_DETAILS = "block_details"BLOCK_OUTPUT = "block_output"DOC_SEARCH_RESULTS = "doc_search_results"DOC_PAGE = "doc_page"@@ -334,13 +335,6 @@ class BlockInfoSummary(BaseModel):id: strname: strdescription: str- categories: list[str]- input_schema: dict[str, Any]- output_schema: dict[str, Any]- required_inputs: list[BlockInputFieldInfo] = Field(- default_factory=list,- description="List of required input fields for this block",- )class BlockListResponse(ToolResponseBase):@@ -350,10 +344,25 @@ class BlockListResponse(ToolResponseBase):blocks: list[BlockInfoSummary]count: intquery: str- usage_hint: str = Field(- default="To execute a block, call run_block with block_id set to the block's "- "'id' field and input_data containing the required fields from input_schema."- )+++class BlockDetails(BaseModel):+ """Detailed block information."""++ id: str+ name: str+ description: str+ inputs: dict[str, Any] = {}+ outputs: dict[str, Any] = {}+ credentials: list[CredentialsMetaInput] = []+++class BlockDetailsResponse(ToolResponseBase):+ """Response for block details (first run_block attempt)."""++ type: ResponseType = ResponseType.BLOCK_DETAILS+ block: BlockDetails+ user_authenticated: bool = Falseclass BlockOutputResponse(ToolResponseBase):diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/run_block.py b/autogpt_platform/backend/backend/api/features/chat/tools/run_block.pyindex 8c29820f8e..a55478326a 100644--- a/autogpt_platform/backend/backend/api/features/chat/tools/run_block.py+++ b/autogpt_platform/backend/backend/api/features/chat/tools/run_block.py@@ -23,8 +23,11 @@ from backend.util.exceptions import BlockErrorfrom .base import BaseToolfrom .helpers import get_inputs_from_schemafrom .models import (+ BlockDetails,+ BlockDetailsResponse,BlockOutputResponse,ErrorResponse,+ InputValidationErrorResponse,SetupInfo,SetupRequirementsResponse,ToolResponseBase,@@ -51,8 +54,8 @@ class RunBlockTool(BaseTool):"Execute a specific block with the provided input data. ""IMPORTANT: You MUST call find_block first to get the block's 'id' - ""do NOT guess or make up block IDs. "- "Use the 'id' from find_block results and provide input_data "- "matching the block's required_inputs."+ "On first attempt (without input_data), returns detailed schema showing "+ "required inputs and outputs. Then call again with proper input_data to execute.")@property@@ -67,11 +70,19 @@ class RunBlockTool(BaseTool):"NEVER guess this - always get it from find_block first."),},+ "block_name": {+ "type": "string",+ "description": (+ "The block's human-readable name from find_block results. "+ "Used for display purposes in the UI."+ ),+ },"input_data": {"type": "object","description": (- "Input values for the block. Use the 'required_inputs' field "- "from find_block to see what fields are needed."+ "Input values for the block. "+ "First call with empty {} to see the block's schema, "+ "then call again with proper values to execute."),},},@@ -156,6 +167,34 @@ class RunBlockTool(BaseTool):await self._resolve_block_credentials(user_id, block, input_data))+ # Get block schemas for details/validation+ try:+ input_schema: dict[str, Any] = block.input_schema.jsonschema()+ except Exception as e:+ logger.warning(+ "Failed to generate input schema for block %s: %s",+ block_id,+ e,+ )+ return ErrorResponse(+ message=f"Block '{block.name}' has an invalid input schema",+ error=str(e),+ session_id=session_id,+ )+ try:+ output_schema: dict[str, Any] = block.output_schema.jsonschema()+ except Exception as e:+ logger.warning(+ "Failed to generate output schema for block %s: %s",+ block_id,+ e,+ )+ return ErrorResponse(+ message=f"Block '{block.name}' has an invalid output schema",+ error=str(e),+ session_id=session_id,+ )+if missing_credentials:# Return setup requirements response with missing credentialscredentials_fields_info = block.input_schema.get_credentials_fields_info()@@ -188,6 +227,53 @@ class RunBlockTool(BaseTool):graph_version=None,)+ # Check if this is a first attempt (required inputs missing)+ # Return block details so user can see what inputs are needed+ credentials_fields = set(block.input_schema.get_credentials_fields().keys())+ required_keys = set(input_schema.get("required", []))+ required_non_credential_keys = required_keys - credentials_fields+ provided_input_keys = set(input_data.keys()) - credentials_fields++ # Check for unknown input fields+ valid_fields = (+ set(input_schema.get("properties", {}).keys()) - credentials_fields+ )+ unrecognized_fields = provided_input_keys - valid_fields+ if unrecognized_fields:+ return InputValidationErrorResponse(+ message=(+ f"Unknown input field(s) provided: {', '.join(sorted(unrecognized_fields))}. "+ f"Block was not executed. Please use the correct field names from the schema."+ ),+ session_id=session_id,+ unrecognized_fields=sorted(unrecognized_fields),+ inputs=input_schema,+ )++ # Show details when not all required non-credential inputs are provided+ if not (required_non_credential_keys <= provided_input_keys):+ # Get credentials info for the response+ credentials_meta = []+ for field_name, cred_meta in matched_credentials.items():+ credentials_meta.append(cred_meta)++ return BlockDetailsResponse(+ message=(+ f"Block '{block.name}' details. "+ "Provide input_data matching the inputs schema to execute the block."+ ),+ session_id=session_id,+ block=BlockDetails(+ id=block_id,+ name=block.name,+ description=block.description or "",+ inputs=input_schema,+ outputs=output_schema,+ credentials=credentials_meta,+ ),+ user_authenticated=True,+ )+try:# Get or create user's workspace for CoPilot file operationsworkspace = await get_or_create_workspace(user_id)diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/run_block_test.py b/autogpt_platform/backend/backend/api/features/chat/tools/run_block_test.pyindex aadc161155..55efc38479 100644--- a/autogpt_platform/backend/backend/api/features/chat/tools/run_block_test.py+++ b/autogpt_platform/backend/backend/api/features/chat/tools/run_block_test.py@@ -1,10 +1,15 @@-"""Tests for block execution guards in RunBlockTool."""+"""Tests for block execution guards and input validation in RunBlockTool."""-from unittest.mock import MagicMock, patch+from unittest.mock import AsyncMock, MagicMock, patchimport pytest-from backend.api.features.chat.tools.models import ErrorResponse+from backend.api.features.chat.tools.models import (+ BlockDetailsResponse,+ BlockOutputResponse,+ ErrorResponse,+ InputValidationErrorResponse,+)from backend.api.features.chat.tools.run_block import RunBlockToolfrom backend.blocks._base import BlockType@@ -28,6 +33,39 @@ def make_mock_block(return mock+def make_mock_block_with_schema(+ block_id: str,+ name: str,+ input_properties: dict,+ required_fields: list[str],+ output_properties: dict | None = None,+):+ """Create a mock block with a defined input/output schema for validation tests."""+ mock = MagicMock()+ mock.id = block_id+ mock.name = name+ mock.block_type = BlockType.STANDARD+ mock.disabled = False+ mock.description = f"Test block: {name}"++ input_schema = {+ "properties": input_properties,+ "required": required_fields,+ }+ mock.input_schema = MagicMock()+ mock.input_schema.jsonschema.return_value = input_schema+ mock.input_schema.get_credentials_fields_info.return_value = {}+ mock.input_schema.get_credentials_fields.return_value = {}++ output_schema = {+ "properties": output_properties or {"result": {"type": "string"}},+ }+ mock.output_schema = MagicMock()+ mock.output_schema.jsonschema.return_value = output_schema++ return mock++class TestRunBlockFiltering:"""Tests for block execution guards in RunBlockTool."""@@ -104,3 +142,221 @@ class TestRunBlockFiltering:# (may be other errors like missing credentials, but not the exclusion guard)if isinstance(response, ErrorResponse):assert "cannot be run directly in CoPilot" not in response.message+++class TestRunBlockInputValidation:+ """Tests for input field validation in RunBlockTool.++ run_block rejects unknown input field names with InputValidationErrorResponse,+ preventing silent failures where incorrect keys would be ignored and the block+ would execute with default values instead of the caller's intended values.+ """++ @pytest.mark.asyncio(loop_scope="session")+ async def test_unknown_input_fields_are_rejected(self):+ """run_block rejects unknown input fields instead of silently ignoring them.++ Scenario: The AI Text Generator block has a field called 'model' (for LLM model+ selection), but the LLM calling the tool guesses wrong and sends 'LLM_Model'+ instead. The block should reject the request and return the valid schema.+ """+ session = make_session(user_id=_TEST_USER_ID)++ mock_block = make_mock_block_with_schema(+ block_id="ai-text-gen-id",+ name="AI Text Generator",+ input_properties={+ "prompt": {"type": "string", "description": "The prompt to send"},+ "model": {+ "type": "string",+ "description": "The LLM model to use",+ "default": "gpt-4o-mini",+ },+ "sys_prompt": {+ "type": "string",+ "description": "System prompt",+ "default": "",+ },+ },+ required_fields=["prompt"],+ output_properties={"response": {"type": "string"}},+ )++ with patch(+ "backend.api.features.chat.tools.run_block.get_block",+ return_value=mock_block,+ ):+ tool = RunBlockTool()++ # Provide 'prompt' (correct) but 'LLM_Model' instead of 'model' (wrong key)+ response = await tool._execute(+ user_id=_TEST_USER_ID,+ session=session,+ block_id="ai-text-gen-id",+ input_data={+ "prompt": "Write a haiku about coding",+ "LLM_Model": "claude-opus-4-6", # WRONG KEY - should be 'model'+ },+ )++ assert isinstance(response, InputValidationErrorResponse)+ assert "LLM_Model" in response.unrecognized_fields+ assert "Block was not executed" in response.message+ assert "inputs" in response.model_dump() # valid schema included++ @pytest.mark.asyncio(loop_scope="session")+ async def test_multiple_wrong_keys_are_all_reported(self):+ """All unrecognized field names are reported in a single error response."""+ session = make_session(user_id=_TEST_USER_ID)++ mock_block = make_mock_block_with_schema(+ block_id="ai-text-gen-id",+ name="AI Text Generator",+ input_properties={+ "prompt": {"type": "string"},+ "model": {"type": "string", "default": "gpt-4o-mini"},+ "sys_prompt": {"type": "string", "default": ""},+ "retry": {"type": "integer", "default": 3},+ },+ required_fields=["prompt"],+ )++ with patch(+ "backend.api.features.chat.tools.run_block.get_block",+ return_value=mock_block,+ ):+ tool = RunBlockTool()++ response = await tool._execute(+ user_id=_TEST_USER_ID,+ session=session,+ block_id="ai-text-gen-id",+ input_data={+ "prompt": "Hello", # correct+ "llm_model": "claude-opus-4-6", # WRONG - should be 'model'+ "system_prompt": "Be helpful", # WRONG - should be 'sys_prompt'+ "retries": 5, # WRONG - should be 'retry'+ },+ )++ assert isinstance(response, InputValidationErrorResponse)+ assert set(response.unrecognized_fields) == {+ "llm_model",+ "system_prompt",+ "retries",+ }+ assert "Block was not executed" in response.message++ @pytest.mark.asyncio(loop_scope="session")+ async def test_unknown_fields_rejected_even_with_missing_required(self):+ """Unknown fields are caught before the missing-required-fields check."""+ session = make_session(user_id=_TEST_USER_ID)++ mock_block = make_mock_block_with_schema(+ block_id="ai-text-gen-id",+ name="AI Text Generator",+ input_properties={+ "prompt": {"type": "string"},+ "model": {"type": "string", "default": "gpt-4o-mini"},+ },+ required_fields=["prompt"],+ )++ with patch(+ "backend.api.features.chat.tools.run_block.get_block",+ return_value=mock_block,+ ):+ tool = RunBlockTool()++ # 'prompt' is missing AND 'LLM_Model' is an unknown field+ response = await tool._execute(+ user_id=_TEST_USER_ID,+ session=session,+ block_id="ai-text-gen-id",+ input_data={+ "LLM_Model": "claude-opus-4-6", # wrong key, and 'prompt' is missing+ },+ )++ # Unknown fields are caught first+ assert isinstance(response, InputValidationErrorResponse)+ assert "LLM_Model" in response.unrecognized_fields++ @pytest.mark.asyncio(loop_scope="session")+ async def test_correct_inputs_still_execute(self):+ """Correct input field names pass validation and the block executes."""+ session = make_session(user_id=_TEST_USER_ID)++ mock_block = make_mock_block_with_schema(+ block_id="ai-text-gen-id",+ name="AI Text Generator",+ input_properties={+ "prompt": {"type": "string"},+ "model": {"type": "string", "default": "gpt-4o-mini"},+ },+ required_fields=["prompt"],+ )++ async def mock_execute(input_data, **kwargs):+ yield "response", "Generated text"++ mock_block.execute = mock_execute++ with (+ patch(+ "backend.api.features.chat.tools.run_block.get_block",+ return_value=mock_block,+ ),+ patch(+ "backend.api.features.chat.tools.run_block.get_or_create_workspace",+ new_callable=AsyncMock,+ return_value=MagicMock(id="test-workspace-id"),+ ),+ ):+ tool = RunBlockTool()++ response = await tool._execute(+ user_id=_TEST_USER_ID,+ session=session,+ block_id="ai-text-gen-id",+ input_data={+ "prompt": "Write a haiku",+ "model": "gpt-4o-mini", # correct field name+ },+ )++ assert isinstance(response, BlockOutputResponse)+ assert response.success is True++ @pytest.mark.asyncio(loop_scope="session")+ async def test_missing_required_fields_returns_details(self):+ """Missing required fields returns BlockDetailsResponse with schema."""+ session = make_session(user_id=_TEST_USER_ID)++ mock_block = make_mock_block_with_schema(+ block_id="ai-text-gen-id",+ name="AI Text Generator",+ input_properties={+ "prompt": {"type": "string"},+ "model": {"type": "string", "default": "gpt-4o-mini"},+ },+ required_fields=["prompt"],+ )++ with patch(+ "backend.api.features.chat.tools.run_block.get_block",+ return_value=mock_block,+ ):+ tool = RunBlockTool()++ # Only provide valid optional field, missing required 'prompt'+ response = await tool._execute(+ user_id=_TEST_USER_ID,+ session=session,+ block_id="ai-text-gen-id",+ input_data={+ "model": "gpt-4o-mini", # valid but optional+ },+ )++ assert isinstance(response, BlockDetailsResponse)diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/test_run_block_details.py b/autogpt_platform/backend/backend/api/features/chat/tools/test_run_block_details.pynew file mode 100644index 0000000000..fbab0b723d--- /dev/null+++ b/autogpt_platform/backend/backend/api/features/chat/tools/test_run_block_details.py@@ -0,0 +1,153 @@+"""Tests for BlockDetailsResponse in RunBlockTool."""++from unittest.mock import AsyncMock, MagicMock, patch++import pytest++from backend.api.features.chat.tools.models import BlockDetailsResponse+from backend.api.features.chat.tools.run_block import RunBlockTool+from backend.blocks._base import BlockType+from backend.data.model import CredentialsMetaInput+from backend.integrations.providers import ProviderName++from ._test_data import make_session++_TEST_USER_ID = "test-user-run-block-details"+++def make_mock_block_with_inputs(+ block_id: str, name: str, description: str = "Test description"+):+ """Create a mock block with input/output schemas for testing."""+ mock = MagicMock()+ mock.id = block_id+ mock.name = name+ mock.description = description+ mock.block_type = BlockType.STANDARD+ mock.disabled = False++ # Input schema with non-credential fields+ mock.input_schema = MagicMock()+ mock.input_schema.jsonschema.return_value = {+ "properties": {+ "url": {"type": "string", "description": "URL to fetch"},+ "method": {"type": "string", "description": "HTTP method"},+ },+ "required": ["url"],+ }+ mock.input_schema.get_credentials_fields.return_value = {}+ mock.input_schema.get_credentials_fields_info.return_value = {}++ # Output schema+ mock.output_schema = MagicMock()+ mock.output_schema.jsonschema.return_value = {+ "properties": {+ "response": {"type": "object", "description": "HTTP response"},+ "error": {"type": "string", "description": "Error message"},+ }+ }++ return mock++[email protected](loop_scope="session")+async def test_run_block_returns_details_when_no_input_provided():+ """When run_block is called without input_data, it should return BlockDetailsResponse."""+ session = make_session(user_id=_TEST_USER_ID)++ # Create a block with inputs+ http_block = make_mock_block_with_inputs(+ "http-block-id", "HTTP Request", "Send HTTP requests"+ )++ with patch(+ "backend.api.features.chat.tools.run_block.get_block",+ return_value=http_block,+ ):+ # Mock credentials check to return no missing credentials+ with patch.object(+ RunBlockTool,+ "_resolve_block_credentials",+ new_callable=AsyncMock,+ return_value=({}, []), # (matched_credentials, missing_credentials)+ ):+ tool = RunBlockTool()+ response = await tool._execute(+ user_id=_TEST_USER_ID,+ session=session,+ block_id="http-block-id",+ input_data={}, # Empty input data+ )++ # Should return BlockDetailsResponse showing the schema+ assert isinstance(response, BlockDetailsResponse)+ assert response.block.id == "http-block-id"+ assert response.block.name == "HTTP Request"+ assert response.block.description == "Send HTTP requests"+ assert "url" in response.block.inputs["properties"]+ assert "method" in response.block.inputs["properties"]+ assert "response" in response.block.outputs["properties"]+ assert response.user_authenticated is True++[email protected](loop_scope="session")+async def test_run_block_returns_details_when_only_credentials_provided():+ """When only credentials are provided (no actual input), should return details."""+ session = make_session(user_id=_TEST_USER_ID)++ # Create a block with both credential and non-credential inputs+ mock = MagicMock()+ mock.id = "api-block-id"+ mock.name = "API Call"+ mock.description = "Make API calls"+ mock.block_type = BlockType.STANDARD+ mock.disabled = False++ mock.input_schema = MagicMock()+ mock.input_schema.jsonschema.return_value = {+ "properties": {+ "credentials": {"type": "object", "description": "API credentials"},+ "endpoint": {"type": "string", "description": "API endpoint"},+ },+ "required": ["credentials", "endpoint"],+ }+ mock.input_schema.get_credentials_fields.return_value = {"credentials": True}+ mock.input_schema.get_credentials_fields_info.return_value = {}++ mock.output_schema = MagicMock()+ mock.output_schema.jsonschema.return_value = {+ "properties": {"result": {"type": "object"}}+ }++ with patch(+ "backend.api.features.chat.tools.run_block.get_block",+ return_value=mock,+ ):+ with patch.object(+ RunBlockTool,+ "_resolve_block_credentials",+ new_callable=AsyncMock,+ return_value=(+ {+ "credentials": CredentialsMetaInput(+ id="cred-id",+ provider=ProviderName("test_provider"),+ type="api_key",+ title="Test Credential",+ )+ },+ [],+ ),+ ):+ tool = RunBlockTool()+ response = await tool._execute(+ user_id=_TEST_USER_ID,+ session=session,+ block_id="api-block-id",+ input_data={"credentials": {"some": "cred"}}, # Only credential+ )++ # Should return details because no non-credential inputs provided+ assert isinstance(response, BlockDetailsResponse)+ assert response.block.id == "api-block-id"+ assert response.block.name == "API Call"diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/RunBlock.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/RunBlock.tsxindex e1cb030449..6e2cbe90d7 100644--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/RunBlock.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/RunBlock.tsx@@ -3,6 +3,7 @@import type { ToolUIPart } from "ai";import { MorphingTextAnimation } from "../../components/MorphingTextAnimation/MorphingTextAnimation";import { ToolAccordion } from "../../components/ToolAccordion/ToolAccordion";+import { BlockDetailsCard } from "./components/BlockDetailsCard/BlockDetailsCard";import { BlockOutputCard } from "./components/BlockOutputCard/BlockOutputCard";import { ErrorCard } from "./components/ErrorCard/ErrorCard";import { SetupRequirementsCard } from "./components/SetupRequirementsCard/SetupRequirementsCard";@@ -11,6 +12,7 @@ import {getAnimationText,getRunBlockToolOutput,isRunBlockBlockOutput,+ isRunBlockDetailsOutput,isRunBlockErrorOutput,isRunBlockSetupRequirementsOutput,ToolIcon,@@ -41,6 +43,7 @@ export function RunBlockTool({ part }: Props) {part.state === "output-available" &&!!output &&(isRunBlockBlockOutput(output) ||+ isRunBlockDetailsOutput(output) ||isRunBlockSetupRequirementsOutput(output) ||isRunBlockErrorOutput(output));@@ -58,6 +61,10 @@ export function RunBlockTool({ part }: Props) {<ToolAccordion {...getAccordionMeta(output)}>{isRunBlockBlockOutput(output) && <BlockOutputCard output={output} />}+ {isRunBlockDetailsOutput(output) && (+ <BlockDetailsCard output={output} />+ )}+{isRunBlockSetupRequirementsOutput(output) && (<SetupRequirementsCard output={output} />)}diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/BlockDetailsCard/BlockDetailsCard.stories.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/BlockDetailsCard/BlockDetailsCard.stories.tsxnew file mode 100644index 0000000000..6e133ca93b--- /dev/null+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/BlockDetailsCard/BlockDetailsCard.stories.tsx@@ -0,0 +1,188 @@+import type { Meta, StoryObj } from "@storybook/nextjs";+import { ResponseType } from "@/app/api/__generated__/models/responseType";+import type { BlockDetailsResponse } from "../../helpers";+import { BlockDetailsCard } from "./BlockDetailsCard";++const meta: Meta<typeof BlockDetailsCard> = {+ title: "Copilot/RunBlock/BlockDetailsCard",+ component: BlockDetailsCard,+ parameters: {+ layout: "centered",+ },+ tags: ["autodocs"],+ decorators: [+ (Story) => (+ <div style={{ maxWidth: 480 }}>+ <Story />+ </div>+ ),+ ],+};++export default meta;+type Story = StoryObj<typeof meta>;++const baseBlock: BlockDetailsResponse = {+ type: ResponseType.block_details,+ message:+ "Here are the details for the GetWeather block. Provide the required inputs to run it.",+ session_id: "session-123",+ user_authenticated: true,+ block: {+ id: "block-abc-123",+ name: "GetWeather",+ description: "Fetches current weather data for a given location.",+ inputs: {+ type: "object",+ properties: {+ location: {+ title: "Location",+ type: "string",+ description:+ "City name or coordinates (e.g. 'London' or '51.5,-0.1')",+ },+ units: {+ title: "Units",+ type: "string",+ description: "Temperature units: 'metric' or 'imperial'",+ },+ },+ required: ["location"],+ },+ outputs: {+ type: "object",+ properties: {+ temperature: {+ title: "Temperature",+ type: "number",+ description: "Current temperature in the requested units",+ },+ condition: {+ title: "Condition",+ type: "string",+ description: "Weather condition description (e.g. 'Sunny', 'Rain')",+ },+ },+ },+ credentials: [],+ },+};++export const Default: Story = {+ args: {+ output: baseBlock,+ },+};++export const InputsOnly: Story = {+ args: {+ output: {+ ...baseBlock,+ message: "This block requires inputs. No outputs are defined.",+ block: {+ ...baseBlock.block,+ outputs: {},+ },+ },+ },+};++export const OutputsOnly: Story = {+ args: {+ output: {+ ...baseBlock,+ message: "This block has no required inputs.",+ block: {+ ...baseBlock.block,+ inputs: {},+ },+ },+ },+};++export const ManyFields: Story = {+ args: {+ output: {+ ...baseBlock,+ message: "Block with many input and output fields.",+ block: {+ ...baseBlock.block,+ name: "SendEmail",+ description: "Sends an email via SMTP.",+ inputs: {+ type: "object",+ properties: {+ to: {+ title: "To",+ type: "string",+ description: "Recipient email address",+ },+ subject: {+ title: "Subject",+ type: "string",+ description: "Email subject line",+ },+ body: {+ title: "Body",+ type: "string",+ description: "Email body content",+ },+ cc: {+ title: "CC",+ type: "string",+ description: "CC recipients (comma-separated)",+ },+ bcc: {+ title: "BCC",+ type: "string",+ description: "BCC recipients (comma-separated)",+ },+ },+ required: ["to", "subject", "body"],+ },+ outputs: {+ type: "object",+ properties: {+ message_id: {+ title: "Message ID",+ type: "string",+ description: "Unique ID of the sent email",+ },+ status: {+ title: "Status",+ type: "string",+ description: "Delivery status",+ },+ },+ },+ },+ },+ },+};++export const NoFieldDescriptions: Story = {+ args: {+ output: {+ ...baseBlock,+ message: "Fields without descriptions.",+ block: {+ ...baseBlock.block,+ name: "SimpleBlock",+ inputs: {+ type: "object",+ properties: {+ input_a: { title: "Input A", type: "string" },+ input_b: { title: "Input B", type: "number" },+ },+ required: ["input_a"],+ },+ outputs: {+ type: "object",+ properties: {+ result: { title: "Result", type: "string" },+ },+ },+ },+ },+ },+};diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/BlockDetailsCard/BlockDetailsCard.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/BlockDetailsCard/BlockDetailsCard.tsxnew file mode 100644index 0000000000..fdbf115222--- /dev/null+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/components/BlockDetailsCard/BlockDetailsCard.tsx@@ -0,0 +1,103 @@+"use client";++import type { BlockDetailsResponse } from "../../helpers";+import {+ ContentBadge,+ ContentCard,+ ContentCardDescription,+ ContentCardTitle,+ ContentGrid,+ ContentMessage,+} from "../../../../components/ToolAccordion/AccordionContent";++interface Props {+ output: BlockDetailsResponse;+}++function SchemaFieldList({+ title,+ properties,+ required,+}: {+ title: string;+ properties: Record<string, unknown>;+ required?: string[];+}) {+ const entries = Object.entries(properties);+ if (entries.length === 0) return null;++ const requiredSet = new Set(required ?? []);++ return (+ <ContentCard>+ <ContentCardTitle className="text-xs">{title}</ContentCardTitle>+ <div className="mt-2 grid gap-2">+ {entries.map(([name, schema]) => {+ const field = schema as Record<string, unknown> | undefined;+ const fieldTitle =+ typeof field?.title === "string" ? field.title : name;+ const fieldType =+ typeof field?.type === "string" ? field.type : "unknown";+ const description =+ typeof field?.description === "string"+ ? field.description+ : undefined;++ return (+ <div key={name} className="rounded-xl border p-2">+ <div className="flex items-center justify-between gap-2">+ <ContentCardTitle className="text-xs">+ {fieldTitle}+ </ContentCardTitle>+ <div className="flex gap-1">+ <ContentBadge>{fieldType}</ContentBadge>+ {requiredSet.has(name) && (+ <ContentBadge>Required</ContentBadge>+ )}+ </div>+ </div>+ {description && (+ <ContentCardDescription className="mt-1 text-xs">+ {description}+ </ContentCardDescription>+ )}+ </div>+ );+ })}+ </div>+ </ContentCard>+ );+}++export function BlockDetailsCard({ output }: Props) {+ const inputs = output.block.inputs as {+ properties?: Record<string, unknown>;+ required?: string[];+ } | null;+ const outputs = output.block.outputs as {+ properties?: Record<string, unknown>;+ required?: string[];+ } | null;++ return (+ <ContentGrid>+ <ContentMessage>{output.message}</ContentMessage>++ {inputs?.properties && Object.keys(inputs.properties).length > 0 && (+ <SchemaFieldList+ title="Inputs"+ properties={inputs.properties}+ required={inputs.required}+ />+ )}++ {outputs?.properties && Object.keys(outputs.properties).length > 0 && (+ <SchemaFieldList+ title="Outputs"+ properties={outputs.properties}+ required={outputs.required}+ />+ )}+ </ContentGrid>+ );+}diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/helpers.tsxindex b8625988cd..6e56154a5e 100644--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/helpers.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/RunBlock/helpers.tsx@@ -10,18 +10,37 @@ import {import type { ToolUIPart } from "ai";import { OrbitLoader } from "../../components/OrbitLoader/OrbitLoader";+/** Block details returned on first run_block attempt (before input_data provided). */+export interface BlockDetailsResponse {+ type: typeof ResponseType.block_details;+ message: string;+ session_id?: string | null;+ block: {+ id: string;+ name: string;+ description: string;+ inputs: Record<string, unknown>;+ outputs: Record<string, unknown>;+ credentials: unknown[];+ };+ user_authenticated: boolean;+}+export interface RunBlockInput {block_id?: string;+ block_name?: string;input_data?: Record<string, unknown>;}export type RunBlockToolOutput =| SetupRequirementsResponse+ | BlockDetailsResponse| BlockOutputResponse| ErrorResponse;const RUN_BLOCK_OUTPUT_TYPES = new Set<string>([ResponseType.setup_requirements,+ ResponseType.block_details,ResponseType.block_output,ResponseType.error,]);@@ -35,6 +54,15 @@ export function isRunBlockSetupRequirementsOutput();}+export function isRunBlockDetailsOutput(+ output: RunBlockToolOutput,+): output is BlockDetailsResponse {+ return (+ output.type === ResponseType.block_details ||+ ("block" in output && typeof output.block === "object")+ );+}+export function isRunBlockBlockOutput(output: RunBlockToolOutput,): output is BlockOutputResponse {@@ -64,6 +92,7 @@ function parseOutput(output: unknown): RunBlockToolOutput | null {return output as RunBlockToolOutput;}if ("block_id" in output) return output as BlockOutputResponse;+ if ("block" in output) return output as BlockDetailsResponse;if ("setup_info" in output) return output as SetupRequirementsResponse;if ("error" in output || "details" in output)return output as ErrorResponse;@@ -84,17 +113,25 @@ export function getAnimationText(part: {output?: unknown;}): string {const input = part.input as RunBlockInput | undefined;+ const blockName = input?.block_name?.trim();const blockId = input?.block_id?.trim();- const blockText = blockId ? ` "${blockId}"` : "";+ // Prefer block_name if available, otherwise fall back to block_id+ const blockText = blockName+ ? ` "${blockName}"`+ : blockId+ ? ` "${blockId}"`+ : "";switch (part.state) {case "input-streaming":case "input-available":- return `Running the block${blockText}`;+ return `Running${blockText}`;case "output-available": {const output = parseOutput(part.output);- if (!output) return `Running the block${blockText}`;+ if (!output) return `Running${blockText}`;if (isRunBlockBlockOutput(output)) return `Ran "${output.block_name}"`;+ if (isRunBlockDetailsOutput(output))+ return `Details for "${output.block.name}"`;if (isRunBlockSetupRequirementsOutput(output)) {return `Setup needed for "${output.setup_info.agent_name}"`;}@@ -158,6 +195,21 @@ export function getAccordionMeta(output: RunBlockToolOutput): {};}+ if (isRunBlockDetailsOutput(output)) {+ const inputKeys = Object.keys(+ (output.block.inputs as { properties?: Record<string, unknown> })+ ?.properties ?? {},+ );+ return {+ icon,+ title: output.block.name,+ description:+ inputKeys.length > 0+ ? `${inputKeys.length} input field${inputKeys.length === 1 ? "" : "s"} available`+ : output.message,+ };+ }+if (isRunBlockSetupRequirementsOutput(output)) {const missingCredsCount = Object.keys((output.setup_info.user_readiness?.missing_credentials ?? {}) as Record<diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.jsonindex 5d2cb83f7c..496a714ba5 100644--- a/autogpt_platform/frontend/src/app/api/openapi.json+++ b/autogpt_platform/frontend/src/app/api/openapi.json@@ -1053,6 +1053,7 @@"$ref": "#/components/schemas/ClarificationNeededResponse"},{ "$ref": "#/components/schemas/BlockListResponse" },+ { "$ref": "#/components/schemas/BlockDetailsResponse" },{ "$ref": "#/components/schemas/BlockOutputResponse" },{ "$ref": "#/components/schemas/DocSearchResultsResponse" },{ "$ref": "#/components/schemas/DocPageResponse" },@@ -6958,6 +6959,58 @@"enum": ["run", "byte", "second"],"title": "BlockCostType"},+ "BlockDetails": {+ "properties": {+ "id": { "type": "string", "title": "Id" },+ "name": { "type": "string", "title": "Name" },+ "description": { "type": "string", "title": "Description" },+ "inputs": {+ "additionalProperties": true,+ "type": "object",+ "title": "Inputs",+ "default": {}+ },+ "outputs": {+ "additionalProperties": true,+ "type": "object",+ "title": "Outputs",+ "default": {}+ },+ "credentials": {+ "items": { "$ref": "#/components/schemas/CredentialsMetaInput" },+ "type": "array",+ "title": "Credentials",+ "default": []+ }+ },+ "type": "object",+ "required": ["id", "name", "description"],+ "title": "BlockDetails",+ "description": "Detailed block information."+ },+ "BlockDetailsResponse": {+ "properties": {+ "type": {+ "$ref": "#/components/schemas/ResponseType",+ "default": "block_details"+ },+ "message": { "type": "string", "title": "Message" },+ "session_id": {+ "anyOf": [{ "type": "string" }, { "type": "null" }],+ "title": "Session Id"+ },+ "block": { "$ref": "#/components/schemas/BlockDetails" },+ "user_authenticated": {+ "type": "boolean",+ "title": "User Authenticated",+ "default": false+ }+ },+ "type": "object",+ "required": ["message", "block"],+ "title": "BlockDetailsResponse",+ "description": "Response for block details (first run_block attempt)."+ },"BlockInfo": {"properties": {"id": { "type": "string", "title": "Id" },@@ -7013,62 +7066,13 @@"properties": {"id": { "type": "string", "title": "Id" },"name": { "type": "string", "title": "Name" },- "description": { "type": "string", "title": "Description" },- "categories": {- "items": { "type": "string" },- "type": "array",- "title": "Categories"- },- "input_schema": {- "additionalProperties": true,- "type": "object",- "title": "Input Schema"- },- "output_schema": {- "additionalProperties": true,- "type": "object",- "title": "Output Schema"- },- "required_inputs": {- "items": { "$ref": "#/components/schemas/BlockInputFieldInfo" },- "type": "array",- "title": "Required Inputs",- "description": "List of required input fields for this block"- }+ "description": { "type": "string", "title": "Description" }},"type": "object",- "required": [- "id",- "name",- "description",- "categories",- "input_schema",- "output_schema"- ],+ "required": ["id", "name", "description"],"title": "BlockInfoSummary","description": "Summary of a block for search results."},- "BlockInputFieldInfo": {- "properties": {- "name": { "type": "string", "title": "Name" },- "type": { "type": "string", "title": "Type" },- "description": {- "type": "string",- "title": "Description",- "default": ""- },- "required": {- "type": "boolean",- "title": "Required",- "default": false- },- "default": { "anyOf": [{}, { "type": "null" }], "title": "Default" }- },- "type": "object",- "required": ["name", "type"],- "title": "BlockInputFieldInfo",- "description": "Information about a block input field."- },"BlockListResponse": {"properties": {"type": {@@ -7086,12 +7090,7 @@"title": "Blocks"},"count": { "type": "integer", "title": "Count" },- "query": { "type": "string", "title": "Query" },- "usage_hint": {- "type": "string",- "title": "Usage Hint",- "default": "To execute a block, call run_block with block_id set to the block's 'id' field and input_data containing the required fields from input_schema."- }+ "query": { "type": "string", "title": "Query" }},"type": "object","required": ["message", "blocks", "count", "query"],@@ -10484,6 +10483,7 @@"agent_saved","clarification_needed","block_list",+ "block_details","block_output","doc_search_results","doc_page",