Spaces:
Running
Running
Download tests/contracts/test_protocol_matrix.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 16.7 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/contracts/test_protocol_matrix.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/tests/contracts/test_protocol_matrix.py
-
curl -L -o test_protocol_matrix.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/contracts/test_protocol_matrix.py
16.7 kB
| """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]) | |
| 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" | |
| ) | |
| 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" | |
| ) | |
| 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 | |
| ) | |