feat: add OpenAI /v1/responses adapter via chat flow

Implement a thin responses layer that reuses existing chat/completions execution so auth, pooling, streaming, tool passthrough, and error semantics stay aligned across APIs.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

tests/test_tool_call_bridge.py

@@ -51,9 +51,10 @@ sys.modules.setdefault("playwright", _playwright)
 sys.modules.setdefault("playwright.async_api", _playwright_async)
 
 from starlette.requests import Request
+from starlette.responses import JSONResponse, Response, StreamingResponse
 
 from app.anthropic_schema import AnthropicMessagesRequest
-from app.openai_schema import ChatCompletionsRequest
+from app.openai_schema import ChatCompletionsRequest, ResponsesRequest
 import app.main as main
 
 
@@ -704,6 +705,119 @@ class ToolCallBridgeTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(fake_cache.keys, [])
         self.assertEqual(fake_cache.get_calls, [])
         self.assertEqual(fake_cache.put_calls, [])
+    async def test_responses_non_stream_maps_chat_payload_shape_and_input(self) -> None:
+        req = ResponsesRequest(
+            model="org_auto",
+            input="hello from responses",
+            stream=False,
+        )
+        chat_payload = {
+            "id": "chatcmpl-abc123",
+            "created": 123,
+            "model": "org_auto",
+            "choices": [
+                {
+                    "index": 0,
+                    "finish_reason": "stop",
+                    "message": {"role": "assistant", "content": "done"},
+                }
+            ],
+            "usage": {"prompt_tokens": 4, "completion_tokens": 2, "total_tokens": 6},
+        }
+
+        mock_chat = AsyncMock(return_value=JSONResponse(content=chat_payload))
+        with patch.object(main, "v1_chat_completions", mock_chat):
+            response = await main.v1_responses(req, _make_request("/v1/responses"))
+
+        payload = json.loads(response.body)
+        self.assertEqual(payload["id"], "resp_abc123")
+        self.assertEqual(payload["object"], "response")
+        self.assertEqual(payload["status"], "completed")
+        self.assertEqual(payload["output_text"], "done")
+        self.assertEqual(payload["usage"], {"input_tokens": 4, "output_tokens": 2, "total_tokens": 6})
+        self.assertEqual(payload["output"][0]["type"], "message")
+        self.assertEqual(payload["output"][0]["content"][0]["type"], "output_text")
+
+        mock_chat.assert_awaited_once()
+        chat_req = mock_chat.await_args.args[0]
+        self.assertIsInstance(chat_req, ChatCompletionsRequest)
+        messages_dump = [m.model_dump() for m in chat_req.messages]
+        self.assertEqual(messages_dump, [{"role": "user", "content": "hello from responses", "name": None, "tool_call_id": None, "tool_calls": None}])
+
+    async def test_responses_forwards_input_tools_and_tool_choice_to_chat_request(self) -> None:
+        req = ResponsesRequest(
+            model="org_auto",
+            instructions="be concise",
+            input=[
+                {"role": "user", "content": [{"type": "text", "text": "first"}]},
+                {"type": "function_call_output", "call_id": "call_1", "output": {"ok": True}},
+                "follow up",
+            ],
+            stream=False,
+            tools=[{"type": "function", "function": {"name": "lookup", "parameters": {}}}],
+            tool_choice={"type": "function", "function": {"name": "lookup"}},
+        )
+
+        mock_chat = AsyncMock(return_value=JSONResponse(content={"id": "chatcmpl-x", "created": 1, "model": "org_auto", "choices": [{"message": {"role": "assistant", "content": "ok"}}], "usage": {}}))
+        with patch.object(main, "v1_chat_completions", mock_chat):
+            await main.v1_responses(req, _make_request("/v1/responses"))
+
+        mock_chat.assert_awaited_once()
+        chat_req = mock_chat.await_args.args[0]
+        self.assertIsInstance(chat_req, ChatCompletionsRequest)
+        self.assertEqual(chat_req.tools, req.tools)
+        self.assertEqual(chat_req.tool_choice, req.tool_choice)
+        messages_dump = [m.model_dump() for m in chat_req.messages]
+        self.assertEqual(messages_dump[0]["role"], "system")
+        self.assertEqual(messages_dump[0]["content"], "be concise")
+        self.assertEqual(messages_dump[1]["role"], "user")
+        self.assertEqual(messages_dump[1]["content"], "first")
+        self.assertEqual(messages_dump[2]["role"], "tool")
+        self.assertEqual(messages_dump[2]["tool_call_id"], "call_1")
+        self.assertEqual(messages_dump[2]["content"], '{"ok": true}')
+        self.assertEqual(messages_dump[3]["role"], "user")
+        self.assertEqual(messages_dump[3]["content"], "follow up")
+
+    async def test_responses_stream_bridges_text_tool_and_completed_events(self) -> None:
+        async def _chat_sse():
+            yield b'data: {"choices": [{"delta": {"content": "hello"}}]}\n\n'
+            yield b'data: {"choices": [{"delta": {"tool_calls": [{"id": "call_1", "function": {"name": "lookup", "arguments": "{\\"q\\": \\"x\\"}"}}]}}]}\n\n'
+            yield b'data: {"usage": {"prompt_tokens": 3, "completion_tokens": 2, "total_tokens": 5}, "choices": [{"delta": {}}]}\n\n'
+            yield b"data: [DONE]\n\n"
+
+        req = ResponsesRequest(model="org_auto", input="hi", stream=True)
+        mock_chat = AsyncMock(
+            return_value=StreamingResponse(_chat_sse(), media_type="text/event-stream")
+        )
+
+        with patch.object(main, "v1_chat_completions", mock_chat):
+            response = await main.v1_responses(req, _make_request("/v1/responses"))
+            body = await _collect_stream(response)
+
+        self.assertIn('"type": "response.created"', body)
+        self.assertIn('"type": "response.output_text.delta"', body)
+        self.assertIn('"delta": "hello"', body)
+        self.assertIn('"type": "response.function_call.delta"', body)
+        self.assertIn('"item_id": "call_1"', body)
+        self.assertIn('"name": "lookup"', body)
+        self.assertIn('"type": "response.completed"', body)
+        self.assertIn('"input_tokens": 3', body)
+        self.assertIn('"output_tokens": 2', body)
+        self.assertIn('data: [DONE]', body)
+
+
+    async def test_responses_non_stream_returns_502_on_invalid_upstream_json(self) -> None:
+        req = ResponsesRequest(model="org_auto", input="hi", stream=False)
+        mock_chat = AsyncMock(return_value=Response(content="not-json", media_type="text/plain"))
+
+        with patch.object(main, "v1_chat_completions", mock_chat):
+            with self.assertRaises(main.HTTPException) as cm:
+                await main.v1_responses(req, _make_request("/v1/responses"))
+
+        self.assertEqual(cm.exception.status_code, 502)
+        detail = cm.exception.detail
+        self.assertEqual(detail["error"]["type"], "upstream_error")
+        self.assertEqual(detail["error"]["message"], "invalid upstream response")
 
 
 class SessionCacheToolFingerprintTests(unittest.TestCase):