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