Fix Responses API tool calling for codex models

integrations/langchain/src/databricks_langchain/chat_models.py

@@ -441,6 +441,19 @@ def _prepare_inputs(
             # Responses API only supports temperature, not max_tokens, stop, or n
             if self.temperature is not None:
                 data["temperature"] = self.temperature
+            # Convert tools from Chat Completions format to Responses API format
+            if "tools" in data:
+                data["tools"] = [
+                    {
+                        "type": "function",
+                        "name": t["function"]["name"],
+                        "description": t["function"].get("description", ""),
+                        "parameters": t["function"].get("parameters", {}),
+                    }
+                    if "function" in t
+                    else t
+                    for t in data["tools"]
+                ]
         else:
             # Chat completions API expects "messages" parameter
             data["messages"] = [_convert_message_to_dict(msg) for msg in messages]
@@ -552,9 +565,11 @@ def _convert_responses_api_response_to_chat_result(self, response: Response) ->
                 "mcp_approval_request",
                 "image_generation_call",
             ):
-                # For these special types, convert to dict if possible
+                # For these special types, convert to dict if possible.
+                # Use exclude_none to drop default None fields (e.g. status, namespace)
+                # that FMAPI rejects as unknown parameters.
                 if hasattr(item, "model_dump"):
-                    content_blocks.append(item.model_dump())
+                    content_blocks.append(item.model_dump(exclude_none=True))
                 else:
                     content_blocks.append(item)
 
@@ -1411,6 +1426,18 @@ def _convert_lc_messages_to_responses_api(messages: list[BaseMessage]) -> list[d
     """
     Convert a LangChain message to a Responses API message.
     """
+
+    # FMAPI enforces max 64-char IDs and requires msg_ prefix on message ids.
+    _MAX_ID = 64
+
+    def _truncate(s: str) -> str:
+        return s[:_MAX_ID]
+
+    def _msg_id(lc_id: str | None) -> str | None:
+        if not lc_id or lc_id.startswith("msg_"):
+            return _truncate(lc_id) if lc_id else lc_id
+        return _truncate(f"msg_{lc_id}")
+
     # TODO: add multimodal support
     input_items = []
     for lc_msg in messages:
@@ -1435,7 +1462,7 @@ def _convert_lc_messages_to_responses_api(messages: list[BaseMessage]) -> list[d
                                         }
                                     ],
                                     "role": "assistant",
-                                    "id": lc_msg.id,
+                                    "id": _msg_id(lc_msg.id),
                                 }
                             )
                         elif block_type == "refusal":
@@ -1449,7 +1476,7 @@ def _convert_lc_messages_to_responses_api(messages: list[BaseMessage]) -> list[d
                                         }
                                     ],
                                     "role": "assistant",
