File size: 14,652 Bytes
261c237
e99df76
2415446
e99df76
2415446
 
 
691dc7c
 
 
 
8e438ab
 
 
 
2e7b8ca
8e438ab
e99df76
61bb677
2415446
e99df76
 
 
 
 
 
a9e27c0
691dc7c
 
 
 
 
2e7b8ca
8e438ab
61bb677
e99df76
61bb677
2e7b8ca
a9e27c0
2e7b8ca
 
 
 
61bb677
 
 
 
e99df76
a9e27c0
61bb677
e99df76
a9e27c0
61bb677
abe1c43
a9e27c0
61bb677
2415446
 
 
3934d27
 
 
2415446
 
 
f7872b8
 
 
 
 
 
 
 
 
3934d27
 
 
 
 
 
 
 
f7872b8
61bb677
2415446
 
 
 
 
3934d27
61bb677
2415446
 
e99df76
 
 
 
 
 
 
 
 
 
 
8e438ab
 
 
 
 
 
 
2e7b8ca
 
 
 
 
 
 
a9e27c0
 
 
 
 
 
 
2415446
 
e99df76
3934d27
2415446
 
 
 
 
 
 
 
3934d27
2415446
 
 
61bb677
2415446
 
61bb677
 
 
 
2415446
 
61bb677
2415446
 
 
61bb677
2415446
3934d27
 
2415446
3934d27
 
61bb677
2415446
 
 
61bb677
3934d27
 
2415446
3934d27
 
 
2415446
3934d27
2415446
3934d27
 
 
 
 
f7872b8
 
 
3934d27
 
 
f7872b8
3934d27
 
f7872b8
 
 
3934d27
 
2415446
 
3934d27
f7872b8
3934d27
 
 
 
f7872b8
3934d27
f7872b8
 
 
 
 
 
 
 
2415446
 
691dc7c
 
 
 
 
2415446
 
 
61bb677
691dc7c
 
 
 
8e438ab
 
 
 
 
 
 
 
 
 
 
2e7b8ca
 
 
 
 
 
 
2415446
691dc7c
 
 
 
 
 
 
 
 
 
61bb677
2415446
 
 
61bb677
2415446
 
 
 
61bb677
691dc7c
 
 
 
 
61bb677
2415446
61bb677
 
2415446
 
 
 
61bb677
 
 
 
 
2415446
 
61bb677
 
 
 
2415446
61bb677
 
 
 
 
 
 
 
 
 
 
 
 
 
2415446
e99df76
 
 
 
 
 
f7872b8
 
 
e99df76
 
 
 
 
 
 
f7872b8
 
 
e99df76
 
 
 
 
 
2415446
 
 
 
 
 
3934d27
61bb677
 
 
 
 
 
 
 
2415446
8e438ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2415446
e99df76
 
 
 
2415446
 
e99df76
2415446
3934d27
2415446
 
8e438ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e7b8ca
 
 
 
 
 
 
 
 
 
 
 
a9e27c0
 
 
 
 
 
 
 
 
 
 
 
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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
from __future__ import annotations
"""Model routing for Claude-compatible requests."""

from dataclasses import dataclass, replace

from loguru import logger

from free_claude_code.application.errors import (
    InvalidRequestError,
    UnknownProviderError,
)
from free_claude_code.config.model_refs import (
    is_retired_model_ref,
    parse_model_name,
    parse_provider_type,
    replace_retired_model_ref,
)
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.reasoning import ReasoningPreference
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import (
    MessagesRequest,
    NativeTokenCountRequest,
    TokenCountRequest,
)
from free_claude_code.core.anthropic.passthrough import NativeMessagesRequest
from free_claude_code.core.chat_completions.request import ChatRequest
from free_claude_code.core.gateway_model_ids import (
    DESKTOP_MODEL_PREFIX,
    DESKTOP_NO_THINKING_PREFIX,
    decode_gateway_model_id,
)
from free_claude_code.core.gemini import GeminiRequest
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.core.trace import trace_event

