import json
from collections.abc import AsyncIterator, Mapping
from typing import Any
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from fastapi.responses import JSONResponse, StreamingResponse
from free_claude_code.api.handlers import (
MessagesHandler,
ResponsesHandler,
TokenCountHandler,
)
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic.models import (
Message,
MessagesRequest,
TokenCountRequest,
)
from free_claude_code.core.anthropic.streaming import format_sse_event
from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.core.stream_output import StreamOutput
from free_claude_code.core.stream_recovery import ContinuationSeed
from tests.web_tools_support import StubWebToolsClient
_LEGACY_CLASSIFIER_SYSTEM = (
"You are a security monitor. Respond with yes or no."
)
_CURRENT_CLASSIFIER_SYSTEM = (
"Classify the command's safety. Output N where N is the "
"numeric severity."
)
_CLASSIFIER_USER = (
"\nUser: review the repo\nBash: inspect the requested file\n"
""
)
class FakeProvider:
def __init__(self, events: list[str] | None = None) -> None:
self.requests: list[MessagesRequest] = []
self.responses_requests: list[OpenAIResponsesRequest] = []
self.stream_kwargs: list[dict[str, Any]] = []
self.events = events or [
'event: message_start\ndata: {"type":"message_start"}\n\n',
'event: message_stop\ndata: {"type":"message_stop"}\n\n',
]
async def cleanup(self) -> None:
return None
async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
return frozenset({ProviderModelInfo("test-model")})
async def stream_messages(
self,
request: MessagesRequest,
input_tokens: int = 0,
*,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
request_headers: Mapping[str, str] | None = None,
model_info: ProviderModelInfo | None = None,
continuation: ContinuationSeed | None = None,
) -> AsyncIterator[StreamOutput]:
self.requests.append(request)
self.stream_kwargs.append(
{
"input_tokens": input_tokens,
"request_id": request_id,
"response_model": response_model,
"reasoning": reasoning,
}
)
for event in self.events:
yield StreamOutput((event,))
async def stream_responses(
self,
request: OpenAIResponsesRequest,
input_tokens: int = 0,
*,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
request_headers: Mapping[str, str] | None = None,
model_info: ProviderModelInfo | None = None,
continuation: ContinuationSeed | None = None,
) -> AsyncIterator[StreamOutput]:
self.responses_requests.append(request)
self.stream_kwargs.append(
{
"input_tokens": input_tokens,
"request_id": request_id,
"response_model": response_model,
"reasoning": reasoning,
}
)
yield StreamOutput(
('event: response.completed\ndata: {"type":"response.completed"}\n\n',)
)
async def _streaming_body_text(response: StreamingResponse) -> str:
parts: list[str] = []
async for chunk in response.body_iterator:
if isinstance(chunk, bytes):
parts.append(chunk.decode("utf-8"))
else:
parts.append(str(chunk))
return "".join(parts)
def _json_response_content(response: JSONResponse) -> dict[str, Any]:
content = json.loads(bytes(response.body).decode("utf-8"))
assert isinstance(content, dict)
return content
def _trace_events(trace_mock: MagicMock, event: str) -> list[dict[str, Any]]:
return [
dict(call.kwargs)
for call in trace_mock.call_args_list
if call.kwargs.get("event") == event
]
@pytest.mark.asyncio
async def test_messages_handler_passes_routed_request_and_stream_metadata() -> None:
provider = FakeProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=True,
messages=[Message(role="user", content="hi")],
)
response = await handler.create(request)
assert isinstance(response, StreamingResponse)
body = await _streaming_body_text(response)
assert "message_start" in body
assert provider.requests[0].model == "test-model"
assert provider.stream_kwargs[0]["input_tokens"] > 0
assert provider.stream_kwargs[0]["request_id"].startswith("req_")
assert provider.stream_kwargs[0]["response_model"] == "nvidia_nim/test-model"
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()
assert len(provider.requests) == 1
@pytest.mark.asyncio
@pytest.mark.parametrize("stream", [True, False])
@pytest.mark.parametrize("content,max_tokens", [("hi", 100), ("quota", 1)])
async def test_messages_handler_startup_invalid_request_stays_http_error(
stream: bool,
content: str,
max_tokens: int,
) -> None:
class RejectStartupProvider(FakeProvider):
def stream_messages(
self,
request: MessagesRequest,
input_tokens: int = 0,
*,
reasoning: ReasoningPolicy,
model_info: ProviderModelInfo | None = None,
**kwargs: object,
) -> AsyncIterator[StreamOutput]:
raise InvalidRequestError("bad tool shape")
provider = RejectStartupProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=max_tokens,
messages=[Message(role="user", content=content)],
stream=stream,
)
if stream:
response = await handler.create(request)
assert isinstance(response, JSONResponse)
assert response.status_code == 400
assert json.loads(bytes(response.body))["error"]["message"] == "bad tool shape"
else:
with pytest.raises(InvalidRequestError, match="bad tool shape"):
await handler.create(request)
@pytest.mark.asyncio
@pytest.mark.parametrize("stream", [True, False])
@pytest.mark.parametrize(
"content,system,max_tokens",
[
pytest.param("hi", None, 100, id="ordinary"),
pytest.param("quota", None, 1, id="quota"),
pytest.param(
"extract command\nCommand: git status --short",
None,
100,
id="prefix",
),
pytest.param(
"hello",
'Generate a concise, sentence-case title. Return JSON with a single "title" field.',
100,
id="title",
),
pytest.param("[SUGGESTION MODE: next]", None, 100, id="suggestion"),
pytest.param(
"Command: cat README.md\nOutput: file contents\n",
"Extract any file paths that this command output contains.",
100,
id="filepath",
),
],
)
async def test_messages_handler_forwards_utility_requests(
stream: bool,
content: str,
system: str | None,
max_tokens: int,
) -> None:
provider = FakeProvider(
[
format_sse_event(
"message_start",
{
"type": "message_start",
"message": {
"id": "msg_test",
"type": "message",
"role": "assistant",
"content": [],
"model": "test-model",
"stop_reason": None,
"stop_sequence": None,
"usage": {"input_tokens": 7, "output_tokens": 1},
},
},
),
format_sse_event(
"content_block_start",
{
"type": "content_block_start",
"index": 0,
"content_block": {"type": "text", "text": ""},
},
),
format_sse_event(
"content_block_delta",
{
"type": "content_block_delta",
"index": 0,
"delta": {"type": "text_delta", "text": "OK"},
},
),
format_sse_event(
"content_block_stop", {"type": "content_block_stop", "index": 0}
),
format_sse_event(
"message_delta",
{
"type": "message_delta",
"delta": {"stop_reason": "end_turn", "stop_sequence": None},
"usage": {
"input_tokens": 20,
"output_tokens": 2,
"cache_read_input_tokens": 10,
},
},
),
format_sse_event("message_stop", {"type": "message_stop"}),
]
)
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=max_tokens,
stream=stream,
system=system,
messages=[Message(role="user", content=content)],
)
response = await handler.create(request)
if stream:
assert isinstance(response, StreamingResponse)
assert response.media_type == "text/event-stream"
wire = await _streaming_body_text(response)
events = [
json.loads(line[6:])
for line in wire.splitlines()
if line.startswith("data: ")
]
assert [event["type"] for event in events] == [
"message_start",
"content_block_start",
"content_block_delta",
"content_block_stop",
"message_delta",
"message_stop",
]
assert events[2]["delta"]["text"] == "OK"
assert events[4]["usage"] == {
"input_tokens": 20,
"output_tokens": 2,
"cache_read_input_tokens": 10,
}
else:
assert isinstance(response, JSONResponse)
assert len(provider.requests) == 1
forwarded = provider.requests[0]
assert forwarded.model == "test-model"
assert forwarded.messages == request.messages
assert forwarded.system == request.system
assert forwarded.max_tokens == request.max_tokens
if stream:
return
assert isinstance(response, JSONResponse)
assert response.headers["content-type"].startswith("application/json")
body = _json_response_content(response)
assert body["id"] == "msg_test"
assert body["type"] == "message"
assert body["role"] == "assistant"
assert body["model"] == "test-model"
assert body["content"] == [{"type": "text", "text": "OK"}]
assert body["stop_reason"] == "end_turn"
assert body["usage"] == {
"input_tokens": 20,
"output_tokens": 2,
"cache_read_input_tokens": 10,
}
@pytest.mark.asyncio
async def test_messages_handler_returns_error_json_for_stream_false_sse_error() -> None:
provider = FakeProvider(
[
format_sse_event(
"error",
{
"type": "error",
"error": {"type": "api_error", "message": "upstream failed"},
},
)
]
)
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=False,
messages=[Message(role="user", content="hi")],
)
response = await handler.create(request)
assert isinstance(response, JSONResponse)
assert response.status_code == 500
assert response.headers["x-should-retry"] == "false"
body = _json_response_content(response)
assert body["type"] == "error"
assert body["error"] == {"type": "api_error", "message": "upstream failed"}
assert body["request_id"].startswith("req_")
@pytest.mark.asyncio
async def test_messages_handler_discards_partial_stream_false_output_on_error() -> None:
provider = FakeProvider(
[
format_sse_event(
"message_start",
{
"type": "message_start",
"message": {
"id": "msg_partial",
"type": "message",
"role": "assistant",
"content": [],
"model": "test-model",
"stop_reason": None,
"stop_sequence": None,
"usage": {"input_tokens": 1, "output_tokens": 1},
},
},
),
format_sse_event(
"content_block_start",
{
"type": "content_block_start",
"index": 0,
"content_block": {"type": "text", "text": ""},
},
),
format_sse_event(
"content_block_delta",
{
"type": "content_block_delta",
"index": 0,
"delta": {"type": "text_delta", "text": "incomplete"},
},
),
format_sse_event(
"error",
{
"type": "error",
"error": {
"type": "overloaded_error",
"message": "provider overloaded",
},
},
),
]
)
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=False,
messages=[Message(role="user", content="hi")],
)
response = await handler.create(request)
assert isinstance(response, JSONResponse)
assert response.status_code == 529
assert response.headers["x-should-retry"] == "false"
body = _json_response_content(response)
assert body["error"] == {
"type": "overloaded_error",
"message": "provider overloaded",
}
assert "content" not in body
@pytest.mark.asyncio
async def test_messages_handler_stream_false_provider_exception_keeps_status() -> None:
class FailingProvider(FakeProvider):
async def stream_messages(
self,
request: Any,
input_tokens: int = 0,
*,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
request_headers: Mapping[str, str] | None = None,
model_info: ProviderModelInfo | None = None,
continuation: ContinuationSeed | None = None,
) -> AsyncIterator[StreamOutput]:
self.requests.append(request)
self.stream_kwargs.append(
{
"input_tokens": input_tokens,
"request_id": request_id,
"response_model": response_model,
"reasoning": reasoning,
}
)
raise ExecutionFailure(
kind=FailureKind.RATE_LIMIT,
status_code=429,
message="upstream is busy",
retryable=True,
)
yield StreamOutput(("unreachable",))
provider = FailingProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=False,
messages=[Message(role="user", content="hi")],
)
response = await handler.create(request)
assert isinstance(response, JSONResponse)
assert response.status_code == 429
assert response.headers["x-should-retry"] == "false"
body = _json_response_content(response)
assert body["error"] == {
"type": "rate_limit_error",
"message": "upstream is busy",
}
@pytest.mark.asyncio
@pytest.mark.parametrize(
("system", "classifier_stop_sequence"),
[
(_CURRENT_CLASSIFIER_SYSTEM, ""),
(_LEGACY_CLASSIFIER_SYSTEM, ""),
],
)
async def test_messages_handler_normalizes_safety_classifier_policy(
system: str,
classifier_stop_sequence: str,
) -> None:
provider = FakeProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=True,
system=system,
stop_sequences=[classifier_stop_sequence],
messages=[Message(role="user", content=_CLASSIFIER_USER)],
)
with patch("free_claude_code.api.handlers.messages.trace_event") as trace_mock:
response = await handler.create(request)
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()
assert provider.requests[0].model == "test-model"
assert provider.requests[0].system == system
assert provider.requests[0].stop_sequences is None
assert provider.requests[0].stop_sequences is None
assert request.stop_sequences == [classifier_stop_sequence]
assert _trace_events(
trace_mock, "free_claude_code.api.route.safety_classifier_policy"
) == [
{
"stage": "routing",
"event": "free_claude_code.api.route.safety_classifier_policy",
"source": "api",
"model": "nvidia_nim/test-model",
"classifier_stop_sequence": classifier_stop_sequence,
"reasoning_changed": True,
"stop_sequence_removed": True,
}
]
@pytest.mark.asyncio
async def test_messages_handler_preserves_thinking_for_non_classifier() -> None:
provider = FakeProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=True,
system="Explain XML formats.",
stop_sequences=[""],
messages=[
Message(
role="user",
content=(
"Explain ... and a tag "
"without making a verdict."
),
)
],
)
with patch("free_claude_code.api.handlers.messages.trace_event") as trace_mock:
response = await handler.create(request)
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()
assert provider.requests[0].stop_sequences == [""]
assert (
_trace_events(
trace_mock,
"free_claude_code.api.route.safety_classifier_policy",
)
== []
)
@pytest.mark.asyncio
async def test_messages_handler_tolerates_required_thinking_for_classifier() -> None:
provider = FakeProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="claude-3-freecc-no-thinking/nvidia_nim/test-model",
max_tokens=100,
stream=True,
system=_LEGACY_CLASSIFIER_SYSTEM,
stop_sequences=[""],
messages=[Message(role="user", content=_CLASSIFIER_USER)],
)
with patch("free_claude_code.api.handlers.messages.trace_event") as trace_mock:
response = await handler.create(request)
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()
assert provider.requests[0].stop_sequences is None
assert request.stop_sequences == [""]
assert _trace_events(
trace_mock, "free_claude_code.api.route.safety_classifier_policy"
) == [
{
"stage": "routing",
"event": "free_claude_code.api.route.safety_classifier_policy",
"source": "api",
"model": "claude-3-freecc-no-thinking/nvidia_nim/test-model",
"classifier_stop_sequence": "",
"reasoning_changed": True,
"stop_sequence_removed": True,
}
]
@pytest.mark.asyncio
async def test_messages_handler_prefers_no_thinking_without_classifier_stop_hint() -> (
None
):
provider = FakeProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=True,
system=_CURRENT_CLASSIFIER_SYSTEM,
messages=[Message(role="user", content=_CLASSIFIER_USER)],
)
with patch("free_claude_code.api.handlers.messages.trace_event") as trace_mock:
response = await handler.create(request)
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()
assert provider.requests[0].stop_sequences is None
assert _trace_events(
trace_mock, "free_claude_code.api.route.safety_classifier_policy"
) == [
{
"stage": "routing",
"event": "free_claude_code.api.route.safety_classifier_policy",
"source": "api",
"model": "nvidia_nim/test-model",
"classifier_stop_sequence": "",
"reasoning_changed": True,
"stop_sequence_removed": False,
}
]
@pytest.mark.asyncio
async def test_messages_handler_preserves_unowned_classifier_stop_sequences() -> None:
provider = FakeProvider()
handler = MessagesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
web_tools=StubWebToolsClient(),
)
original_stops = ["custom", "", "custom", "", "tail"]
request = MessagesRequest(
model="nvidia_nim/test-model",
max_tokens=100,
stream=True,
system=_CURRENT_CLASSIFIER_SYSTEM,
stop_sequences=original_stops,
messages=[Message(role="user", content=_CLASSIFIER_USER)],
)
response = await handler.create(request)
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()
assert provider.requests[0].stop_sequences == [
"custom",
"custom",
"tail",
]
assert provider.requests[0].stop_sequences == ["custom", "custom", "tail"]
assert request.stop_sequences == original_stops
@pytest.mark.asyncio
async def test_responses_handler_forwards_quota_prompt() -> None:
provider = FakeProvider()
handler = ResponsesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
)
response = await handler.create(
OpenAIResponsesRequest(
model="nvidia_nim/test-model",
input="quota check",
)
)
assert isinstance(response, StreamingResponse)
body = await _streaming_body_text(response)
assert "response.completed" in body
assert provider.responses_requests[0].input == "quota check"
@pytest.mark.asyncio
async def test_responses_handler_does_not_apply_safety_classifier_policy() -> None:
provider = FakeProvider()
handler = ResponsesHandler(
Settings(),
provider_resolver=AsyncMock(side_effect=lambda _, _api_key_number: provider),
)
with patch("free_claude_code.api.handlers.messages.trace_event") as trace_mock:
response = await handler.create(
OpenAIResponsesRequest(
model="nvidia_nim/test-model",
input=_CLASSIFIER_USER,
instructions=_CURRENT_CLASSIFIER_SYSTEM,
)
)
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()
assert (
_trace_events(
trace_mock,
"free_claude_code.api.route.safety_classifier_policy",
)
== []
)
def test_token_count_handler_routes_and_counts_tokens() -> None:
handler = TokenCountHandler(
Settings(),
token_counter=lambda messages, system, tools: len(messages) + 41,
)
with patch("free_claude_code.api.handlers.token_count.trace_event") as trace:
response = handler.count(
TokenCountRequest(
model="nvidia_nim/test-model",
messages=[Message(role="user", content="hi")],
),
request_id="req_ingress",
)
assert response.input_tokens == 42
assert all(
call.kwargs["request_id"] == "req_ingress" for call in trace.call_args_list
)