dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
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