Spaces:
Running
Running
File size: 6,841 Bytes
261c237 e99df76 261c237 61bb677 a9e27c0 2e7b8ca 8e438ab 61bb677 8e438ab f7872b8 2e7b8ca a9e27c0 2e7b8ca a9e27c0 2e7b8ca f7872b8 2e7b8ca a9e27c0 f7872b8 8e438ab 61bb677 8e438ab 61bb677 8e438ab 61bb677 abe1c43 61bb677 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 | 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
|