Preserve array item schema (#5200)

When CC submits a schema to the MCP server, our manual conversion from
JSON schema to Pydantic model was dropping important details. When
submitting a schema containing an array, the schema for the array's
items was lost completely.

This meant the array items could be anything: strings, numbers,
objects with arbitrary fields. This gives the agents far too much
freedom to return their results in whatever format they want. And it
caused serialization errors when writing the results since the backend
would make incorrect assumptions about the array item type.

This PR lets the MCP tools bypass the JSON schema -> Pydantic -> JSON
schema chain.

Sourced from commit dda388ec445ee7e681b68bed303a320c56334aa7

Author: rgambee

futuresearch-mcp/src/futuresearch_mcp/models.py

@@ -17,23 +17,13 @@
     BaseModel,
     ConfigDict,
     Field,
-    create_model,
     field_validator,
     model_validator,
 )
 
 from futuresearch_mcp.config import settings
 from futuresearch_mcp.utils import is_url, validate_csv_path, validate_url
 
-JSON_TYPE_MAP = {
-    "string": str,
-    "integer": int,
-    "number": float,
-    "boolean": bool,
-    "array": list,
-    "object": dict,
-}
-
 
 class InputDataMode(StrEnum):
     dataframe = "DATAFRAME"
@@ -80,37 +70,6 @@ def _validate_response_schema(schema: dict[str, Any] | None) -> dict[str, Any] |
     return schema
 
 