-                                    "id": lc_msg.id,
+                                    "id": _msg_id(lc_msg.id),
                                 }
                             )
                         elif block_type in (
@@ -1463,13 +1490,23 @@ def _convert_lc_messages_to_responses_api(messages: list[BaseMessage]) -> list[d
                             "mcp_list_tools",
                             "mcp_approval_request",
                         ):
-                            input_items.append(block | {"id": lc_msg.id})
+                            # FMAPI rejects output-only fields on input items.
+                            block.pop("status", None)
+                            # Fix ids: FMAPI requires fc_ prefix and max 64 chars.
+                            if "id" not in block:
+                                call_id = block.get("call_id", "")
+                                block["id"] = _truncate(
+                                    f"fc_{call_id}" if call_id else (lc_msg.id or "")
+                                )
+                            elif len(block["id"]) > _MAX_ID:
+                                block["id"] = _truncate(block["id"])
+                            input_items.append(block)
             elif isinstance(cc_msg.get("content"), str):
                 input_items.append(
                     {
                         "type": "message",
                         "role": "assistant",
-                        "id": lc_msg.id,
+                        "id": _msg_id(lc_msg.id),
                         "content": [{"type": "output_text", "text": cc_msg["content"]}],
                     }
                 )
@@ -1479,7 +1516,7 @@ def _convert_lc_messages_to_responses_api(messages: list[BaseMessage]) -> list[d
                     [
                         {
                             "type": "function_call",
-                            "id": lc_msg.id,
+                            "id": _truncate(f"fc_{tool_call['id']}"),
                             "call_id": tool_call["id"],
                             "name": tool_call["function"]["name"],
                             "arguments": tool_call["function"]["arguments"],

integrations/langchain/tests/integration_tests/test_fmapi_tool_calling.py

@@ -11,9 +11,11 @@
 
 import pytest
 from databricks_ai_bridge.test_utils.fmapi import (
-    LANGCHAIN_SKIP_MODELS,
+    SKIP_CHAT_COMPLETIONS_LANGCHAIN,
+    SKIP_RESPONSES_API,
     async_retry,
-    discover_foundation_models,
+    discover_chat_models,
+    discover_responses_models,
     max_tokens_for_model,
     retry,
 )
@@ -29,7 +31,8 @@
     reason="FMAPI tool calling tests disabled. Set RUN_FMAPI_TOOL_CALLING_TESTS=1 to enable.",
 )
 
-_FOUNDATION_MODELS = discover_foundation_models(LANGCHAIN_SKIP_MODELS)
+_CHAT_MODELS = discover_chat_models(SKIP_CHAT_COMPLETIONS_LANGCHAIN)
+_RESPONSES_MODELS = discover_responses_models(SKIP_RESPONSES_API)
 
 
 @tool
@@ -60,7 +63,7 @@ def multiply(a: int, b: int) -> int:
 
 
 @pytest.mark.integration
-@pytest.mark.parametrize("model", _FOUNDATION_MODELS)
+@pytest.mark.parametrize("model", _CHAT_MODELS)
 class TestLangGraphSync:
     """Sync LangGraph agent tests using ChatDatabricks + create_react_agent."""
 
@@ -157,7 +160,7 @@ def _run():
 
 @pytest.mark.integration
 @pytest.mark.asyncio
-@pytest.mark.parametrize("model", _FOUNDATION_MODELS)
+@pytest.mark.parametrize("model", _CHAT_MODELS)
 class TestLangGraphAsync:
     """Async LangGraph agent tests using ChatDatabricks + create_react_agent."""
 
@@ -251,3 +254,82 @@ async def _run():
             assert got_message_chunks, "Expected AIMessageChunk tokens in message stream"
 
         await async_retry(_run)
+
+
+# =============================================================================
+# Responses API — LangGraph (GPT models including codex)
+# =============================================================================
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("model", _RESPONSES_MODELS)
+class TestLangGraphResponsesAPI:
+    """LangGraph agent tests using ChatDatabricks(use_responses_api=True).
+
+    Tests GPT models (including codex which only supports Responses API).
+    """
+
+    def test_single_turn(self, model):
+        """Single-turn: agent calls tools and produces a final answer via Responses API."""
+        llm = ChatDatabricks(model=model, use_responses_api=True)
+        agent = create_react_agent(llm, [add, multiply])
+
+        def _run():
+            response = agent.invoke({"messages": [("human", "Use the add tool to compute 10 + 5")]})
+            tool_msgs = [m for m in response["messages"] if isinstance(m, ToolMessage)]
+            assert len(tool_msgs) >= 1, "Agent should have called at least one tool"
+            last = response["messages"][-1]
+            assert isinstance(last, AIMessage)
+
+        retry(_run)
+
+    def test_multi_turn(self, model):
+        """Multi-turn: agent maintains context across turns via Responses API."""
+        llm = ChatDatabricks(model=model, use_responses_api=True)
+        checkpointer = MemorySaver()
+        agent = create_react_agent(llm, [add, multiply], checkpointer=checkpointer)
+        config = {"configurable": {"thread_id": "responses-api-test"}}
+
+        def _run():
+            r1 = agent.invoke(
+                {"messages": [("human", "Use the add tool to compute 10 + 5")]}, config=config
+            )
+            tool_msgs_1 = [m for m in r1["messages"] if isinstance(m, ToolMessage)]
+            assert len(tool_msgs_1) >= 1
+
+            r2 = agent.invoke(
+                {"messages": [("human", "Now multiply the result by 3")]}, config=config
+            )
+            assert len(r2["messages"]) > len(r1["messages"]), "History should grow across turns"
+
+        retry(_run)
+
+    def test_streaming(self, model):
+        """Streaming: agent streams node updates and tool events via Responses API."""
+        llm = ChatDatabricks(model=model, use_responses_api=True)
+        agent = create_react_agent(llm, [add, multiply])
+
+        def _run():
+            event_count = 0
+            nodes_seen = set()
+            got_message_chunks = False
+
+            for event in agent.stream(
+                {"messages": [("human", "Use the add tool to compute 10 + 5")]},
+                stream_mode=["updates", "messages"],
+            ):
+                event_count += 1
+                mode, data = event
+                if mode == "updates":
+                    nodes_seen.update(data.keys())
+                elif mode == "messages":
+                    chunk, _metadata = data
+                    if isinstance(chunk, AIMessageChunk):
+                        got_message_chunks = True
+
+            assert event_count > 0, "No stream events received"
+            assert "agent" in nodes_seen, f"Expected 'agent' node, got: {nodes_seen}"
+            assert "tools" in nodes_seen, f"Expected 'tools' node, got: {nodes_seen}"
+            assert got_message_chunks, "Expected AIMessageChunk tokens in message stream"
+
+        retry(_run)

integrations/langchain/tests/unit_tests/test_chat_models.py

@@ -895,7 +895,7 @@ def test_convert_lc_messages_to_responses_api_with_tool_calls():
             "name": "get_weather",
             "call_id": "call_123",
             "arguments": '{"location": "SF"}',
-            "id": "msg_123",
+            "id": "fc_call_123",
         },
         {
             "type": "function_call_output",

integrations/openai/src/databricks_openai/utils/clients.py

@@ -208,8 +208,44 @@ class DatabricksChat(Chat):
     completions: DatabricksCompletions
 
 
+_FMAPI_MAX_ID_LENGTH = 64
+
+
+def _truncate_response_ids(response: Any) -> None:
+    """Truncate ids that exceed FMAPI's 64-char input limit.
+
+    FMAPI returns response and output item ids longer than 64 chars, but rejects
+    them on the next turn's input. We truncate to prevent multi-turn failures.
+    """
+    if hasattr(response, "id") and response.id and len(response.id) > _FMAPI_MAX_ID_LENGTH:
+        response.id = response.id[:_FMAPI_MAX_ID_LENGTH]
+    if not hasattr(response, "output"):
+        return
+    for item in response.output:
+        item_id = getattr(item, "id", None)
+        if item_id and len(item_id) > _FMAPI_MAX_ID_LENGTH:
+            item.id = item_id[:_FMAPI_MAX_ID_LENGTH]
+
+
+def _truncate_input_ids(input_items: Any) -> None:
+    """Truncate ids in input items. Covers the streaming path where
+    _truncate_response_ids can't intercept the assembled response.
+    """
+    if not input_items or not isinstance(input_items, list):
+        return
+    for item in input_items:
+        if isinstance(item, dict):
+            item_id = item.get("id")
+            if isinstance(item_id, str) and len(item_id) > _FMAPI_MAX_ID_LENGTH:
+                item["id"] = item_id[:_FMAPI_MAX_ID_LENGTH]
+        else:
+            item_id = getattr(item, "id", None)
+            if isinstance(item_id, str) and len(item_id) > _FMAPI_MAX_ID_LENGTH:
+                item.id = item_id[:_FMAPI_MAX_ID_LENGTH]
+
+
 class DatabricksResponses(Responses):
-    """Responses resource that handles apps/ prefix routing."""
+    """Responses resource that handles apps/ prefix routing and id truncation."""
 
     def __init__(self, client, workspace_client: WorkspaceClient):
         super().__init__(client)
@@ -231,6 +267,7 @@ def _get_app_client(self, app_name: str) -> OpenAI:
 
     def create(self, **kwargs):
         model = kwargs.get("model", "")
+        _truncate_input_ids(kwargs.get("input"))
 
         if isinstance(model, str) and model.startswith(_APPS_ENDPOINT_PREFIX):
             app_name = model[len(_APPS_ENDPOINT_PREFIX) :]
@@ -240,7 +277,9 @@ def create(self, **kwargs):
             except (APIStatusError, APIConnectionError) as e:
                 raise _wrap_app_error(e, app_name) from e
 
-        return super().create(**kwargs)
+        response = super().create(**kwargs)
+        _truncate_response_ids(response)
+        return response
 
 
 class DatabricksOpenAI(OpenAI):
@@ -356,7 +395,7 @@ class AsyncDatabricksChat(AsyncChat):
 
 
 class AsyncDatabricksResponses(AsyncResponses):
-    """Async Responses resource that handles apps/ prefix routing."""
+    """Async Responses resource that handles apps/ prefix routing and id truncation."""
 
     def __init__(self, client, workspace_client: WorkspaceClient):
         super().__init__(client)
@@ -378,6 +417,7 @@ def _get_app_client(self, app_name: str) -> AsyncOpenAI:
 
     async def create(self, **kwargs):
         model = kwargs.get("model", "")
+        _truncate_input_ids(kwargs.get("input"))
 
         if isinstance(model, str) and model.startswith(_APPS_ENDPOINT_PREFIX):
             app_name = model[len(_APPS_ENDPOINT_PREFIX) :]
@@ -387,7 +427,9 @@ async def create(self, **kwargs):
             except (APIStatusError, APIConnectionError) as e:
                 raise _wrap_app_error(e, app_name) from e
 
-        return await super().create(**kwargs)
+        response = await super().create(**kwargs)
+        _truncate_response_ids(response)
+        return response
 
 
 class AsyncDatabricksOpenAI(AsyncOpenAI):