@velum-labs/routekit-gateway 0.17.0 → 0.17.2

package/dist/adapters/anthropic.d.ts

@@ -104,8 +104,14 @@ export declare function openAiSseToAnthropic(upstream: ReadableStream<Uint8Array
 export declare function countTokensEstimate(body: AnthropicRequest): number;
 export declare function handleAnthropicMessages(backend: Backend, body: AnthropicRequest, modelCallId?: string, signal?: AbortSignal, backendOptions?: BackendRequestOptions): Promise<Response>;
 export declare function handleCountTokens(body: AnthropicRequest): Response;
-/** The `claude-` prefix used to alias non-Anthropic models past Claude's filter. */
+/** Historical Claude Code discovery alias prefix. Never emitted by new installs. */
 export declare const CLAUDE_ALIAS_PREFIX = "claude-";
+/**
+ * Claude Code admits arbitrary custom entries in `availableModels` when they
+ * begin with `anthropic.`. The RouteKit discriminator makes the value
+ * reversible and reserves it from provider-native model spelling.
+ */
+export declare const CLAUDE_PICKER_PREFIX = "anthropic.routekit.";
 export type ClaudePickerModelRoute = {
     publicId: string;
     nativeId: string;
@@ -121,20 +127,17 @@ export type ClaudeModelSelection = {
     status: "unsupported_effort";
     model: string;
     message: string;
+} | {
+    status: "ambiguous_model";
+    model: string;
+    message: string;
 } | {
     status: "passthrough";
     model: string;
 };
-/**
- * The id a model is advertised under in Claude Code's `/model` picker. Claude
- * only lists ids beginning with `claude`/`anthropic`, so non-Anthropic models
- * are aliased with a `claude-` prefix; the gateway maps the alias back when
- * routing (see `resolveAlias`), and the picker shows the real id via
- * `display_name`. This is the claude-code-router trick: the `model` field is an
- * identifier we control end-to-end, so any model can be made selectable.
- */
+/** Historical `claude-` spelling accepted for existing sessions only. */
 export declare function claudeModelAlias(id: string): string;
-/** Claude Code picker spelling for one catalog route. */
+/** Claude Code's new native-picker spelling for one RouteKit catalog route. */
 export declare function claudePickerClientModel(route: ClaudePickerModelRoute): string;
 export declare function resolveClaudeModelAlias(requested: string | undefined, modelIds?: readonly string[], modelRoutes?: readonly ClaudePickerModelRoute[]): string | undefined;
 /**
@@ -150,16 +153,14 @@ export declare function resolveClaudeModelSelection(requested: string | undefine
  * defaults remain in force.
  */
 export declare function withClaudeReasoningSelection(body: AnthropicRequest, selection: ReasoningSelection): AnthropicRequest;
-/** Qualify a Claude picker base id with a launch-time effort selection. */
+/** Historical effort-qualified spelling retained for compatibility exports. */
 export declare function claudeEffortQualifiedModel(baseClientModel: string, selection: ReasoningSelection | undefined): string;
 /**
- * Anthropic-shaped `/v1/models` discovery response. Every advertised model is
- * listed so it appears in Claude Code's `/model` picker: Anthropic-family ids
- * as-is, others under a `claude-`prefixed alias with the real id as
- * `display_name`. Reasoning-capable models also advertise one
- * `<base>:<effort>` entry per discovered effort. `modelIds` is the full
- * advertised set (default model first); when absent we fall back to the
- * single backend default.
+ * Anthropic-shaped `/v1/models` response. IDs remain canonical RouteKit ids:
+ * Claude Code filters arbitrary IDs from dynamic discovery, so RouteKit uses
+ * its supported `availableModels` custom-model path for the native picker.
+ * `modelIds` is the full advertised set (default model first); when absent we
+ * fall back to the single backend default.
  */
-export declare function anthropicModelsResponse(backendModel: string | undefined, modelIds?: readonly string[], modelRoutes?: readonly ClaudePickerModelRoute[]): Response;
+export declare function anthropicModelsResponse(backendModel: string | undefined, modelIds?: readonly string[], _modelRoutes?: readonly ClaudePickerModelRoute[]): Response;
 export {};

package/dist/adapters/anthropic.js

@@ -7,7 +7,7 @@
  * the request handler wires them to a `Backend` and returns a `Response` the
  * server pipes straight to the client (JSON or SSE).
  */
-import { EFFORT_QUALIFIED_MODEL_CODEC, effortQualifiedClientModel, enumerateModelEffortVariants, resolveModelEffortVariant } from "@velum-labs/routekit-contracts";
+import { EFFORT_QUALIFIED_MODEL_CODEC, resolveModelEffortVariant } from "@velum-labs/routekit-contracts";
 import { estimateTokens, randomId } from "@velum-labs/routekit-runtime";
 import { SseDecoder, SseParseError } from "../sse/parse.js";
 import { attachAnthropicMessageContent, attachAnthropicRequestMetadata, attachReasoningSelection, attachReasoningSelectionError, anthropicReasoningDetailsOf } from "./openai-chat-wire.js";
@@ -1120,29 +1120,29 @@ export async function handleAnthropicMessages(backend, body, modelCallId, signal
 export function handleCountTokens(body) {
     return jsonResponse(200, { input_tokens: countTokensEstimate(body) });
 }
-/** Claude Code only lists models whose id begins with `claude` or `anthropic`. */
-function isAnthropicFamilyId(id) {
-    return id.startsWith("claude") || id.startsWith("anthropic");
-}
-/** The `claude-` prefix used to alias non-Anthropic models past Claude's filter. */
+/** Historical Claude Code discovery alias prefix. Never emitted by new installs. */
 export const CLAUDE_ALIAS_PREFIX = "claude-";
 /**
- * The id a model is advertised under in Claude Code's `/model` picker. Claude
- * only lists ids beginning with `claude`/`anthropic`, so non-Anthropic models
- * are aliased with a `claude-` prefix; the gateway maps the alias back when
- * routing (see `resolveAlias`), and the picker shows the real id via
- * `display_name`. This is the claude-code-router trick: the `model` field is an
- * identifier we control end-to-end, so any model can be made selectable.
+ * Claude Code admits arbitrary custom entries in `availableModels` when they
+ * begin with `anthropic.`. The RouteKit discriminator makes the value
+ * reversible and reserves it from provider-native model spelling.
  */
+export const CLAUDE_PICKER_PREFIX = "anthropic.routekit.";
+/** Historical `claude-` spelling accepted for existing sessions only. */
 export function claudeModelAlias(id) {
-    return isAnthropicFamilyId(id) ? id : `${CLAUDE_ALIAS_PREFIX}${id}`;
+    return id.startsWith("claude") || id.startsWith("anthropic")
+        ? id
+        : `${CLAUDE_ALIAS_PREFIX}${id}`;
 }
-/** Claude Code picker spelling for one catalog route. */
+/** Claude Code's new native-picker spelling for one RouteKit catalog route. */
 export function claudePickerClientModel(route) {
+    return `${CLAUDE_PICKER_PREFIX}${route.publicId}`;
+}
+function legacyClaudePickerClientModel(route) {
     const displayName = route.provider === "claude-code" ? route.nativeId : route.publicId;
     return claudeModelAlias(displayName);
 }
-function claudeVariantEntries(modelIds, modelRoutes) {
+function legacyClaudeVariantEntries(modelIds, modelRoutes) {
     const routes = new Map(modelRoutes.map((route) => [route.publicId, route]));
     return modelIds.map((publicId) => {
         const route = routes.get(publicId) ?? {
@@ -1152,7 +1152,7 @@ function claudeVariantEntries(modelIds, modelRoutes) {
         };
         return {
             model: publicId,
-            clientModel: claudePickerClientModel(route),
+            clientModel: legacyClaudePickerClientModel(route),
             ...(route.reasoning !== undefined ? { reasoning: route.reasoning } : {})
         };
     });
@@ -1161,7 +1161,30 @@ export function resolveClaudeModelAlias(requested, modelIds = [], modelRoutes =
     if (requested === undefined)
         return undefined;
     const selection = resolveClaudeModelSelection(requested, modelIds, modelRoutes);
-    return selection.status === "unsupported_effort" ? undefined : selection.model;
+    return selection.status === "unsupported_effort" || selection.status === "ambiguous_model"
+        ? undefined
+        : selection.model;
+}
+function uniqueNativeModel(requested, modelRoutes) {
+    const routes = new Map();
+    for (const route of modelRoutes) {
+        if (route.nativeId !== requested)
+            continue;
+        // Catalog aliases do not make an otherwise unique provider/native pair
+        // ambiguous.
+        const key = `${route.provider}\u0000${route.nativeId}`;
+        if (!routes.has(key))
+            routes.set(key, route);
+    }
+    const values = [...routes.values()];
+    if (values.length === 0)
+        return { status: "none" };
+    if (values.length === 1)
+        return { status: "resolved", model: values[0].publicId };
+    return {
+        status: "ambiguous",
+        models: values.map((route) => route.publicId).sort((left, right) => left.localeCompare(right))
+    };
 }
 /**
  * Resolve a Claude Code picker id (base or effort-qualified) to the served
@@ -1172,15 +1195,44 @@ export function resolveClaudeModelSelection(requested, modelIds = [], modelRoute
         return { status: "passthrough", model: "" };
     }
     if (modelIds.includes(requested)) {
-        const route = modelRoutes.find((entry) => entry.publicId === requested);
         return {
             status: "resolved",
             model: requested,
-            clientModel: route === undefined ? claudeModelAlias(requested) : claudePickerClientModel(route),
+            clientModel: requested,
             selection: { mode: "auto" }
         };
     }
-    const resolved = resolveModelEffortVariant(requested, claudeVariantEntries(modelIds, modelRoutes), EFFORT_QUALIFIED_MODEL_CODEC);
+    if (requested.startsWith(CLAUDE_PICKER_PREFIX)) {
+        const candidate = requested.slice(CLAUDE_PICKER_PREFIX.length);
+        if (modelIds.includes(candidate)) {
+            return {
+                status: "resolved",
+                model: candidate,
+                clientModel: requested,
+                selection: { mode: "auto" }
+            };
+        }
+    }
+    const native = uniqueNativeModel(requested, modelRoutes);
+    if (native.status === "resolved") {
+        return {
+            status: "resolved",
+            model: native.model,
+            clientModel: requested,
+            selection: { mode: "auto" }
+        };
+    }
+    if (native.status === "ambiguous") {
+        return {
+            status: "ambiguous_model",
+            model: requested,
+            message: `model "${requested}" is served by multiple RouteKit routes: ` +
+                `${native.models.join(", ")}; select one of those canonical ids instead`
+        };
+    }
+    // New installs no longer create aliases or effort-qualified models. Preserve
+    // parsing of the former `claude-*` spellings for existing sessions/scripts.
+    const resolved = resolveModelEffortVariant(requested, legacyClaudeVariantEntries(modelIds, modelRoutes), EFFORT_QUALIFIED_MODEL_CODEC);
     if (resolved.ok) {
         return {
             status: "resolved",
@@ -1231,52 +1283,37 @@ export function withClaudeReasoningSelection(body, selection) {
         output_config: outputConfig
     };
 }
-/** Qualify a Claude picker base id with a launch-time effort selection. */
+/** Historical effort-qualified spelling retained for compatibility exports. */
 export function claudeEffortQualifiedModel(baseClientModel, selection) {
-    return effortQualifiedClientModel(baseClientModel, selection, EFFORT_QUALIFIED_MODEL_CODEC);
+    return selection?.mode === "effort"
+        ? EFFORT_QUALIFIED_MODEL_CODEC.qualify(baseClientModel, selection.effort)
+        : baseClientModel;
 }
 /**
- * Anthropic-shaped `/v1/models` discovery response. Every advertised model is
- * listed so it appears in Claude Code's `/model` picker: Anthropic-family ids
- * as-is, others under a `claude-`prefixed alias with the real id as
- * `display_name`. Reasoning-capable models also advertise one
- * `<base>:<effort>` entry per discovered effort. `modelIds` is the full
- * advertised set (default model first); when absent we fall back to the
- * single backend default.
+ * Anthropic-shaped `/v1/models` response. IDs remain canonical RouteKit ids:
+ * Claude Code filters arbitrary IDs from dynamic discovery, so RouteKit uses
+ * its supported `availableModels` custom-model path for the native picker.
+ * `modelIds` is the full advertised set (default model first); when absent we
+ * fall back to the single backend default.
  */
-export function anthropicModelsResponse(backendModel, modelIds, modelRoutes = []) {
+export function anthropicModelsResponse(backendModel, modelIds, _modelRoutes = []) {
     const source = modelIds !== undefined && modelIds.length > 0
         ? modelIds
         : backendModel !== undefined
             ? [backendModel]
             : [];
     const seen = new Set();
-    const routes = new Map(modelRoutes.map((route) => [route.publicId, route]));
     const models = [];
     for (const realId of source) {
-        const route = routes.get(realId) ?? {
-            publicId: realId,
-            nativeId: realId,
-            provider: "unknown"
-        };
-        const displayName = route.provider === "claude-code" ? route.nativeId : realId;
-        for (const variant of enumerateModelEffortVariants({
-            model: realId,
-            clientModel: claudePickerClientModel(route),
-            ...(route.reasoning !== undefined ? { reasoning: route.reasoning } : {})
-        }, EFFORT_QUALIFIED_MODEL_CODEC)) {
-            if (seen.has(variant.id))
-                continue;
-            seen.add(variant.id);
-            models.push({
-                type: "model",
-                id: variant.id,
-                display_name: variant.selection.mode === "effort"
-                    ? `${displayName} (${variant.selection.effort})`
-                    : displayName,
-                created_at: new Date(0).toISOString()
-            });
-        }
+        if (seen.has(realId))
+            continue;
+        seen.add(realId);
+        models.push({
+            type: "model",
+            id: realId,
+            display_name: realId,
+            created_at: new Date(0).toISOString()
+        });
     }
     const ids = models.map((model) => model.id);
     return new Response(JSON.stringify({

package/dist/index.d.ts

@@ -21,7 +21,7 @@ export { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
 export { ANTHROPIC_MESSAGE_CONTENT, ANTHROPIC_REQUEST_METADATA, REASONING_SELECTION, ROUTEKIT_EXTENSION_KEY, attachAnthropicMessageContent, attachAnthropicRequestMetadata, attachReasoningSelection, anthropicMessageContentOf, anthropicRequestMetadataOf, routeKitRequestValidationErrorOf, reasoningSelectionErrorOf, reasoningSelectionOf, responsesReasoningMetadataErrorOf, withoutRouteKitExtensions } from "./adapters/openai-chat-wire.js";
 export type { AnthropicNativeContentBlock, AnthropicRequestMetadata, RouteKitMessageEnvelope, RouteKitReasoningEnvelope } from "./adapters/openai-chat-wire.js";
 export { isCursorChatBody, translateCursorRequest } from "./adapters/cursor.js";
-export { anthropicModelsResponse, anthropicToChat, CLAUDE_ALIAS_PREFIX, chatToAnthropicMessage, claudeEffortQualifiedModel, claudeModelAlias, claudePickerClientModel, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic, resolveClaudeModelAlias, resolveClaudeModelSelection, withClaudeReasoningSelection } from "./adapters/anthropic.js";
+export { anthropicModelsResponse, anthropicToChat, CLAUDE_ALIAS_PREFIX, CLAUDE_PICKER_PREFIX, chatToAnthropicMessage, claudeEffortQualifiedModel, claudeModelAlias, claudePickerClientModel, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic, resolveClaudeModelAlias, resolveClaudeModelSelection, withClaudeReasoningSelection } from "./adapters/anthropic.js";
 export type { AnthropicRequest, ClaudeModelSelection, ClaudePickerModelRoute } from "./adapters/anthropic.js";
 export { chatToResponses, customToolNames, handleResponses, openAiSseToResponses, responsesToChat, responsesToolRegistry } from "./adapters/responses.js";
 export type { ResponsesRequest, ResponsesToolKind, ResponsesToolRegistry } from "./adapters/responses.js";

package/dist/index.js

@@ -11,7 +11,7 @@ export { CapacityPool } from "./capacity-pool.js";
 export { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
 export { ANTHROPIC_MESSAGE_CONTENT, ANTHROPIC_REQUEST_METADATA, REASONING_SELECTION, ROUTEKIT_EXTENSION_KEY, attachAnthropicMessageContent, attachAnthropicRequestMetadata, attachReasoningSelection, anthropicMessageContentOf, anthropicRequestMetadataOf, routeKitRequestValidationErrorOf, reasoningSelectionErrorOf, reasoningSelectionOf, responsesReasoningMetadataErrorOf, withoutRouteKitExtensions } from "./adapters/openai-chat-wire.js";
 export { isCursorChatBody, translateCursorRequest } from "./adapters/cursor.js";
-export { anthropicModelsResponse, anthropicToChat, CLAUDE_ALIAS_PREFIX, chatToAnthropicMessage, claudeEffortQualifiedModel, claudeModelAlias, claudePickerClientModel, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic, resolveClaudeModelAlias, resolveClaudeModelSelection, withClaudeReasoningSelection } from "./adapters/anthropic.js";
+export { anthropicModelsResponse, anthropicToChat, CLAUDE_ALIAS_PREFIX, CLAUDE_PICKER_PREFIX, chatToAnthropicMessage, claudeEffortQualifiedModel, claudeModelAlias, claudePickerClientModel, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic, resolveClaudeModelAlias, resolveClaudeModelSelection, withClaudeReasoningSelection } from "./adapters/anthropic.js";
 export { chatToResponses, customToolNames, handleResponses, openAiSseToResponses, responsesToChat, responsesToolRegistry } from "./adapters/responses.js";
 export { MAX_WEB_SEARCHES_PER_TURN, resolveWebSearchExecutor } from "./adapters/web-search.js";
 export { DIALECT_DROPPED_ATTRIBUTE, droppedField, resetDroppedFieldWarnings, withDroppedFieldSpan } from "./adapters/dropped.js";

package/dist/server.js

@@ -348,7 +348,7 @@ export async function startGateway(options) {
         if (method === "GET" && path.startsWith("/v1/models/")) {
             const id = decodeURIComponent(path.slice("/v1/models/".length));
             const selection = resolveClaudeSelection(backend, id);
-            if (selection.status === "unsupported_effort") {
+            if (selection.status === "unsupported_effort" || selection.status === "ambiguous_model") {
                 writeClaudeSelectionError(res, selection);
                 return;
             }
@@ -489,7 +489,7 @@ export async function startGateway(options) {
                 return;
             const rawBody = raw;
             const selection = resolveClaudeSelection(backend, rawBody.model);
-            if (selection.status === "unsupported_effort") {
+            if (selection.status === "unsupported_effort" || selection.status === "ambiguous_model") {
                 writeClaudeSelectionError(res, selection);
                 return;
             }
@@ -532,7 +532,7 @@ export async function startGateway(options) {
                 return;
             const rawBody = raw;
             const selection = resolveClaudeSelection(backend, rawBody.model);
-            if (selection.status === "unsupported_effort") {
+            if (selection.status === "unsupported_effort" || selection.status === "ambiguous_model") {
                 writeClaudeSelectionError(res, selection);
                 return;
             }

package/dist/test/anthropic.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { createServer } from "node:http";
 import { test } from "node:test";
-import { anthropicModelsResponse, anthropicToChat, chatToAnthropicMessage, claudeModelAlias, mapStopReason, openAiSseToAnthropic, resolveClaudeModelAlias, resolveClaudeModelSelection, withClaudeReasoningSelection } from "../adapters/anthropic.js";
+import { anthropicModelsResponse, anthropicToChat, chatToAnthropicMessage, mapStopReason, openAiSseToAnthropic, resolveClaudeModelAlias, resolveClaudeModelSelection, withClaudeReasoningSelection } from "../adapters/anthropic.js";
 import { OpenAiBackend } from "../backend.js";
 import { CatalogBackend } from "../router.js";
 import { MODEL_CALL_ID_HEADER } from "../provenance.js";
@@ -12,7 +12,7 @@ import { ANTHROPIC_MESSAGE_CONTENT, ANTHROPIC_REQUEST_METADATA } from "../adapte
  * Verifies request translation (system, tools, tool results), non-streaming
  * and streaming response shapes, count_tokens, and discovery.
  */
-test("anthropicModelsResponse aliases every model past Claude Code's claude/anthropic filter", async () => {
+test("anthropicModelsResponse keeps canonical route ids and emits no effort variants", async () => {
     const res = anthropicModelsResponse("route-primary", [
         "route-primary",
         "claude-opus-4-8",
@@ -20,70 +20,17 @@ test("anthropicModelsResponse aliases every model past Claude Code's claude/anth
         "mlx-community/Qwen3-1.7B-4bit"
     ]);
     const body = (await res.json());
-    // Every id begins with claude/anthropic so Claude Code lists them all...
-    assert.ok(body.data.every((model) => model.id.startsWith("claude") || model.id.startsWith("anthropic")));
-    // ...non-Anthropic ids are aliased, Anthropic-family ids pass through as-is.
     assert.deepEqual(body.data.map((model) => model.id), [
-        "claude-route-primary",
+        "route-primary",
         "claude-opus-4-8",
-        "claude-gpt-5.5",
-        "claude-mlx-community/Qwen3-1.7B-4bit"
+        "gpt-5.5",
+        "mlx-community/Qwen3-1.7B-4bit"
     ]);
-    // The picker shows the real id via display_name.
-    const gpt = body.data.find((model) => model.id === "claude-gpt-5.5");
+    assert.ok(body.data.every((model) => !model.id.includes(":")));
+    const gpt = body.data.find((model) => model.id === "gpt-5.5");
     assert.equal(gpt?.display_name, "gpt-5.5");
-    assert.equal(claudeModelAlias("claude-opus-4-8"), "claude-opus-4-8");
-    assert.equal(resolveClaudeModelAlias("claude-gpt-5.5", [
-        "route-primary",
-        "gpt-5.5"
-    ]), "gpt-5.5");
-    assert.equal(resolveClaudeModelAlias("claude-opus-4-8", ["gpt-5.5"]), "claude-opus-4-8");
-});
-test("anthropicModelsResponse exposes Claude subscription models as bare native ids", async () => {
-    const response = anthropicModelsResponse("claude-code/claude-sonnet-4-6", [
-        "claude-code/claude-sonnet-4-6",
-        "codex/gpt-5.5",
-        "anthropic/claude-opus-4-8"
-    ], [
-        {
-            publicId: "claude-code/claude-sonnet-4-6",
-            nativeId: "claude-sonnet-4-6",
-            provider: "claude-code"
-        },
-        {
-            publicId: "codex/gpt-5.5",
-            nativeId: "gpt-5.5",
-            provider: "codex"
-        },
-        {
-            publicId: "anthropic/claude-opus-4-8",
-            nativeId: "claude-opus-4-8",
-            provider: "anthropic"
-        }
-    ]);
-    const body = (await response.json());
-    assert.deepEqual(body.data, [
-        {
-            id: "claude-sonnet-4-6",
-            display_name: "claude-sonnet-4-6",
-            created_at: new Date(0).toISOString(),
-            type: "model"
-        },
-        {
-            id: "claude-codex/gpt-5.5",
-            display_name: "codex/gpt-5.5",
-            created_at: new Date(0).toISOString(),
-            type: "model"
-        },
-        {
-            id: "anthropic/claude-opus-4-8",
-            display_name: "anthropic/claude-opus-4-8",
-            created_at: new Date(0).toISOString(),
-            type: "model"
-        }
-    ]);
 });
-test("anthropicModelsResponse emits base plus discovered effort variants", async () => {
+test("Claude selection accepts picker ids and unique native ids but rejects collisions", () => {
     const reasoning = {
         status: "supported",
         efforts: [
@@ -93,49 +40,35 @@ test("anthropicModelsResponse emits base plus discovered effort variants", async
         ],
         provenance: "provider"
     };
-    const response = anthropicModelsResponse("claude-code/claude-sonnet-4-6", ["claude-code/claude-sonnet-4-6", "codex/gpt-5.5", "openai/gpt-4o"], [
-        {
-            publicId: "claude-code/claude-sonnet-4-6",
-            nativeId: "claude-sonnet-4-6",
-            provider: "claude-code",
-            reasoning
-        },
-        {
-            publicId: "codex/gpt-5.5",
-            nativeId: "gpt-5.5",
-            provider: "codex",
-            reasoning
-        },
-        {
-            publicId: "openai/gpt-4o",
-            nativeId: "gpt-4o",
-            provider: "openai"
-        }
-    ]);
-    const body = (await response.json());
-    assert.deepEqual(body.data.map((model) => model.id), [
-        "claude-sonnet-4-6",
-        "claude-sonnet-4-6:low",
-        "claude-sonnet-4-6:high",
-        "claude-codex/gpt-5.5",
-        "claude-codex/gpt-5.5:low",
-        "claude-codex/gpt-5.5:high",
-        "claude-openai/gpt-4o"
-    ]);
-    assert.equal(body.data.find((model) => model.id === "claude-sonnet-4-6:high")?.display_name, "claude-sonnet-4-6 (high)");
-    assert.deepEqual(resolveClaudeModelSelection("claude-codex/gpt-5.5:max", ["claude-code/claude-sonnet-4-6", "codex/gpt-5.5", "openai/gpt-4o"], [
-        {
-            publicId: "codex/gpt-5.5",
-            nativeId: "gpt-5.5",
-            provider: "codex",
-            reasoning
-        }
+    assert.deepEqual(resolveClaudeModelSelection("anthropic.routekit.codex/gpt-5.5", ["openai/gpt-5.5", "fast", "codex/gpt-5.5"], [
+        { publicId: "openai/gpt-5.5", nativeId: "gpt-5.5", provider: "openai", reasoning },
+        { publicId: "fast", nativeId: "gpt-5.5", provider: "openai", reasoning },
+        { publicId: "codex/gpt-5.5", nativeId: "gpt-5.5", provider: "codex", reasoning }
     ]), {
         status: "resolved",
         model: "codex/gpt-5.5",
-        clientModel: "claude-codex/gpt-5.5",
-        selection: { mode: "effort", effort: "high" }
+        clientModel: "anthropic.routekit.codex/gpt-5.5",
+        selection: { mode: "auto" }
     });
+    assert.deepEqual(resolveClaudeModelSelection("gpt-5.5", ["openai/gpt-5.5", "fast"], [
+        { publicId: "openai/gpt-5.5", nativeId: "gpt-5.5", provider: "openai", reasoning },
+        { publicId: "fast", nativeId: "gpt-5.5", provider: "openai", reasoning }
+    ]), {
+        status: "resolved",
+        model: "openai/gpt-5.5",
+        clientModel: "gpt-5.5",
+        selection: { mode: "auto" }
+    });
+    const collision = resolveClaudeModelSelection("gpt-5.5", ["openai/gpt-5.5", "codex/gpt-5.5"], [
+        { publicId: "openai/gpt-5.5", nativeId: "gpt-5.5", provider: "openai", reasoning },
+        { publicId: "codex/gpt-5.5", nativeId: "gpt-5.5", provider: "codex", reasoning }
+    ]);
+    assert.equal(collision.status, "ambiguous_model");
+    if (collision.status === "ambiguous_model") {
+        assert.match(collision.message, /codex\/gpt-5\.5, openai\/gpt-5\.5/);
+    }
+    // The legacy spelling remains accepted, but is not emitted anywhere.
+    assert.equal(resolveClaudeModelAlias("claude-gpt-5.5", ["gpt-5.5"]), "gpt-5.5");
     assert.equal(resolveClaudeModelSelection("claude-codex/gpt-5.5:unknown", ["codex/gpt-5.5"], [
         {
             publicId: "codex/gpt-5.5",
@@ -735,7 +668,7 @@ test("estimates tokens and serves Anthropic discovery", async () => {
             headers: { "anthropic-version": "2023-06-01" }
         });
         const list = (await models.json());
-        assert.ok(list.data[0]?.id.startsWith("claude"));
+        assert.equal(list.data[0]?.id, "local-model");
     }
     finally {
         await gateway.close();
@@ -781,7 +714,7 @@ test("Claude's implicit thinking default does not reject a base model without re
             method: "POST",
             headers: { "content-type": "application/json", "anthropic-version": "2023-06-01" },
             body: JSON.stringify({
-                model: "claude-openai/mock-model",
+                model: "anthropic.routekit.openai/mock-model",
                 max_tokens: 32,
                 thinking: { type: "adaptive" },
                 output_config: { effort: "high" },
@@ -796,7 +729,7 @@ test("Claude's implicit thinking default does not reject a base model without re
         await gateway.close();
     }
 });
-test("Claude picker aliases use the canonical catalog and pooled native relay", async () => {
+test("Claude picker ids and bare native ids use the canonical catalog and pooled native relay", async () => {
     const sourceCalls = [];
     const source = (sourceId) => ({
         sourceId,
@@ -860,10 +793,11 @@ test("Claude picker aliases use the canonical catalog and pooled native relay",
             headers: { "anthropic-version": "2023-06-01" }
         })).json());
         assert.deepEqual(catalog.data.map(({ id, display_name }) => [id, display_name]), [
-            ["claude-codex/gpt-5.5", "codex/gpt-5.5"],
-            ["claude-sonnet-4-6", "claude-sonnet-4-6"]
+            ["codex/gpt-5.5", "codex/gpt-5.5"],
+            ["claude-code/claude-sonnet-4-6", "claude-code/claude-sonnet-4-6"]
         ]);
         for (const model of [
+            "anthropic.routekit.claude-code/claude-sonnet-4-6",
             "claude-sonnet-4-6",
             "claude-code/claude-sonnet-4-6"
         ]) {
@@ -885,6 +819,7 @@ test("Claude picker aliases use the canonical catalog and pooled native relay",
                 .content[0]?.text, "NATIVE_OK");
         }
         assert.deepEqual(relayedBodies.map((body) => body.model), [
+            "claude-sonnet-4-6",
             "claude-sonnet-4-6",
             "claude-sonnet-4-6"
         ]);
@@ -905,6 +840,7 @@ test("Claude picker aliases use the canonical catalog and pooled native relay",
         assert.equal(unknown.status, 400);
         assert.match(await unknown.text(), /unknown model/);
         assert.deepEqual(relayedBodies.map((body) => body.model), [
+            "claude-sonnet-4-6",
             "claude-sonnet-4-6",
             "claude-sonnet-4-6"
         ]);
@@ -913,7 +849,49 @@ test("Claude picker aliases use the canonical catalog and pooled native relay",
         await gateway.close();
     }
 });
-test("Claude effort variants apply request-scoped effort on native and translated routes", async () => {
+test("Claude rejects an ambiguous bare native model before provider routing", async () => {
+    const sourceCalls = [];
+    const source = (sourceId) => ({
+        sourceId,
+        discoverModels: async () => [{ id: "gpt-5.5" }],
+        chat: async (body) => {
+            sourceCalls.push(body.model);
+            return Response.json({});
+        },
+        embeddings: async () => Response.json({})
+    });
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { openai: {}, codex: {} },
+            defaultModel: "openai/gpt-5.5"
+        },
+        sources: { openai: source("openai"), codex: source("codex") }
+    });
+    const gateway = await startGateway({ backend });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/messages`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify({
+                model: "gpt-5.5",
+                max_tokens: 32,
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(response.status, 400);
+        const payload = (await response.json());
+        assert.equal(payload.error.type, "invalid_request_error");
+        assert.match(payload.error.message, /codex\/gpt-5\.5, openai\/gpt-5\.5/);
+        assert.deepEqual(sourceCalls, []);
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("Claude native effort applies request-scoped effort on picker and bare-native routes", async () => {
     const reasoning = {
         status: "supported",
         efforts: [{ id: "low" }, { id: "high", aliases: ["max"] }],
@@ -980,9 +958,7 @@ test("Claude effort variants apply request-scoped effort on native and translate
         const catalog = (await (await fetch(`${gateway.url()}/v1/models`, {
             headers: { "anthropic-version": "2023-06-01" }
         })).json());
-        assert.ok(catalog.data.some((model) => model.id === "claude-sonnet-4-6"));
-        assert.ok(catalog.data.some((model) => model.id === "claude-sonnet-4-6:high"));
-        assert.ok(catalog.data.some((model) => model.id === "claude-codex/gpt-5.5:low"));
+        assert.deepEqual(catalog.data.map((model) => model.id), ["codex/gpt-5.5", "claude-code/claude-sonnet-4-6"]);
         for (const effort of ["low", "high"]) {
             const response = await fetch(`${gateway.url()}/v1/messages`, {
                 method: "POST",
@@ -991,8 +967,10 @@ test("Claude effort variants apply request-scoped effort on native and translate
                     "anthropic-version": "2023-06-01"
                 },
                 body: JSON.stringify({
-                    model: `claude-sonnet-4-6:${effort}`,
+                    model: "anthropic.routekit.claude-code/claude-sonnet-4-6",
                     max_tokens: 32,
+                    thinking: { type: "adaptive" },
+                    output_config: { effort },
                     messages: [{ role: "user", content: "hi" }]
                 })
             });
@@ -1028,8 +1006,10 @@ test("Claude effort variants apply request-scoped effort on native and translate
                 "anthropic-version": "2023-06-01"
             },
             body: JSON.stringify({
-                model: "claude-codex/gpt-5.5:max",
+                model: "anthropic.routekit.codex/gpt-5.5",
                 max_tokens: 32,
+                thinking: { type: "adaptive" },
+                output_config: { effort: "high" },
                 messages: [{ role: "user", content: "hi" }]
             })
         });
@@ -1037,25 +1017,31 @@ test("Claude effort variants apply request-scoped effort on native and translate
         assert.equal(sourceCalls.length, 1);
         assert.equal(sourceCalls[0]?.model, "gpt-5.5");
         assert.equal(sourceCalls[0]?.reasoning_effort, "high");
-        const rejected = await fetch(`${gateway.url()}/v1/messages`, {
+        const passthrough = await fetch(`${gateway.url()}/v1/messages`, {
             method: "POST",
             headers: {
                 "content-type": "application/json",
                 "anthropic-version": "2023-06-01"
             },
             body: JSON.stringify({
-                model: "claude-sonnet-4-6:bogus",
+                model: "anthropic.routekit.claude-code/claude-sonnet-4-6",
                 max_tokens: 32,
+                thinking: { type: "adaptive" },
+                output_config: { effort: "bogus" },
                 messages: [{ role: "user", content: "hi" }]
             })
         });
-        assert.equal(rejected.status, 400);
-        assert.match(await rejected.text(), /not supported/);
-        assert.equal(relayedBodies.length, 3);
+        // Claude Code owns the native effort selector. RouteKit must preserve an
+        // unrecognised value for the provider rather than validating it against a
+        // stale discovery catalog or reintroducing synthetic effort model ids.
+        assert.equal(passthrough.status, 200);
+        assert.deepEqual(relayedBodies.at(-1)?.output_config, { effort: "bogus" });
+        assert.deepEqual(relayedBodies.at(-1)?.thinking, { type: "adaptive" });
+        assert.equal(relayedBodies.length, 4);
         assert.equal(sourceCalls.length, 1);
-        const retrieve = await fetch(`${gateway.url()}/v1/models/${encodeURIComponent("claude-sonnet-4-6:high")}`, { headers: { "anthropic-version": "2023-06-01" } });
+        const retrieve = await fetch(`${gateway.url()}/v1/models/${encodeURIComponent("anthropic.routekit.claude-code/claude-sonnet-4-6")}`, { headers: { "anthropic-version": "2023-06-01" } });
         assert.equal(retrieve.status, 200);
-        assert.equal((await retrieve.json()).id, "claude-sonnet-4-6:high");
+        assert.equal((await retrieve.json()).id, "anthropic.routekit.claude-code/claude-sonnet-4-6");
     }
     finally {
         await gateway.close();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "0.17.0",
+  "version": "0.17.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -29,10 +29,10 @@
     "@aws-sdk/client-bedrock": "3.1095.0",
     "@aws-sdk/client-bedrock-runtime": "3.1095.0",
     "zod": "4.4.3",
-    "@velum-labs/routekit-contracts": "0.17.0",
-    "@velum-labs/routekit-registry": "0.17.0",
-    "@velum-labs/routekit-runtime": "0.17.0",
-    "@velum-labs/routekit-tracing": "0.17.0"
+    "@velum-labs/routekit-contracts": "0.17.2",
+    "@velum-labs/routekit-registry": "0.17.2",
+    "@velum-labs/routekit-runtime": "0.17.2",
+    "@velum-labs/routekit-tracing": "0.17.2"
   },
   "keywords": [
     "routekit",