-def _schema_to_model(name: str, schema: dict[str, Any]) -> type[BaseModel]:
-    """Convert a JSON schema dict to a dynamic Pydantic model.
-
-    This allows the MCP client to pass arbitrary response schemas without
-    needing to define Python classes.
-    """
-    properties = schema["properties"]
-    required = set(schema.get("required", []))
-
-    fields: dict[str, Any] = {}
-    for field_name, field_def in properties.items():
-        if not isinstance(field_def, dict):
-            raise ValueError(
-                f"Invalid property schema for '{field_name}': expected an object."
-            )
-
-        field_type_str = field_def.get("type", "string")
-        python_type = JSON_TYPE_MAP.get(field_type_str, str)
-        description = field_def.get("description", "")
-
-        if field_name in required:
-            fields[field_name] = (python_type, Field(..., description=description))
-        else:
-            fields[field_name] = (
-                python_type | None,
-                Field(default=None, description=description),
-            )
-
-    return create_model(name, **fields)
-
-
 def _check_exactly_one(
     *,
     values: tuple[Any | None, ...],

futuresearch-mcp/src/futuresearch_mcp/tools.py

@@ -17,14 +17,14 @@
 from futuresearch.generated.api.tasks import get_task_status_tasks_task_id_status_get
 from futuresearch.generated.models.task_status import TaskStatus
 from futuresearch.ops import (
-    agent_map_async,
+    _submit_agent_map,
+    _submit_rank,
+    _submit_single_agent,
     classify_async,
     create_table_artifact,
     dedupe_async,
     forecast_async,
     merge_async,
-    rank_async,
-    single_agent_async,
 )
 from futuresearch.session import list_sessions
 from futuresearch.task import cancel_task
@@ -51,7 +51,6 @@
     StdioResultsInput,
     UploadDataInput,
     UseListInput,
-    _schema_to_model,
 )
 from futuresearch_mcp.result_store import (
     _build_result_response,
@@ -270,10 +269,6 @@ async def futuresearch_agent(
 
     input_data = params._aid_or_dataframe
 
-    response_model: type[BaseModel] | None = None
-    if params.response_schema:
-        response_model = _schema_to_model("AgentResult", params.response_schema)
-
     async with create_linked_session(
         client=client, session_id=params.session_id, name=params.session_name
     ) as session:
@@ -284,8 +279,8 @@ async def futuresearch_agent(
             "input": input_data,
             "enforce_row_independence": params.enforce_row_independence,
         }
-        if response_model:
-            kwargs["response_model"] = response_model
+        if params.response_schema:
+            kwargs["response_schema"] = params.response_schema
         kwargs["effort_level"] = params.effort_level
         if params.effort_level is None:
             if params.llm is not None:
@@ -294,8 +289,8 @@ async def futuresearch_agent(
                 kwargs["iteration_budget"] = params.iteration_budget
             if params.include_reasoning is not None:
                 kwargs["include_reasoning"] = params.include_reasoning
-        cohort_task = await agent_map_async(**kwargs)
-        task_id = str(cohort_task.task_id)
+        submitted = await _submit_agent_map(**kwargs)
+        task_id = str(submitted.task_id)
         total = len(input_data) if isinstance(input_data, pd.DataFrame) else 0
 
     return await create_tool_response(
@@ -356,10 +351,6 @@ async def futuresearch_single_agent(
     log_client_info(ctx, "futuresearch_single_agent")
     client = _get_client(ctx)
 
-    response_model: type[BaseModel] | None = None
-    if params.response_schema:
-        response_model = _schema_to_model("SingleAgentResult", params.response_schema)
-
     # Convert input_data dict to a BaseModel if provided
     input_model: BaseModel | None = None
     if params.input_data:
@@ -378,8 +369,8 @@ async def futuresearch_single_agent(
         }
         if input_model is not None:
             kwargs["input"] = input_model
-        if response_model is not None:
-            kwargs["response_model"] = response_model
+        if params.response_schema:
+            kwargs["response_schema"] = params.response_schema
         kwargs["effort_level"] = params.effort_level
         if params.effort_level is None:
             if params.llm is not None:
@@ -388,8 +379,8 @@ async def futuresearch_single_agent(
                 kwargs["iteration_budget"] = params.iteration_budget
             if params.include_reasoning is not None:
                 kwargs["include_reasoning"] = params.include_reasoning
-        cohort_task = await single_agent_async(**kwargs)
-        task_id = str(cohort_task.task_id)
+        submitted = await _submit_single_agent(**kwargs)
+        task_id = str(submitted.task_id)
 
     return await create_tool_response(
         task_id=task_id,
@@ -445,24 +436,20 @@ async def futuresearch_rank(
 
     input_data = params._aid_or_dataframe
 
-    response_model: type[BaseModel] | None = None
-    if params.response_schema:
-        response_model = _schema_to_model("RankResult", params.response_schema)
-
     async with create_linked_session(
         client=client, session_id=params.session_id, name=params.session_name
     ) as session:
         session_id_str = str(session.session_id)
-        cohort_task = await rank_async(
+        submitted = await _submit_rank(
             task=params.task,
             session=session,
             input=input_data,
             field_name=params.field_name,
             field_type=params.field_type,
-            response_model=response_model,
+            response_schema=params.response_schema,
             ascending_order=params.ascending_order,
         )
-        task_id = str(cohort_task.task_id)
+        task_id = str(submitted.task_id)
         total = len(input_data) if isinstance(input_data, pd.DataFrame) else 0
 
     return await create_tool_response(

futuresearch-mcp/tests/test_mcp_e2e.py

@@ -234,7 +234,7 @@ async def test_call_agent_tool(self, _http_state):
                     return_value=MagicMock(token="fake-token"),
                 ),
                 patch(
-                    "futuresearch_mcp.tools.agent_map_async",
+                    "futuresearch_mcp.tools._submit_agent_map",
                     new_callable=AsyncMock,
                     return_value=mock_task,
                 ),

futuresearch-mcp/tests/test_schema_roundtrip.py

@@ -0,0 +1,139 @@
+import json
+
+from futuresearch.generated.models.agent_map_operation_response_schema_type_0 import (
+    AgentMapOperationResponseSchemaType0,
+)
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+EBAY_DEALS_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "deals": {
+            "type": "array",
+            "description": "List of eBay deals found where per-item cost is below avg_90d",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "title": {
+                        "type": "string",
+                        "description": "Full eBay listing title",
+                    },
+                    "per_item_cost": {
+                        "type": "number",
+                        "description": "Price per item",
+                    },
+                    "shipping_cost": {"type": "string", "description": "Shipping cost"},
+                    "margin": {
+                        "type": "number",
+                        "description": "avg_90d minus per_item_cost",
+                    },
+                    "url": {
+                        "type": "string",
+                        "description": "Full URL to the eBay listing",
+                    },
+                },
+                "required": [
+                    "title",
+                    "per_item_cost",
+                    "shipping_cost",
+                    "margin",
+                    "url",
+                ],
+            },
+        },
+        "no_deals_reason": {
+            "type": "string",
+            "description": "If no deals found, explain why",
+        },
+    },
+    "required": ["deals"],
+}
+
+
+def _roundtrip_via_sdk(schema: dict) -> dict:
+    """Simulate the SDK path: schema → generated model → dict."""
+    sdk_obj = AgentMapOperationResponseSchemaType0.from_dict(schema)
+    return sdk_obj.to_dict()
+
+
+class TestSchemaPassthrough:
+    """The SDK should pass the schema dict through without modification."""
+
+    def test_ebay_deals_schema_preserved(self):
+        """The exact schema from the failing eBay CPAP session."""
+        result = _roundtrip_via_sdk(EBAY_DEALS_SCHEMA)
+        deals = result["properties"]["deals"]
+        assert deals["type"] == "array"
+        assert deals["items"]["type"] == "object"
+        assert "title" in deals["items"]["properties"]
+        assert "url" in deals["items"]["properties"]
+        assert deals["items"]["required"] == [
+            "title",
+            "per_item_cost",
+            "shipping_cost",
+            "margin",
+            "url",
+        ]
+
+    def test_array_of_objects_items_preserved(self):
+        schema = {
+            "type": "object",
+            "properties": {
+                "items": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "value": {"type": "number"},
+                        },
+                        "required": ["name"],
+                    },
+                }
+            },
+            "required": ["items"],
+        }
+        result = _roundtrip_via_sdk(schema)
+        assert (
+            result["properties"]["items"]["items"]["properties"]["name"]["type"]
+            == "string"
+        )
+        assert result["properties"]["items"]["items"]["required"] == ["name"]
+
+    def test_array_of_primitives_preserved(self):
+        schema = {
+            "type": "object",
+            "properties": {
+                "tags": {"type": "array", "items": {"type": "string"}},
+            },
+            "required": ["tags"],
+        }
+        result = _roundtrip_via_sdk(schema)
+        assert result["properties"]["tags"]["items"]["type"] == "string"
+
+    def test_nested_object_properties_preserved(self):
+        schema = {
+            "type": "object",
+            "properties": {
+                "metadata": {
+                    "type": "object",
+                    "properties": {
+                        "source": {"type": "string"},
+                        "confidence": {"type": "number"},
+                    },
+                }
+            },
+            "required": ["metadata"],
+        }
+        result = _roundtrip_via_sdk(schema)
+        assert (
+            result["properties"]["metadata"]["properties"]["source"]["type"] == "string"
+        )
+
+    def test_schema_is_json_serializable(self):
+        """The schema must be JSON-serializable for the HTTP request."""
+        result = _roundtrip_via_sdk(EBAY_DEALS_SCHEMA)
+        json.dumps(result)  # should not raise