Spaces:
Running
Running
Download tests/api/test_chat_tool_identity_api.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 17.3 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/api/test_chat_tool_identity_api.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/tests/api/test_chat_tool_identity_api.py
-
curl -L -o test_chat_tool_identity_api.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/api/test_chat_tool_identity_api.py
17.3 kB
| """Public API routes preserve parallel Chat calls with imperfect indexes.""" | |
| import json | |
| import httpx2 | |
| import pytest | |
| from fastapi.testclient import TestClient | |
| from openai import AsyncOpenAI | |
| from free_claude_code.application.response_collection import collect_response | |
| from free_claude_code.config.settings import Settings | |
| from free_claude_code.core.anthropic.stream_contracts import parse_sse_text | |
| from free_claude_code.core.failures import ExecutionFailure | |
| from free_claude_code.providers.google_openai import GoogleOpenAIProvider | |
| from free_claude_code.providers.vertex.client import _PROFILE as GOOGLE_PROFILE | |
| from tests.api.support import create_test_app | |
| from tests.api.test_hidden_stream_retries import delivered | |
| from tests.api.test_tool_call_buffer_transports import _tools | |
| from tests.providers.support import immediate_admission, make_provider_config | |
| from tests.providers.test_chat_tool_identity import call | |
| from tests.providers.test_history_transports import _harness, _saved_reply | |
| from tests.providers.test_native_tool_arguments import tool_events | |
| def chat_chunk(delta, finish=None): | |
| return { | |
| "id": "chat_identity", | |
| "object": "chat.completion.chunk", | |
| "created": 0, | |
| "model": "test-model", | |
| "choices": [{"index": 0, "delta": delta, "finish_reason": finish}], | |
| } | |
| def google_compat_api_response(monkeypatch, events, wire, streaming, *, max_attempts=2): | |
| sent = [] | |
| upstream = ( | |
| "".join(f"data: {json.dumps(event)}\n\n" for event in events) | |
| + "data: [DONE]\n\n" | |
| ) | |
| def reply(request): | |
| sent.append(json.loads(request.content)) | |
| return httpx2.Response( | |
| 200, headers={"content-type": "text/event-stream"}, content=upstream | |
| ) | |
| sdk = AsyncOpenAI( | |
| api_key="fixture", | |
| base_url="https://fixture.invalid/v1", | |
| max_retries=0, | |
| http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(reply)), | |
| ) | |
| monkeypatch.setattr( | |
| "free_claude_code.providers.openai_chat.client.AsyncOpenAI", lambda **_: sdk | |
| ) | |
| provider = GoogleOpenAIProvider( | |
| make_provider_config(api_key="fixture", base_url="https://fixture.invalid/v1"), | |
| profile=GOOGLE_PROFILE, | |
| admission=immediate_admission(max_attempts=max_attempts), | |
| ) | |
| app = create_test_app( | |
| Settings(MODEL="vertex/test-model", ENABLE_WEB_SERVER_TOOLS=False), | |
| providers={"vertex": provider}, | |
| ) | |
| schema = {"type": "object", "properties": {"path": {"type": "string"}}} | |
| if wire == "messages": | |
| body = { | |
| "model": "vertex/test-model", | |
| "max_tokens": 100, | |
| "stream": streaming, | |
| "messages": [{"role": "user", "content": "read both"}], | |
| "tools": [{"name": "read", "input_schema": schema}], | |
| } | |
| else: | |
| body = { | |
| "model": "vertex/test-model", | |
| "stream": True, | |
| "input": "read both", | |
| "tools": [{"type": "function", "name": "read", "parameters": schema}], | |
| } | |
| with TestClient(app) as client: | |
| response = client.post(f"/v1/{wire}", json=body) | |
| return response, sent | |
| def test_google_compat_parallel_calls_reach_public_api( | |
| monkeypatch, deltas, expected_ids, wire, streaming | |
| ): | |
| events = [chat_chunk({"tool_calls": calls}) for calls in deltas] | |
| events.append(chat_chunk({}, "tool_calls")) | |
| response, sent = google_compat_api_response(monkeypatch, events, wire, streaming) | |
| assert response.status_code == 200, response.text | |
| assert len(sent) == 1 | |
| if not streaming: | |
| values = [ | |
| (item["id"], item["name"], item["input"]) | |
| for item in response.json()["content"] | |
| if item["type"] == "tool_use" | |
| ] | |
| elif wire == "messages": | |
| calls = {} | |
| events = parse_sse_text(response.text) | |
| assert events[-1].event == "message_stop" | |
| for event in events: | |
| data = event.data | |
| block = data.get("content_block", {}) | |
| if block.get("type") == "tool_use": | |
| calls[data["index"]] = { | |
| "id": block["id"], | |
| "name": block["name"], | |
| "arguments": "", | |
| } | |
| if data.get("delta", {}).get("type") == "input_json_delta": | |
| calls[data["index"]]["arguments"] += data["delta"]["partial_json"] | |
| values = [ | |
| (item["id"], item["name"], json.loads(item["arguments"])) | |
| for item in calls.values() | |
| ] | |
| else: | |
| events = parse_sse_text(response.text) | |
| assert events[-1].event == "response.completed" | |
| values = [ | |
| (item["call_id"], item["name"], json.loads(item["arguments"])) | |
| for item in events[-1].data["response"]["output"] | |
| if item["type"] == "function_call" | |
| ] | |
| assert [(name, arguments) for _, name, arguments in values] == [ | |
| ("read", {"path": "a"}), | |
| ("read", {"path": "b"}), | |
| ] | |
| assert len({tool_id for tool_id, _, _ in values}) == 2 | |
| for (tool_id, _, _), expected_id in zip(values, expected_ids, strict=True): | |
| if expected_id is None: | |
| assert tool_id.startswith("tool_") | |
| else: | |
| assert tool_id == expected_id | |
| def test_google_compat_unresolvable_calls_cannot_complete( | |
| monkeypatch, anonymous, wire, streaming | |
| ): | |
| if anonymous: | |
| events = [ | |
| chat_chunk( | |
| { | |
| "tool_calls": [ | |
| call(None, None, '{"path":"a"}'), | |
| call(None, None, '{"path":"b"}'), | |
| ] | |
| } | |
| ) | |
| ] | |
| else: | |
| # Either call could own the index-only fragment. Both assignments | |
| # would produce valid JSON, so argument validation cannot decide. | |
| events = [ | |
| chat_chunk( | |
| { | |
| "tool_calls": [ | |
| call(0, "call_a", '{"path":"a'), | |
| call(None, "call_b", '{"path":"b'), | |
| ] | |
| } | |
| ), | |
| chat_chunk({"tool_calls": [call(0, None, "_part", name=None)]}), | |
| chat_chunk({"tool_calls": [call(0, "call_b", '"}', name=None)]}), | |
| chat_chunk({"tool_calls": [call(0, "call_a", '"}', name=None)]}), | |
| ] | |
| events.append(chat_chunk({}, "tool_calls")) | |
| response, sent = google_compat_api_response( | |
| monkeypatch, events, wire, streaming, max_attempts=1 | |
| ) | |
| assert len(sent) == 1 | |
| if streaming: | |
| # Lifecycle metadata is immediate, while unfinished calls stay private. | |
| assert response.status_code == 200 | |
| output = parse_sse_text(response.text) | |
| assert output[-1].event == ( | |
| "error" if wire == "messages" else "response.failed" | |
| ) | |
| assert "call_a" not in response.text and "call_b" not in response.text | |
| else: | |
| assert response.status_code == 502 | |
| assert isinstance(response.json().get("error"), dict) | |
| def completed_arguments(events, wire): | |
| if wire == "messages": | |
| return "".join( | |
| event.data["delta"]["partial_json"] | |
| for event in events | |
| if event.data.get("delta", {}).get("type") == "input_json_delta" | |
| ) | |
| return "".join( | |
| event.data["item"]["arguments"] | |
| for event in events | |
| if event.event == "response.output_item.done" | |
| and event.data["item"]["type"] == "function_call" | |
| ) | |
| def ambiguous_events(stop, *, incomplete=False, fragment_index=0): | |
| events = [ | |
| chat_chunk( | |
| { | |
| "tool_calls": [ | |
| call( | |
| 0, | |
| "call_abandoned_a", | |
| '{"path":' if incomplete else '{"path":"a"}', | |
| ), | |
| call( | |
| 0, | |
| "call_abandoned_b", | |
| '{"path":' if incomplete else '{"path":"b"}', | |
| ), | |
| ] | |
| } | |
| ) | |
| ] | |
| if stop == "before": | |
| events.append(chat_chunk({}, "tool_calls")) | |
| events.append( | |
| chat_chunk( | |
| {"tool_calls": [call(fragment_index, None, "uncertain", name=None)]}, | |
| "tool_calls" if stop == "same" else None, | |
| ) | |
| ) | |
| return events | |
| async def test_public_identity_failure_respects_delivery_stop_and_budget( | |
| monkeypatch, wire, prefix, stop, max_attempts, fragment_index | |
| ): | |
| first = ambiguous_events(stop, fragment_index=fragment_index) | |
| if prefix: | |
| first.insert( | |
| 0, | |
| chat_chunk( | |
| { | |
| "reasoning_details": [ | |
| { | |
| "type": "reasoning.text", | |
| "text": "already visible", | |
| "index": 0, | |
| } | |
| ] | |
| } | |
| if prefix == "reasoning_details" | |
| else {prefix: "already visible"} | |
| ), | |
| ) | |
| async with _harness( | |
| "chat", | |
| lambda bodies: ( | |
| 200, | |
| first if len(bodies) == 1 else tool_events("chat", '{"path":"winning"}'), | |
| ), | |
| max_attempts=max_attempts, | |
| ) as (send, bodies, _): | |
| result = await delivered( | |
| send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire | |
| ) | |
| # Unsigned readable reasoning follows the same continuation policy as text. | |
| retry = False | |
| assert len(bodies) == (2 if retry else 1) | |
| assert ("call_abandoned" in result) == (stop == "before") | |
| events = parse_sse_text(result) | |
| visible_prefix = prefix is not None | |
| assert ("already visible" in result) == visible_prefix | |
| if retry: | |
| assert completed_arguments(events, wire) == '{"path":"winning"}' | |
| assert events[-1].event == ( | |
| "message_stop" if wire == "messages" else "response.completed" | |
| ) | |
| assert bodies[1]["tools"] == bodies[0]["tools"] | |
| if visible_prefix: | |
| assert "already visible" in str(bodies[1]) | |
| else: | |
| assert bodies[0] == bodies[1] | |
| else: | |
| assert events[-1].event == ( | |
| "error" if wire == "messages" else "response.failed" | |
| ) | |
| assert "winning" not in result | |
| assert any( | |
| event.event | |
| in {"response.function_call_arguments.done", "response.output_item.done"} | |
| and ( | |
| event.event != "response.output_item.done" | |
| or event.data["item"]["type"] == "function_call" | |
| ) | |
| for event in events | |
| ) == (stop == "before" and wire == "responses") | |
| async def test_private_identity_failure_never_salvages_or_repairs( | |
| monkeypatch, wire, incomplete, committed, stop, max_attempts, fragment_index | |
| ): | |
| first = ambiguous_events(stop, incomplete=incomplete, fragment_index=fragment_index) | |
| async with _harness("chat", lambda _: (200, first), max_attempts=max_attempts) as ( | |
| send, | |
| bodies, | |
| _, | |
| ): | |
| with pytest.raises(ExecutionFailure): | |
| await collect_response( | |
| send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), | |
| protocol=wire, | |
| ) | |
| assert len(bodies) == 1 | |
| async def test_google_compat_metadata_replays_under_each_public_id(wire, indexes, ids): | |
| first = [ | |
| chat_chunk( | |
| { | |
| "tool_calls": [ | |
| call( | |
| indexes[0], | |
| ids[0], | |
| '{"path":"a"}', | |
| metadata={"google": {"thought_signature": "sig-a"}}, | |
| ), | |
| call( | |
| indexes[1], | |
| ids[1], | |
| '{"path":"b"}', | |
| metadata={"google": {"thought_signature": "sig-b"}}, | |
| ), | |
| ] | |
| } | |
| ), | |
| chat_chunk({}, "tool_calls"), | |
| ] | |
| def gemini(): | |
| return GoogleOpenAIProvider( | |
| make_provider_config("fixture", "https://provider.invalid/v1"), | |
| profile=GOOGLE_PROFILE, | |
| admission=immediate_admission(max_attempts=2), | |
| ) | |
| async with _harness( | |
| "chat", | |
| lambda bodies: ( | |
| 200, | |
| first if len(bodies) == 1 else [chat_chunk({"content": "done"}, "stop")], | |
| ), | |
| chat_provider_factory=gemini, | |
| ) as (send, bodies, _): | |
| saved = await _saved_reply( | |
| send(wire, [{"role": "user", "content": "read both"}], tools=_tools(wire)), | |
| wire, | |
| ) | |
| if wire == "messages": | |
| calls = [item for item in saved[0]["content"] if item["type"] == "tool_use"] | |
| public_ids = [item["id"] for item in calls] | |
| followup = [ | |
| { | |
| "role": "assistant", | |
| "content": [ | |
| { | |
| "type": "tool_use", | |
| "id": item["id"], | |
| "name": item["name"], | |
| "input": item["input"], | |
| } | |
| for item in calls | |
| ], | |
| }, | |
| { | |
| "role": "user", | |
| "content": [ | |
| {"type": "tool_result", "tool_use_id": tool_id, "content": "ok"} | |
| for tool_id in public_ids | |
| ], | |
| }, | |
| ] | |
| else: | |
| calls = [item for item in saved if item["type"] == "function_call"] | |
| public_ids = [item["call_id"] for item in calls] | |
| followup = [ | |
| { | |
| "type": "function_call", | |
| "call_id": item["call_id"], | |
| "name": item["name"], | |
| "arguments": item["arguments"], | |
| } | |
| for item in calls | |
| ] + [ | |
| {"type": "function_call_output", "call_id": tool_id, "output": "ok"} | |
| for tool_id in public_ids | |
| ] | |
| assert len(set(public_ids)) == 2 | |
| await _saved_reply(send(wire, followup, tools=_tools(wire)), wire) | |
| replayed = next( | |
| row["tool_calls"] for row in bodies[1]["messages"] if row.get("tool_calls") | |
| ) | |
| assert [(item["id"], item["extra_content"]) for item in replayed] == [ | |
| (public_ids[0], {"google": {"thought_signature": "sig-a"}}), | |
| (public_ids[1], {"google": {"thought_signature": "sig-b"}}), | |
| ] | |