Spaces:
Running
Running
Download tests/api/test_chat_protocol_matrix.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 14.2 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/api/test_chat_protocol_matrix.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/tests/api/test_chat_protocol_matrix.py
-
curl -L -o test_chat_protocol_matrix.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/api/test_chat_protocol_matrix.py
14.2 kB
| """The Chat endpoint uses each upstream through the real HTTP boundary.""" | |
| import json | |
| from typing import Any | |
| import httpx | |
| import httpx2 | |
| import pytest | |
| from fastapi.testclient import TestClient | |
| from free_claude_code.config.settings import Settings | |
| from tests.api.support import create_test_app, provider_manager_for_app | |
| from tests.providers.test_custom_provider import completion, definition, provider | |
| def test_chat_http_dispatch_preserves_controls_credentials_and_public_model( | |
| wire, streaming | |
| ): | |
| sent = [] | |
| def reply(request): | |
| sent.append((json.loads(request.content), dict(request.headers))) | |
| module = httpx if wire == "anthropic_messages" else httpx2 | |
| return module.Response( | |
| 200, text=completion(wire), headers={"content-type": "text/event-stream"} | |
| ) | |
| configured = definition(api_format=wire, api_keys=["upstream-key"]) | |
| instance = provider(configured, openai_handler=reply, messages_handler=reply) | |
| app = create_test_app( | |
| Settings( | |
| MODEL=f"{configured.provider_id}/backend", | |
| custom_providers=(configured,), | |
| PROXY_AUTH_ENABLED=True, | |
| proxy_auth_token="ingress-key", | |
| ), | |
| providers={configured.provider_id: instance}, | |
| ) | |
| payload = { | |
| "model": "public", | |
| "messages": [{"role": "user", "content": "hello"}], | |
| "temperature": 0, | |
| "max_completion_tokens": 37, | |
| "stream": streaming, | |
| } | |
| with TestClient(app) as client: | |
| response = client.post( | |
| "/v1/chat/completions", | |
| json=payload, | |
| headers={"authorization": "Bearer ingress-key"}, | |
| ) | |
| assert response.status_code == 200, response.text | |
| assert response.headers["x-request-id"] | |
| if streaming: | |
| assert response.text.endswith("data: [DONE]\n\n") | |
| values = [ | |
| json.loads(line[6:]) | |
| for line in response.text.splitlines() | |
| if line.startswith("data: ") and line != "data: [DONE]" | |
| ] | |
| assert ( | |
| "".join( | |
| choice.get("delta", {}).get("content") or "" | |
| for value in values | |
| for choice in value.get("choices", []) | |
| ) | |
| == "Hello" | |
| ) | |
| assert all(value["model"] == "public" for value in values) | |
| else: | |
| assert response.json()["model"] == "public" | |
| assert response.json()["choices"][0]["message"]["content"] == "Hello" | |
| assert provider_manager_for_app(app)._current.active_leases == 0 | |
| assert len(sent) == 1 | |
| body, headers = sent[0] | |
| assert body["model"] == "backend" | |
| assert body["temperature"] == 0 | |
| limit = { | |
| "openai_chat": "max_completion_tokens", | |
| "openai_responses": "max_output_tokens", | |
| "anthropic_messages": "max_tokens", | |
| }[wire] | |
| assert body[limit] == 37 | |
| assert "ingress-key" not in json.dumps(headers) | |
| assert headers[ | |
| "x-api-key" if wire == "anthropic_messages" else "authorization" | |
| ].endswith("upstream-key") | |
| def test_chat_function_strictness_survives_upstream_translation(wire, strict): | |
| sent = [] | |
| def reply(request): | |
| sent.append(json.loads(request.content)) | |
| return httpx2.Response( | |
| 200, text=completion(wire), headers={"content-type": "text/event-stream"} | |
| ) | |
| configured = definition(api_format=wire) | |
| instance = provider(configured, openai_handler=reply) | |
| app = create_test_app( | |
| Settings( | |
| MODEL=f"{configured.provider_id}/backend", | |
| custom_providers=(configured,), | |
| ), | |
| providers={configured.provider_id: instance}, | |
| ) | |
| function = { | |
| "name": "weather", | |
| "parameters": { | |
| "type": "object", | |
| "properties": {"city": {"type": "string"}}, | |
| "required": ["city"] if strict.get("strict") else [], | |
| "additionalProperties": False, | |
| }, | |
| **strict, | |
| } | |
| with TestClient(app) as client: | |
| response = client.post( | |
| "/v1/chat/completions", | |
| json={ | |
| "model": "public", | |
| "messages": [{"role": "user", "content": "weather"}], | |
| "tools": [{"type": "function", "function": function}], | |
| }, | |
| ) | |
| assert response.status_code == 200, response.text | |
| assert len(sent) == 1 | |
| if wire == "openai_chat": | |
| assert sent[0]["tools"] == [{"type": "function", "function": function}] | |
| else: | |
| assert sent[0]["tools"] == [ | |
| {"type": "function", **function, "strict": strict.get("strict") is True} | |
| ] | |
| def test_chat_validation_and_auth_errors_use_openai_shape(): | |
| app = create_test_app( | |
| Settings(PROXY_AUTH_ENABLED=True, proxy_auth_token="ingress-key") | |
| ) | |
| with TestClient(app) as client: | |
| unauthenticated = client.post( | |
| "/v1/chat/completions", | |
| json={"model": "x", "messages": [{"role": "user", "content": "hi"}]}, | |
| ) | |
| assert unauthenticated.status_code == 401 | |
| assert "error" in unauthenticated.json() | |
| invalid = client.post( | |
| "/v1/chat/completions", | |
| json={"model": "x", "messages": []}, | |
| headers={"authorization": "Bearer ingress-key"}, | |
| ) | |
| assert invalid.status_code == 400 | |
| assert invalid.json()["error"]["type"] == "invalid_request_error" | |
| def test_native_chat_null_tool_delta_preserves_text_and_later_calls( | |
| streaming, with_tool | |
| ): | |
| from tests.api.test_four_protocol_matrix import matrix_app, response_value | |
| call = { | |
| "index": 0, | |
| "id": "call_read", | |
| "type": "function", | |
| "function": {"name": "read", "arguments": "{}"}, | |
| } | |
| deltas = [ | |
| {"role": "assistant", "content": "hello", "tool_calls": None}, | |
| *([{"tool_calls": [{**call, "function": None}]}] if with_tool else []), | |
| {"tool_calls": [call]} if with_tool else {"tool_calls": None}, | |
| ] | |
| def reply(_): | |
| events = [ | |
| { | |
| "id": "chatcmpl-a", | |
| "object": "chat.completion.chunk", | |
| "created": 1, | |
| "model": "backend", | |
| "choices": [ | |
| { | |
| "index": 0, | |
| "delta": delta, | |
| "finish_reason": ("tool_calls" if with_tool else "stop") | |
| if index == len(deltas) - 1 | |
| else None, | |
| } | |
| ], | |
| } | |
| for index, delta in enumerate(deltas) | |
| ] | |
| return httpx2.Response( | |
| 200, | |
| headers={"content-type": "text/event-stream"}, | |
| text="".join(f"data: {json.dumps(event)}\n\n" for event in events), | |
| ) | |
| with TestClient(matrix_app("chat", reply)) as client: | |
| response = client.post( | |
| "/v1/chat/completions", | |
| json={ | |
| "model": "public", | |
| "messages": [{"role": "user", "content": "hello"}], | |
| "stream": streaming, | |
| }, | |
| ) | |
| value = response_value(response, "chat", streaming) | |
| message = value["choices"][0]["message"] | |
| assert message["content"] == "hello" | |
| assert message["tool_calls"] == ( | |
| [{key: item for key, item in call.items() if key != "index"}] | |
| if with_tool | |
| else None | |
| ) | |
| if streaming: | |
| first = json.loads(response.text.splitlines()[0][6:]) | |
| assert first["choices"][0]["delta"]["tool_calls"] is None | |
| def test_chat_malformed_fields_fail_before_provider_execution(changes): | |
| app = create_test_app(Settings()) | |
| with TestClient(app) as client: | |
| response = client.post( | |
| "/v1/chat/completions", | |
| json={ | |
| "model": "public", | |
| "messages": [{"role": "user", "content": "hi"}], | |
| **changes, | |
| }, | |
| ) | |
| assert response.status_code == 400, response.text | |
| assert response.json()["error"]["type"] == "invalid_request_error" | |
| def test_native_chat_nullable_fields_accumulate_later_values( | |
| streaming, field, updates, expected | |
| ): | |
| from tests.api.test_four_protocol_matrix import matrix_app, response_value | |
| def reply(_): | |
| deltas = [ | |
| {"role": "assistant", field: None}, | |
| *[{field: value} for value in updates], | |
| {field: None, "content": "done"}, | |
| ] | |
| events = [ | |
| { | |
| "id": "chatcmpl-a", | |
| "object": "chat.completion.chunk", | |
| "created": 1, | |
| "model": "backend", | |
| "choices": [ | |
| { | |
| "index": 0, | |
| "delta": delta, | |
| "finish_reason": "stop" if index == len(deltas) - 1 else None, | |
| } | |
| ], | |
| } | |
| for index, delta in enumerate(deltas) | |
| ] | |
| return httpx2.Response( | |
| 200, | |
| headers={"content-type": "text/event-stream"}, | |
| text="".join(f"data: {json.dumps(event)}\n\n" for event in events), | |
| ) | |
| with TestClient(matrix_app("chat", reply)) as client: | |
| response = client.post( | |
| "/v1/chat/completions", | |
| json={ | |
| "model": "public", | |
| "messages": [{"role": "user", "content": "hello"}], | |
| "stream": streaming, | |
| }, | |
| ) | |
| value = response_value(response, "chat", streaming) | |
| assert value["choices"][0]["message"][field] == expected | |
| if streaming: | |
| first = json.loads(response.text.splitlines()[0][6:]) | |
| assert first["choices"][0]["delta"][field] is None | |
| def test_native_custom_tool_fragments_survive_public_chat_response(streaming): | |
| from tests.api.test_four_protocol_matrix import matrix_app, response_value | |
| chunks = [ | |
| { | |
| "index": 0, | |
| "id": "call_custom", | |
| "type": "custom", | |
| "custom": {"name": "code_exec", "input": "print("}, | |
| }, | |
| {"index": 0, "custom": {"input": "1)"}}, | |
| ] | |
| def reply(_): | |
| events: list[dict[str, Any]] = [ | |
| { | |
| "id": "chatcmpl-a", | |
| "object": "chat.completion.chunk", | |
| "created": 1, | |
| "model": "backend", | |
| "choices": [ | |
| { | |
| "index": 0, | |
| "delta": {"tool_calls": [chunk]}, | |
| "finish_reason": None, | |
| } | |
| ], | |
| } | |
| for chunk in chunks | |
| ] | |
| events.append( | |
| { | |
| "id": "chatcmpl-a", | |
| "object": "chat.completion.chunk", | |
| "created": 1, | |
| "model": "backend", | |
| "choices": [{"index": 0, "delta": {}, "finish_reason": "tool_calls"}], | |
| } | |
| ) | |
| return httpx2.Response( | |
| 200, | |
| headers={"content-type": "text/event-stream"}, | |
| text="".join(f"data: {json.dumps(event)}\n\n" for event in events), | |
| ) | |
| with TestClient(matrix_app("chat", reply)) as client: | |
| response = client.post( | |
| "/v1/chat/completions", | |
| json={ | |
| "model": "public", | |
| "messages": [{"role": "user", "content": "run"}], | |
| "stream": streaming, | |
| "tools": [{"type": "custom", "custom": {"name": "code_exec"}}], | |
| }, | |
| ) | |
| value = response_value(response, "chat", streaming) | |
| assert value["choices"][0]["message"]["tool_calls"] == [ | |
| { | |
| "id": "call_custom", | |
| "type": "custom", | |
| "custom": {"name": "code_exec", "input": "print(1)"}, | |
| } | |
| ] | |