"""Claude Auto mode exercises the real handler/provider request boundary.""" import json from types import SimpleNamespace from unittest.mock import AsyncMock, patch import httpx as native_httpx import httpx2 as httpx import pytest from fastapi.responses import JSONResponse, StreamingResponse from openai import APIError, AsyncOpenAI, BadRequestError from free_claude_code.api.handlers import MessagesHandler from free_claude_code.application.model_metadata import ProviderModelInfo from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS from free_claude_code.config.reasoning import FALLBACK_REASONING_PREFERENCES from free_claude_code.config.settings import Settings from free_claude_code.core.anthropic.models import MessagesRequest from free_claude_code.core.anthropic.stream_contracts import ( parse_sse_text, text_content, thinking_content, ) from free_claude_code.core.reasoning import ReasoningCapability from free_claude_code.providers.gemini import GeminiProvider from free_claude_code.providers.open_router import OpenRouterProvider from tests.api.model_fallback_support import ( ControlledFallbackProvider, execution_failure, ) from tests.providers.support import ( SDKStreamDouble, immediate_admission, make_provider_config, sdk_chat_chunk, ) from tests.providers.test_gemini import _sse from tests.web_tools_support import StubWebToolsClient class ClassifierStream(SDKStreamDouble): def __init__(self, *, starved: bool = False, error: Exception | None = None): self.starved = starved self.error = error self.closed = False super().__init__(self._iterate(), close=self.aclose) async def _iterate(self): if self.error is not None: raise self.error for text, reasoning, finish in ( (None, "Internal provider analysis", None), (None if self.starved else "0", None, None), (None, None, "length" if self.starved else "stop"), ): yield sdk_chat_chunk( SimpleNamespace( choices=[ SimpleNamespace( delta=SimpleNamespace( content=text, reasoning=reasoning, reasoning_content=reasoning, tool_calls=None, ), finish_reason=finish, ) ], usage=None, ) ) async def aclose(self): self.closed = True def classifier_request(): return MessagesRequest.model_validate( { "model": "open_router/dynamic-route", "system": "Output N for this command's safety.", "messages": [ { "role": "user", "content": "Read the requested file.", } ], "max_tokens": 64, "thinking": {"type": "disabled"}, "stop_sequences": [""], "stream": False, } ) @pytest.mark.asyncio @pytest.mark.parametrize( ("capability", "off", "limit"), [ ("none", False, 64), ("optional", True, 64), ("required", False, None), ("unknown", True, None), ], ) @pytest.mark.parametrize("rejection", [None, "mandatory", "field", "unrelated"]) async def test_native_gemini_classifier_preserves_reasoning_preparation( capability, off, limit, rejection ): bodies = [] def reply(request): body = json.loads(request.content) bodies.append(body) config = body["generationConfig"] if config["thinkingConfig"].get("thinkingBudget") == 0 and rejection: error = { "mandatory": {"message": "Thinking cannot be disabled"}, "field": { "message": "Value is not supported", "param": "generationConfig.thinkingConfig.thinkingBudget", }, "unrelated": {"message": "Invalid tool schema", "param": "tools"}, }[rejection] return native_httpx.Response(400, json={"error": error}) return _sse( [ {"text": "Private classifier reasoning", "thought": True}, {"text": "0"}, ] ) provider = GeminiProvider( make_provider_config("test", "https://gemini.invalid/v1beta"), admission=immediate_admission(), transport=native_httpx.MockTransport(reply), ) try: response = await MessagesHandler( Settings(), provider_resolver=AsyncMock(return_value=provider), model_info_lookup=lambda *_: ProviderModelInfo( "models/gemini-2.5-flash", reasoning_capability=ReasoningCapability(capability), ), web_tools=StubWebToolsClient(), ).create( classifier_request().model_copy( update={"model": "gemini/models/gemini-2.5-flash"} ) ) assert isinstance(response, JSONResponse) if off and rejection == "unrelated": assert response.status_code >= 400 assert len(bodies) == 1 else: assert response.status_code == 200 assert json.loads(bytes(response.body))["content"] == [ {"type": "text", "text": "0"} ] assert len(bodies) == (2 if off and rejection else 1) config = bodies[0]["generationConfig"] assert config.get("maxOutputTokens") == limit assert (config["thinkingConfig"].get("thinkingBudget") == 0) is off if len(bodies) == 2: retried = bodies[1]["generationConfig"] assert "maxOutputTokens" not in retried assert "thinkingBudget" not in retried["thinkingConfig"] finally: await provider.cleanup() @pytest.mark.asyncio @pytest.mark.parametrize( ("error", "corrects"), [ ({"code": 400, "message": "Reasoning cannot be disabled."}, True), ( { "code": 400, "message": "Reasoning cannot be disabled.", "metadata": {"error_type": "invalid_request"}, }, True, ), ({"code": 400, "message": "Messages contain an invalid role."}, False), ( {"code": 400, "param": "tools", "message": "Reasoning is required."}, False, ), ({"code": 403, "message": "Reasoning cannot be disabled."}, False), ], ids=["numeric", "metadata", "unrelated", "other-field", "permission"], ) async def test_openrouter_numeric_sse_rejection_uses_classifier_correction( error, corrects ): bodies = [] def upstream(request): bodies.append(json.loads(request.content)) chunk = { "id": "gen-test", "object": "chat.completion.chunk", "created": 1, "model": "dynamic-route", "provider": "test", "choices": [ { "index": 0, "delta": {"content": "0"}, "finish_reason": "stop", } ], } if len(bodies) == 1: chunk["error"] = error chunk["choices"] = [ {"index": 0, "delta": {"content": ""}, "finish_reason": "error"} ] return httpx.Response( 200, headers={"content-type": "text/event-stream"}, text=f"data: {json.dumps(chunk)}\n\ndata: [DONE]\n\n", ) with patch( "free_claude_code.providers.openai_chat.client.AsyncOpenAI", return_value=AsyncOpenAI( api_key="test", base_url="https://provider.invalid/v1", max_retries=0, http_client=httpx.AsyncClient(transport=httpx.MockTransport(upstream)), ), ): provider = OpenRouterProvider( make_provider_config("test", "https://provider.invalid/v1"), admission=immediate_admission(), ) try: response = await MessagesHandler( Settings(), provider_resolver=AsyncMock( side_effect=lambda _, _api_key_number: provider ), web_tools=StubWebToolsClient(), ).create(classifier_request()) assert isinstance(response, JSONResponse) assert len(bodies) == (2 if corrects else 1) if corrects: assert response.status_code == 200 assert json.loads(bytes(response.body))["content"] == [ {"type": "text", "text": "0"} ] assert bodies[0]["reasoning"] == {"enabled": False} assert "reasoning" not in bodies[1] assert bodies[1]["max_tokens"] == 81920 else: assert response.status_code >= 400 finally: await provider.cleanup() @pytest.mark.asyncio @pytest.mark.parametrize("stream", [False, True]) @pytest.mark.parametrize("fallback_effort", [None, *FALLBACK_REASONING_PREFERENCES]) @pytest.mark.parametrize( "reject_off", [False, True, "stream"], ids=["off-ignored", "off-rejected", "off-stream-rejected"], ) async def test_classifier_mandatory_reasoning_still_returns_verdict( reject_off, stream, fallback_effort ): provider = OpenRouterProvider( make_provider_config(api_key="test", base_url="https://openrouter.test/v1"), admission=immediate_admission(), ) bodies = [] streams = [] primary = ControlledFallbackProvider(failure=execution_failure("primary failed")) settings = Settings() request = classifier_request().model_copy(update={"stream": stream}) if fallback_effort is not None: settings = Settings( MODEL="nvidia_nim/primary", MODEL_FALLBACKS=[ {"model": "open_router/dynamic-route", "reasoning": fallback_effort} ], ) request = request.model_copy(update={"model": "nvidia_nim/primary"}) async def upstream(**body): bodies.append(body) if ( reject_off and body.get("extra_body", {}).get("reasoning", {}).get("enabled") is False ): error = { "error": { "code": "invalid_request_error", "message": "Reasoning is mandatory for this endpoint and cannot be disabled.", } } if reject_off == "stream": rejected = ClassifierStream( error=APIError( error["error"]["message"], request=httpx.Request( "POST", "https://openrouter.test/v1/chat/completions" ), body=error["error"], ) ) streams.append(rejected) return rejected raise BadRequestError( error["error"]["message"], response=httpx.Response( 400, request=httpx.Request( "POST", "https://openrouter.test/v1/chat/completions" ), json=error, ), body=error, ) result = ClassifierStream(starved=body.get("max_tokens", 0) < 2048) streams.append(result) return result try: handler = MessagesHandler( settings, provider_resolver=AsyncMock( side_effect=lambda provider_id, _api_key_number: ( primary if provider_id == "nvidia_nim" else provider ) ), web_tools=StubWebToolsClient(), ) with patch.object( provider._client.chat.completions, "create", new=AsyncMock(side_effect=upstream), ): response = await handler.create(request) assert isinstance(response, (JSONResponse, StreamingResponse)) assert response.status_code == 200 if stream: assert isinstance(response, StreamingResponse) raw = "".join([str(chunk) async for chunk in response.body_iterator]) events = parse_sse_text(raw) assert text_content(events) == "0" assert thinking_content(events) == "" assert events[-1].event == "message_stop" else: assert isinstance(response, JSONResponse) message = json.loads(bytes(response.body)) assert message["content"] == [ {"type": "text", "text": "0"} ] assert message["stop_reason"] == "end_turn" assert bodies[0]["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS assert len(bodies) == (2 if reject_off else 1) assert all(stream.closed for stream in streams) finally: await provider.cleanup() @pytest.mark.asyncio @pytest.mark.parametrize( ("capability", "off", "limit"), [ ("none", False, 64), ("optional", True, 64), ("required", False, 81920), ("unknown", True, 81920), ], ) async def test_handler_uses_cached_capabilities_for_the_selected_provider( capability, off, limit ): provider = OpenRouterProvider( make_provider_config("test", "https://provider.invalid/v1"), admission=immediate_admission(), ) bodies = [] async def upstream(**body): bodies.append(body) return ClassifierStream() try: handler = MessagesHandler( Settings(), provider_resolver=AsyncMock( side_effect=lambda _, _api_key_number: provider ), model_info_lookup=lambda provider_id, model_id: next( ( info for info in ( ProviderModelInfo( "open_router/dynamic-route", reasoning_capability=ReasoningCapability(capability), ), ) if info.model_id == f"{provider_id}/{model_id}" ), None, ), web_tools=StubWebToolsClient(), ) with patch.object( provider._client.chat.completions, "create", new=AsyncMock(side_effect=upstream), ): response = await handler.create(classifier_request()) assert isinstance(response, JSONResponse) and response.status_code == 200 assert json.loads(bytes(response.body))["content"] == [ {"type": "text", "text": "0"} ] assert ( bodies[0].get("extra_body", {}).get("reasoning", {}).get("enabled") is False ) is off assert bodies[0]["max_tokens"] == limit finally: await provider.cleanup()