Spaces:
Running
Running
Download src/free_claude_code/application/reasoning.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 6.84 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/application/reasoning.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/application/reasoning.py
-
curl -L -o reasoning.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/application/reasoning.py
6.84 kB
| from __future__ import annotations | |
| """Resolve client reasoning input and FCC configuration exactly once.""" | |
| from collections.abc import Mapping | |
| from free_claude_code.config.reasoning import ReasoningPreference | |
| from free_claude_code.core.anthropic.models import MessagesRequest, ThinkingConfig | |
| from free_claude_code.core.chat_completions.request import ChatRequest | |
| from free_claude_code.core.gemini import GeminiRequest | |
| from free_claude_code.core.openai_responses import ( | |
| OpenAIResponsesRequest, | |
| responses_reasoning_policy, | |
| ) | |
| from free_claude_code.core.reasoning import ( | |
| ReasoningControl, | |
| ReasoningEffort, | |
| ReasoningPolicy, | |
| ) | |
| def resolve_reasoning_policy( | |
| request: MessagesRequest, | |
| preference: ReasoningPreference, | |
| ) -> ReasoningPolicy: | |
| """Apply one resolved configuration preference to the client request.""" | |
| return _apply_reasoning_preference( | |
| client_reasoning_policy(request), | |
| preference, | |
| ) | |
| def resolve_responses_reasoning_policy( | |
| request: OpenAIResponsesRequest, | |
| preference: ReasoningPreference, | |
| ) -> ReasoningPolicy: | |
| """Apply one resolved configuration preference to a Responses request.""" | |
| return _apply_reasoning_preference( | |
| client_responses_reasoning_policy(request), | |
| preference, | |
| ) | |
| def resolve_fallback_reasoning( | |
| original: ReasoningPolicy, | |
| preference: ReasoningPreference, | |
| *, | |
| client: ReasoningPolicy, | |
| ) -> ReasoningPolicy: | |
| """Resolve a candidate from original intent, never a previous fallback.""" | |
| # Classifier requests keep the handler's tolerant policy on every candidate. | |
| if original.control is ReasoningControl.PREFER_OFF: | |
| return original | |
| if preference is ReasoningPreference.INHERIT: | |
| return original | |
| if preference is ReasoningPreference.CLIENT: | |
| return client | |
| return _apply_reasoning_preference(original, preference) | |
| def resolve_gemini_reasoning_policy( | |
| request: GeminiRequest, | |
| preference: ReasoningPreference, | |
| ) -> ReasoningPolicy: | |
| return _apply_reasoning_preference(request.reasoning_policy(), preference) | |
| def client_chat_reasoning_policy(request: ChatRequest) -> ReasoningPolicy: | |
| return responses_reasoning_policy({"effort": request.reasoning_effort}) | |
| def resolve_chat_reasoning_policy( | |
| request: ChatRequest, preference: ReasoningPreference | |
| ) -> ReasoningPolicy: | |
| return _apply_reasoning_preference( | |
| client_chat_reasoning_policy(request), preference | |
| ) | |
| def prepare_fallback_request[ | |
| T: MessagesRequest | OpenAIResponsesRequest | GeminiRequest | ChatRequest | |
| ](original: T, *, model: str, preference: ReasoningPreference) -> T: | |
| """Copy a candidate and remove computation controls replaced by its policy.""" | |
| request = original.model_copy(update={"model": model}, deep=True) | |
| if preference in {ReasoningPreference.INHERIT, ReasoningPreference.CLIENT}: | |
| return request | |
| if isinstance(request, MessagesRequest): | |
| if request.thinking is not None: | |
| thinking = request.thinking.model_dump(exclude_unset=True) | |
| for key in ("type", "enabled", "budget_tokens"): | |
| thinking.pop(key, None) | |
| request.thinking = ( | |
| ThinkingConfig.model_validate(thinking) if thinking else None | |
| ) | |
| if request.output_config is not None: | |
| request.output_config.pop("effort", None) | |
| elif isinstance(request, GeminiRequest): | |
| thinking = request.generation_config.thinking_config | |
| thinking.thinking_budget = None | |
| thinking.thinking_level = None | |
| elif isinstance(request, ChatRequest): | |
| request.reasoning_effort = None | |
| request.model_fields_set.discard("reasoning_effort") | |
| elif request.reasoning is not None: | |
| request.reasoning.pop("effort", None) | |
| return request | |
| def _apply_reasoning_preference( | |
| client_policy: ReasoningPolicy, | |
| preference: ReasoningPreference, | |
| ) -> ReasoningPolicy: | |
| """Apply FCC's route preference to already-parsed client intent.""" | |
| if preference is ReasoningPreference.INHERIT: | |
| raise ValueError("Reasoning preference must be resolved before application.") | |
| if preference is ReasoningPreference.OFF: | |
| return ReasoningPolicy.off() | |
| if preference is not ReasoningPreference.CLIENT: | |
| return ReasoningPolicy.on(effort=ReasoningEffort(preference.value)) | |
| return client_policy | |
| def client_reasoning_policy(request: MessagesRequest) -> ReasoningPolicy: | |
| """Return the lossless reasoning intent expressed by one client request.""" | |
| budget_tokens = _positive_budget(request.thinking) | |
| thinking_control = _thinking_control( | |
| request.thinking, | |
| budget_tokens=budget_tokens, | |
| ) | |
| effort, effort_disables = _output_effort(request.output_config) | |
| if effort_disables: | |
| return ReasoningPolicy.off() | |
| if thinking_control is ReasoningControl.OFF: | |
| return ReasoningPolicy( | |
| control=ReasoningControl.OFF, | |
| effort=effort, | |
| ) | |
| if thinking_control is ReasoningControl.ON or budget_tokens is not None: | |
| return ReasoningPolicy.on( | |
| effort=effort, | |
| budget_tokens=budget_tokens, | |
| ) | |
| return ReasoningPolicy( | |
| control=ReasoningControl.DEFAULT, | |
| effort=effort, | |
| ) | |
| def client_responses_reasoning_policy( | |
| request: OpenAIResponsesRequest, | |
| ) -> ReasoningPolicy: | |
| """Return the supported reasoning intent from one Responses request.""" | |
| return responses_reasoning_policy(request.reasoning) | |
| def _thinking_control( | |
| thinking: ThinkingConfig | None, | |
| *, | |
| budget_tokens: int | None, | |
| ) -> ReasoningControl: | |
| if thinking is None: | |
| return ReasoningControl.DEFAULT | |
| if thinking.type == "disabled" or ( | |
| "enabled" in thinking.model_fields_set and thinking.enabled is False | |
| ): | |
| return ReasoningControl.OFF | |
| if ( | |
| thinking.type in {"adaptive", "enabled"} | |
| or ("enabled" in thinking.model_fields_set and thinking.enabled is True) | |
| or budget_tokens is not None | |
| ): | |
| return ReasoningControl.ON | |
| return ReasoningControl.DEFAULT | |
| def _output_effort(value: object) -> tuple[ReasoningEffort | None, bool]: | |
| if not isinstance(value, Mapping): | |
| return None, False | |
| raw = value.get("effort") | |
| if not isinstance(raw, str): | |
| return None, False | |
| normalized = raw.strip().lower() | |
| if normalized == "none": | |
| return None, True | |
| try: | |
| return ReasoningEffort(normalized), False | |
| except ValueError: | |
| return None, False | |
| def _positive_budget(thinking: ThinkingConfig | None) -> int | None: | |
| if thinking is None: | |
| return None | |
| value = thinking.budget_tokens | |
| if isinstance(value, int) and not isinstance(value, bool) and value > 0: | |
| return value | |
| return None | |