"""Executable contract for the two-ingress by two-upstream protocol matrix.""" import json from collections.abc import AsyncIterator, Callable from unittest.mock import patch import httpx2 import pytest from openai import AsyncOpenAI from free_claude_code.core.anthropic import MessagesRequest, ReasoningReplayMode from free_claude_code.core.anthropic.stream_contracts import ( assert_anthropic_stream_contract, parse_sse_text, text_content, ) from free_claude_code.core.openai_responses import OpenAIResponsesRequest from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY from free_claude_code.core.stream_output import StreamOutput from free_claude_code.providers.openai_chat import ( NO_REASONING, OpenAIChatProfile, OpenAIChatProvider, OpenAIChatRequestPolicy, ) from free_claude_code.providers.openai_responses import OpenAIResponsesTransport from tests.providers.support import ( immediate_admission, make_provider_config, without_empty_reasoning, ) def _messages_request() -> MessagesRequest: return MessagesRequest.model_validate( { "model": "upstream-model", "messages": [{"role": "user", "content": "hello"}], "max_tokens": 64, } ) def _responses_request() -> OpenAIResponsesRequest: return OpenAIResponsesRequest.model_validate( { "model": "upstream-model", "input": "hello", "max_output_tokens": 64, } ) def _image_messages_request() -> MessagesRequest: return MessagesRequest.model_validate( { "model": "upstream-model", "messages": [ { "role": "assistant", "content": [ { "type": "tool_use", "id": "call_image", "name": "read_image", "input": {}, } ], }, { "role": "user", "content": [ { "type": "tool_result", "tool_use_id": "call_image", "content": [ {"type": "text", "text": "result"}, { "type": "image", "source": { "type": "url", "url": "https://images.example.test/result.png", }, }, ], } ], }, ], "max_tokens": 64, } ) def _image_responses_request() -> OpenAIResponsesRequest: return OpenAIResponsesRequest.model_validate( { "model": "upstream-model", "input": [ { "type": "function_call", "call_id": "call_image", "name": "read_image", "arguments": "{}", }, { "type": "function_call_output", "call_id": "call_image", "output": [ {"type": "input_text", "text": "result"}, { "type": "input_image", "image_url": "https://images.example.test/result.png", }, ], }, ], "max_output_tokens": 64, } ) def _client(handler: Callable[[httpx2.Request], httpx2.Response]) -> AsyncOpenAI: return AsyncOpenAI( api_key="test-key", base_url="https://provider.invalid/v1", max_retries=0, http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(handler)), ) def _chat_sse(text: str) -> str: chunks = ( { "id": "chatcmpl_matrix", "object": "chat.completion.chunk", "created": 1, "model": "upstream-model", "choices": [ { "index": 0, "delta": {"role": "assistant", "content": text}, "finish_reason": None, } ], }, { "id": "chatcmpl_matrix", "object": "chat.completion.chunk", "created": 1, "model": "upstream-model", "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}], "usage": { "prompt_tokens": 2, "completion_tokens": 1, "total_tokens": 3, }, }, ) return "".join(f"data: {json.dumps(chunk)}\n\n" for chunk in chunks) + ( "data: [DONE]\n\n" ) def _response_payload(*, status: str, text: str) -> dict[str, object]: output = ( [] if status == "in_progress" else [ { "id": "msg_matrix", "type": "message", "status": "completed", "role": "assistant", "content": [ { "type": "output_text", "text": text, "annotations": [], "logprobs": [], } ], } ] ) return { "id": "resp_matrix", "created_at": 1, "error": None, "incomplete_details": None, "instructions": None, "metadata": None, "model": "upstream-model", "object": "response", "output": output, "parallel_tool_calls": True, "temperature": None, "tool_choice": "auto", "tools": [], "top_p": None, "background": False, "conversation": None, "max_output_tokens": 64, "max_tool_calls": None, "previous_response_id": None, "prompt": None, "prompt_cache_key": None, "reasoning": None, "safety_identifier": None, "service_tier": "default", "status": status, "text": {"format": {"type": "text"}, "verbosity": "medium"}, "top_logprobs": 0, "truncation": "disabled", "usage": ( None if status == "in_progress" else { "input_tokens": 2, "input_tokens_details": {"cached_tokens": 0}, "output_tokens": 1, "output_tokens_details": {"reasoning_tokens": 0}, "total_tokens": 3, } ), "user": None, "store": False, } def _responses_sse(text: str) -> str: events = ( { "type": "response.created", "sequence_number": 0, "response": _response_payload(status="in_progress", text=text), }, { "type": "response.output_text.delta", "sequence_number": 1, "item_id": "msg_matrix", "output_index": 0, "content_index": 0, "delta": text, "logprobs": [], }, { "type": "response.completed", "sequence_number": 2, "response": _response_payload(status="completed", text=text), }, ) return "".join(f"data: {json.dumps(event)}\n\n" for event in events) async def _collect(stream: AsyncIterator[StreamOutput]) -> str: return "".join([frame async for packet in stream for frame in packet.frames]) @pytest.mark.asyncio async def test_chat_upstream_accepts_both_ingress_protocols_directly() -> None: requests: list[httpx2.Request] = [] def handler(request: httpx2.Request) -> httpx2.Response: requests.append(request) return httpx2.Response( 200, headers={"content-type": "text/event-stream"}, text=_chat_sse("chat-ok"), ) client = _client(handler) config = make_provider_config( api_key="test-key", base_url="https://provider.invalid/v1", ) with patch( "free_claude_code.providers.openai_chat.client.AsyncOpenAI", return_value=client, ): provider = OpenAIChatProvider( config, profile=OpenAIChatProfile( OpenAIChatRequestPolicy( provider_name="MATRIX_CHAT", reasoning_replay=ReasoningReplayMode.REASONING_CONTENT, ), NO_REASONING, ), admission=immediate_admission(provider_name="MATRIX_CHAT"), ) try: messages_body = await _collect( provider.stream_messages( _messages_request(), input_tokens=2, request_id="req_matrix_messages_chat", response_model="public-model", ) ) responses_body = await _collect( provider.stream_responses( _responses_request(), input_tokens=2, request_id="req_matrix_responses_chat", response_model="public-model", ) ) finally: await provider.cleanup() assert [request.url.path for request in requests] == [ "/v1/chat/completions", "/v1/chat/completions", ] messages_events = parse_sse_text(messages_body) assert_anthropic_stream_contract(messages_events) assert text_content(messages_events) == "chat-ok" responses_events = parse_sse_text(responses_body) assert responses_events[0].event == "response.created" assert responses_events[-1].event == "response.completed" assert responses_events[-1].data["response"]["model"] == "public-model" assert ( responses_events[-1].data["response"]["output"][0]["content"][0]["text"] == "chat-ok" ) @pytest.mark.asyncio async def test_responses_upstream_accepts_both_ingress_protocols_directly() -> None: requests: list[httpx2.Request] = [] def handler(request: httpx2.Request) -> httpx2.Response: requests.append(request) return httpx2.Response( 200, headers={"content-type": "text/event-stream"}, text=_responses_sse("responses-ok"), ) client = _client(handler) transport = OpenAIResponsesTransport( client=client, admission=immediate_admission(provider_name="MATRIX_RESPONSES"), provider_name="MATRIX_RESPONSES", read_timeout_s=120.0, log_raw_sse_events=False, ) try: messages_body = await _collect( transport.stream_messages( _messages_request(), input_tokens=2, request_id="req_matrix_messages_responses", response_model="public-model", reasoning=DEFAULT_REASONING_POLICY, ) ) responses_body = await _collect( transport.stream_responses( _responses_request(), input_tokens=2, request_id="req_matrix_responses_responses", response_model="public-model", reasoning=DEFAULT_REASONING_POLICY, ) ) finally: await client.close() assert [request.url.path for request in requests] == [ "/v1/responses", "/v1/responses", ] messages_events = parse_sse_text(messages_body) assert_anthropic_stream_contract(messages_events) assert text_content(messages_events) == "responses-ok" responses_events = parse_sse_text(responses_body) assert [event.event for event in responses_events] == [ "response.created", "response.output_text.delta", "response.completed", ] assert responses_events[0].data["response"]["id"] == "resp_matrix" assert responses_events[-1].data["response"]["model"] == "public-model" assert ( responses_events[-1].data["response"]["output"][0]["content"][0]["text"] == "responses-ok" ) @pytest.mark.asyncio async def test_image_tool_output_remains_visual_across_all_protocol_cells() -> None: chat_requests: list[httpx2.Request] = [] responses_requests: list[httpx2.Request] = [] def chat_handler(request: httpx2.Request) -> httpx2.Response: chat_requests.append(request) return httpx2.Response( 200, headers={"content-type": "text/event-stream"}, text=_chat_sse("chat-ok"), ) def responses_handler(request: httpx2.Request) -> httpx2.Response: responses_requests.append(request) return httpx2.Response( 200, headers={"content-type": "text/event-stream"}, text=_responses_sse("responses-ok"), ) chat_client = _client(chat_handler) config = make_provider_config( api_key="test-key", base_url="https://provider.invalid/v1", ) with patch( "free_claude_code.providers.openai_chat.client.AsyncOpenAI", return_value=chat_client, ): chat_provider = OpenAIChatProvider( config, profile=OpenAIChatProfile( OpenAIChatRequestPolicy( provider_name="MATRIX_CHAT", reasoning_replay=ReasoningReplayMode.REASONING_CONTENT, ), NO_REASONING, ), admission=immediate_admission(provider_name="MATRIX_CHAT"), ) responses_client = _client(responses_handler) responses_transport = OpenAIResponsesTransport( client=responses_client, admission=immediate_admission(provider_name="MATRIX_RESPONSES"), provider_name="MATRIX_RESPONSES", read_timeout_s=120.0, log_raw_sse_events=False, ) try: await _collect( chat_provider.stream_messages( _image_messages_request(), input_tokens=2, request_id="req_matrix_image_messages_chat", response_model="public-model", ) ) await _collect( chat_provider.stream_responses( _image_responses_request(), input_tokens=2, request_id="req_matrix_image_responses_chat", response_model="public-model", ) ) await _collect( responses_transport.stream_messages( _image_messages_request(), input_tokens=2, request_id="req_matrix_image_messages_responses", response_model="public-model", reasoning=DEFAULT_REASONING_POLICY, ) ) await _collect( responses_transport.stream_responses( _image_responses_request(), input_tokens=2, request_id="req_matrix_image_responses_responses", response_model="public-model", reasoning=DEFAULT_REASONING_POLICY, ) ) finally: await chat_provider.cleanup() await responses_client.close() image_url = "https://images.example.test/result.png" messages_chat = json.loads(chat_requests[0].content) responses_chat = json.loads(chat_requests[1].content) messages_responses = json.loads(responses_requests[0].content) responses_responses = json.loads(responses_requests[1].content) for chat_body in (messages_chat, responses_chat): tool_message = next( message for message in chat_body["messages"] if message["role"] == "tool" ) assert image_url not in tool_message["content"] assert any( part.get("image_url", {}).get("url") == image_url for message in chat_body["messages"] if message["role"] == "user" and isinstance(message["content"], list) for part in message["content"] ) assert without_empty_reasoning(messages_responses["input"])[1] == { "type": "function_call_output", "call_id": "call_image", "output": [ {"type": "input_text", "text": "result"}, {"type": "input_image", "image_url": image_url}, ], } assert ( without_empty_reasoning(responses_responses["input"]) == _image_responses_request().input )