from .reasoning import (
    resolve_chat_reasoning_policy,
    resolve_gemini_reasoning_policy,
    resolve_reasoning_policy,
    resolve_responses_reasoning_policy,
)

_ROUTE_SETTINGS = (
    ("fable", "model_fable", "reasoning_fable"),
    ("opus", "model_opus", "reasoning_opus"),
    ("sol", "model_opus", "reasoning_opus"),
    ("gpt-5.6-sol", "model_opus", "reasoning_opus"),
    ("haiku", "model_haiku", "reasoning_haiku"),
    ("luna", "model_haiku", "reasoning_haiku"),
    ("gpt-5.6-luna", "model_haiku", "reasoning_haiku"),
    ("sonnet", "model_sonnet", "reasoning_sonnet"),
    ("terra", "model_sonnet", "reasoning_sonnet"),
    ("gpt-5.6-terra", "model_sonnet", "reasoning_sonnet"),
)


@dataclass(frozen=True, slots=True)
class ProviderModelTarget:
    """One canonical provider/model execution target."""

    provider_id: str
    provider_model: str
    provider_model_ref: str
    api_key_number: int = 1


@dataclass(frozen=True, slots=True)
class ProviderModelCandidate:
    """One execution target with a candidate-local reasoning preference."""

    target: ProviderModelTarget
    reasoning_preference: ReasoningPreference = ReasoningPreference.INHERIT


@dataclass(frozen=True, slots=True)
class ResolvedModelRoute:
    """One public model resolved to a primary and ordered fallbacks."""

    original_model: str
    primary: ProviderModelTarget
    fallbacks: tuple[ProviderModelCandidate, ...]
    reasoning_preference: ReasoningPreference


@dataclass(frozen=True, slots=True)
class RoutedMessagesRequest:
    request: MessagesRequest
    resolved: ResolvedModelRoute
    reasoning: ReasoningPolicy


@dataclass(frozen=True, slots=True)
class RoutedNativeMessagesRequest:
    request: NativeMessagesRequest
    resolved: ResolvedModelRoute


def supports_native_messages(provider_id: str) -> bool:
    descriptor = PROVIDER_CATALOG.get(provider_id)
    return descriptor is not None and descriptor.native_messages_passthrough


@dataclass(frozen=True, slots=True)
class RoutedResponsesRequest:
    request: OpenAIResponsesRequest
    resolved: ResolvedModelRoute
    reasoning: ReasoningPolicy


@dataclass(frozen=True, slots=True)
class RoutedGeminiRequest:
    request: GeminiRequest
    resolved: ResolvedModelRoute
    reasoning: ReasoningPolicy


@dataclass(frozen=True, slots=True)
class RoutedChatRequest:
    request: ChatRequest
    resolved: ResolvedModelRoute
    reasoning: ReasoningPolicy


@dataclass(frozen=True, slots=True)
class RoutedTokenCountRequest:
    request: TokenCountRequest | NativeTokenCountRequest
    resolved: ResolvedModelRoute


class ModelRouter:
    """Resolve incoming Claude model names to configured provider/model pairs."""

    def __init__(self, settings: Settings):
        self._settings = settings

    def resolve(self, claude_model_name: str) -> ResolvedModelRoute:
        (
            direct_provider_id,
            direct_provider_model,
            force_reasoning_off,
        ) = self._direct_provider_model(claude_model_name)
        if direct_provider_id is not None and direct_provider_model is not None:
            reasoning_preference = (
                ReasoningPreference.OFF
                if force_reasoning_off
                else self._settings.reasoning_policy
            )
            logger.debug(
                "MODEL DIRECT: '{}' -> provider='{}' model='{}' reasoning={}",
                claude_model_name,
                direct_provider_id,
                direct_provider_model,
                reasoning_preference.value,
            )
            primary = self._target(direct_provider_id, direct_provider_model)
            return ResolvedModelRoute(
                original_model=claude_model_name,
                primary=primary,
                fallbacks=self._fallback_targets(primary),
                reasoning_preference=reasoning_preference,
            )

        provider_model_ref = self._resolve_model_ref(claude_model_name)
        reasoning_preference = self._resolve_reasoning_preference(claude_model_name)
        primary = self._target_from_ref(provider_model_ref)
        if primary.provider_model != claude_model_name:
            logger.debug(
                "MODEL MAPPING: '{}' -> '{}'",
                claude_model_name,
                primary.provider_model,
            )
        return ResolvedModelRoute(
            original_model=claude_model_name,
            primary=primary,
            fallbacks=self._fallback_targets(primary),
            reasoning_preference=reasoning_preference,
        )

    def _target_from_ref(
        self, provider_model_ref: str, api_key_number: int = 1
    ) -> ProviderModelTarget:
        return self._target(
            parse_provider_type(provider_model_ref),
            parse_model_name(provider_model_ref),
            api_key_number,
        )

    def _target(
        self, provider_id: str, provider_model: str, api_key_number: int = 1
    ) -> ProviderModelTarget:
        self._validate_provider_id(provider_id)
        return ProviderModelTarget(
            provider_id=provider_id,
            provider_model=provider_model,
            provider_model_ref=f"{provider_id}/{provider_model}",
            api_key_number=api_key_number,
        )

    def _fallback_targets(
        self, primary: ProviderModelTarget
    ) -> tuple[ProviderModelCandidate, ...]:
        configured = tuple(
            ProviderModelCandidate(
                self._target_from_ref(entry.model, entry.api_key_number),
                entry.reasoning,
            )
            for entry in self._settings.model_fallbacks or ()
        )
        return tuple(
            candidate for candidate in configured if candidate.target != primary
        )

    def _validate_provider_id(self, provider_id: str) -> None:
        if provider_id not in self._settings.provider_ids:
            raise UnknownProviderError.for_provider(
                provider_id, self._settings.provider_ids
            )

    def _direct_provider_model(
        self, model_name: str
    ) -> tuple[str | None, str | None, bool]:
        try:
            decoded = decode_gateway_model_id(model_name)
        except ValueError:
            raise InvalidRequestError("Invalid Claude Desktop model ID") from None
        candidate = (
            f"{decoded.provider_id}/{decoded.provider_model}"
            if decoded is not None
            else model_name
        )
        if is_retired_model_ref(candidate):
            return (
                parse_provider_type(self._settings.model),
                parse_model_name(self._settings.model),
                decoded.force_reasoning_off if decoded is not None else False,
            )
        replacement = replace_retired_model_ref(candidate)
        if replacement != candidate:
            return (
                parse_provider_type(replacement),
                parse_model_name(replacement),
                decoded.force_reasoning_off if decoded is not None else False,
            )
        if decoded is not None:
            if decoded.provider_id not in self._settings.provider_ids:
                if decoded.provider_id.startswith("custom_") or model_name.partition(
                    "/"
                )[0] in {
                    DESKTOP_MODEL_PREFIX,
                    DESKTOP_NO_THINKING_PREFIX,
                }:
                    raise UnknownProviderError.for_provider(
                        decoded.provider_id, self._settings.provider_ids
                    )
                return None, None, False
            return (
                decoded.provider_id,
                decoded.provider_model,
                decoded.force_reasoning_off,
            )

        provider_id, separator, provider_model = model_name.partition("/")
        if not separator:
            return None, None, False
        if provider_id not in self._settings.provider_ids:
            if provider_id.startswith("custom_"):
                raise UnknownProviderError.for_provider(
                    provider_id, self._settings.provider_ids
                )
            return None, None, False
        if not provider_model:
            return None, None, False
        return provider_id, provider_model, False

    def _resolve_model_ref(self, claude_model_name: str) -> str:
        """Resolve a Claude model name to the configured provider/model ref."""

        route = self._matched_route(claude_model_name)
        if route is not None:
            model = getattr(self._settings, route[1])
            if isinstance(model, str):
                return model
        return self._settings.model

    def _resolve_reasoning_preference(
        self, claude_model_name: str
    ) -> ReasoningPreference:
        """Resolve a route override without inspecting the provider model."""

        route = self._matched_route(claude_model_name)
        if route is not None:
            preference = getattr(self._settings, route[2])
            if preference is not ReasoningPreference.INHERIT:
                return preference
        return self._settings.reasoning_policy

    @staticmethod
    def _matched_route(model_name: str) -> tuple[str, str, str] | None:
        normalized = model_name.lower()
        return next(
            (route for route in _ROUTE_SETTINGS if route[0] in normalized),
            None,
        )

    def route_native_messages(
        self,
        request: NativeMessagesRequest,
        resolved: ResolvedModelRoute,
    ) -> RoutedNativeMessagesRequest:
        eligible = tuple(
            candidate
            for candidate in resolved.fallbacks
            if supports_native_messages(candidate.target.provider_id)
        )
        trace_event(
            stage="routing",
            event="free_claude_code.api.route.messages_contract",
            source="application",
            contract="native",
            excluded_fallbacks=tuple(
                candidate.target.provider_model_ref
                for candidate in resolved.fallbacks
                if candidate not in eligible
            ),
        )
        return RoutedNativeMessagesRequest(
            request, replace(resolved, fallbacks=eligible)
        )

    def resolve_messages_request(
        self, request: MessagesRequest
    ) -> RoutedMessagesRequest:
        """Return an internal routed request context."""
        resolved = self.resolve(request.model)
        routed = request.model_copy(deep=True)
        routed.model = resolved.primary.provider_model
        return RoutedMessagesRequest(
            request=routed,
            resolved=resolved,
            reasoning=resolve_reasoning_policy(
                routed,
                resolved.reasoning_preference,
            ),
        )

    def resolve_messages_request_with_policy(
        self,
        request: MessagesRequest,
        *,
        reasoning: ReasoningPolicy,
    ) -> RoutedMessagesRequest:
        """Route an application-owned Messages request with resolved intent."""

        resolved = self.resolve(request.model)
        routed = request.model_copy(
            update={"model": resolved.primary.provider_model},
            deep=True,
        )
        return RoutedMessagesRequest(
            request=routed,
            resolved=resolved,
            reasoning=reasoning,
        )

    def resolve_token_count_request(
        self,
        request: TokenCountRequest | NativeTokenCountRequest,
        *,
        resolved: ResolvedModelRoute | None = None,
    ) -> RoutedTokenCountRequest:
        """Return an internal token-count request context."""
        resolved = resolved or self.resolve(request.model)
        routed = request.model_copy(
            update={"model": resolved.primary.provider_model}, deep=True
        )
        return RoutedTokenCountRequest(request=routed, resolved=resolved)

    def resolve_responses_request(
        self,
        request: OpenAIResponsesRequest,
    ) -> RoutedResponsesRequest:
        """Route a Responses request without converting its protocol shape."""

        resolved = self.resolve(request.model)
        routed = request.model_copy(deep=True)
        routed.model = resolved.primary.provider_model
        return RoutedResponsesRequest(
            request=routed,
            resolved=resolved,
            reasoning=resolve_responses_reasoning_policy(
                routed,
                resolved.reasoning_preference,
            ),
        )

    def resolve_gemini_request(self, request: GeminiRequest) -> RoutedGeminiRequest:
        resolved = self.resolve(request.model)
        return RoutedGeminiRequest(
            request=request.model_copy(
                update={"model": resolved.primary.provider_model}, deep=True
            ),
            resolved=resolved,
            reasoning=resolve_gemini_reasoning_policy(
                request, resolved.reasoning_preference
            ),
        )

    def resolve_chat_request(self, request: ChatRequest) -> RoutedChatRequest:
        resolved = self.resolve(request.model)
        return RoutedChatRequest(
            request=request.model_copy(
                update={"model": resolved.primary.provider_model}, deep=True
            ),
            resolved=resolved,
            reasoning=resolve_chat_reasoning_policy(
                request, resolved.reasoning_preference
            ),
        )