@velum-labs/routekit-gateway 0.16.4 → 0.16.6

package/dist/adapters/anthropic.d.ts

@@ -8,6 +8,7 @@
  * server pipes straight to the client (JSON or SSE).
  */
 import type { Backend, BackendRequestOptions } from "../backend.js";
+import type { ModelReasoningCapabilities, ReasoningSelection } from "@velum-labs/routekit-contracts";
 import { type AnthropicThinkingConfig, type OpenAiChoice } from "./openai-chat-wire.js";
 import type { ExecutedSearch, ServerToolLoopEvent } from "./server-tool-loop.js";
 type AnthropicTextBlock = {
@@ -109,6 +110,20 @@ export type ClaudePickerModelRoute = {
     publicId: string;
     nativeId: string;
     provider: string;
+    reasoning?: ModelReasoningCapabilities;
+};
+export type ClaudeModelSelection = {
+    status: "resolved";
+    model: string;
+    clientModel: string;
+    selection: ReasoningSelection;
+} | {
+    status: "unsupported_effort";
+    model: string;
+    message: string;
+} | {
+    status: "passthrough";
+    model: string;
 };
 /**
  * The id a model is advertised under in Claude Code's `/model` picker. Claude
@@ -119,13 +134,32 @@ export type ClaudePickerModelRoute = {
  * identifier we control end-to-end, so any model can be made selectable.
  */
 export declare function claudeModelAlias(id: string): string;
-export declare function resolveClaudeModelAlias(requested: string | undefined, modelIds?: readonly string[]): string | undefined;
+/** Claude Code picker spelling for one catalog route. */
+export declare function claudePickerClientModel(route: ClaudePickerModelRoute): string;
+export declare function resolveClaudeModelAlias(requested: string | undefined, modelIds?: readonly string[], modelRoutes?: readonly ClaudePickerModelRoute[]): string | undefined;
+/**
+ * Resolve a Claude Code picker id (base or effort-qualified) to the served
+ * model and request-scoped reasoning selection.
+ */
+export declare function resolveClaudeModelSelection(requested: string | undefined, modelIds?: readonly string[], modelRoutes?: readonly ClaudePickerModelRoute[]): ClaudeModelSelection;
+/**
+ * Apply a request-scoped effort selection onto an Anthropic Messages body.
+ *
+ * Effort selections use adaptive thinking plus `output_config.effort`. Base /
+ * auto selections leave thinking and output_config untouched so provider
+ * 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. */
+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`. `modelIds` is the full advertised set (default model first);
- * when absent we fall back to the single backend default.
+ * `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.
  */
 export declare function anthropicModelsResponse(backendModel: string | undefined, modelIds?: readonly string[], modelRoutes?: readonly ClaudePickerModelRoute[]): Response;
 export {};

package/dist/adapters/anthropic.js

@@ -7,6 +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 { 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";
@@ -1136,22 +1137,112 @@ export const CLAUDE_ALIAS_PREFIX = "claude-";
 export function claudeModelAlias(id) {
     return isAnthropicFamilyId(id) ? id : `${CLAUDE_ALIAS_PREFIX}${id}`;
 }
-export function resolveClaudeModelAlias(requested, modelIds = []) {
-    if (requested === undefined || modelIds.includes(requested))
-        return requested;
-    if (!requested.startsWith(CLAUDE_ALIAS_PREFIX))
-        return requested;
+/** Claude Code picker spelling for one catalog route. */
+export function claudePickerClientModel(route) {
+    const displayName = route.provider === "claude-code" ? route.nativeId : route.publicId;
+    return claudeModelAlias(displayName);
+}
+function claudeVariantEntries(modelIds, modelRoutes) {
+    const routes = new Map(modelRoutes.map((route) => [route.publicId, route]));
+    return modelIds.map((publicId) => {
+        const route = routes.get(publicId) ?? {
+            publicId,
+            nativeId: publicId,
+            provider: "unknown"
+        };
+        return {
+            model: publicId,
+            clientModel: claudePickerClientModel(route),
+            ...(route.reasoning !== undefined ? { reasoning: route.reasoning } : {})
+        };
+    });
+}
+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;
+}
+/**
+ * Resolve a Claude Code picker id (base or effort-qualified) to the served
+ * model and request-scoped reasoning selection.
+ */
+export function resolveClaudeModelSelection(requested, modelIds = [], modelRoutes = []) {
+    if (requested === undefined) {
+        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),
+            selection: { mode: "auto" }
+        };
+    }
+    const resolved = resolveModelEffortVariant(requested, claudeVariantEntries(modelIds, modelRoutes), EFFORT_QUALIFIED_MODEL_CODEC);
+    if (resolved.ok) {
+        return {
+            status: "resolved",
+            model: resolved.model,
+            clientModel: resolved.clientModel,
+            selection: resolved.selection
+        };
+    }
+    if (resolved.code === "unsupported_effort") {
+        return {
+            status: "unsupported_effort",
+            model: requested,
+            message: resolved.message
+        };
+    }
+    // Preserve the historical base-alias fallback for callers that only pass
+    // model ids (no route metadata) and for unknown ids deferred to Anthropic.
+    if (!requested.startsWith(CLAUDE_ALIAS_PREFIX)) {
+        return { status: "passthrough", model: requested };
+    }
     const candidate = requested.slice(CLAUDE_ALIAS_PREFIX.length);
-    return modelIds.includes(candidate) && claudeModelAlias(candidate) === requested
-        ? candidate
-        : requested;
+    if (modelIds.includes(candidate) && claudeModelAlias(candidate) === requested) {
+        return {
+            status: "resolved",
+            model: candidate,
+            clientModel: requested,
+            selection: { mode: "auto" }
+        };
+    }
+    return { status: "passthrough", model: requested };
+}
+/**
+ * Apply a request-scoped effort selection onto an Anthropic Messages body.
+ *
+ * Effort selections use adaptive thinking plus `output_config.effort`. Base /
+ * auto selections leave thinking and output_config untouched so provider
+ * defaults remain in force.
+ */
+export function withClaudeReasoningSelection(body, selection) {
+    if (selection.mode !== "effort")
+        return body;
+    const outputConfig = body.output_config === null || body.output_config === undefined
+        ? { effort: selection.effort }
+        : { ...body.output_config, effort: selection.effort };
+    return {
+        ...body,
+        thinking: { type: "adaptive" },
+        output_config: outputConfig
+    };
+}
+/** Qualify a Claude picker base id with a launch-time effort selection. */
+export function claudeEffortQualifiedModel(baseClientModel, selection) {
+    return effortQualifiedClientModel(baseClientModel, selection, EFFORT_QUALIFIED_MODEL_CODEC);
 }
 /**
  * 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`. `modelIds` is the full advertised set (default model first);
- * when absent we fall back to the single backend default.
+ * `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.
  */
 export function anthropicModelsResponse(backendModel, modelIds, modelRoutes = []) {
     const source = modelIds !== undefined && modelIds.length > 0
@@ -1163,18 +1254,29 @@ export function anthropicModelsResponse(backendModel, modelIds, modelRoutes = []
     const routes = new Map(modelRoutes.map((route) => [route.publicId, route]));
     const models = [];
     for (const realId of source) {
-        const route = routes.get(realId);
-        const displayName = route?.provider === "claude-code" ? route.nativeId : realId;
-        const id = claudeModelAlias(displayName);
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        models.push({
-            type: "model",
-            id,
-            display_name: displayName,
-            created_at: new Date(0).toISOString()
-        });
+        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()
+            });
+        }
     }
     const ids = models.map((model) => model.id);
     return new Response(JSON.stringify({

package/dist/adapters/cursor.d.ts

@@ -47,7 +47,7 @@ export declare function cursorModelVariants(id: string, reasoning: unknown): Cur
 /**
  * Resolve a Cursor-facing model variant back to its served model and effort.
  *
- * Exact served ids win before suffix parsing, so a provider model whose real
+ * Exact served ids win before qualification, so a provider model whose real
  * id contains a colon remains addressable. Effort aliases are accepted but
  * normalized to the provider's canonical id.
  */

package/dist/adapters/cursor.js

@@ -14,7 +14,7 @@
  * never a reason to throw — unknown item and tool types are dropped so the
  * boundary stays defensive without 4xx-ing on new shapes.
  */
-import { cursorModelName, resolveReasoningEffort, stripCursorNamespace } from "@velum-labs/routekit-contracts";
+import { cursorModelName, EFFORT_QUALIFIED_MODEL_CODEC, enumerateModelEffortVariants, resolveModelEffortVariant, stripCursorNamespace } from "@velum-labs/routekit-contracts";
 import { droppedField } from "./dropped.js";
 import { attachReasoningSelection, attachReasoningSelectionError, hasExplicitReasoningSelection, reasoningSelectionErrorOf, reasoningSelectionOf } from "./openai-chat-wire.js";
 /** Fields copied through unchanged when present and non-null. */
@@ -53,6 +53,20 @@ export function isCursorChatBody(body) {
 export function cursorModelAliasId(id) {
     return id.replaceAll("/", "-");
 }
+function cursorVariantEntries(servedIds, reasoningCapabilities) {
+    return servedIds.map((id) => ({
+        model: id,
+        clientModel: cursorModelName(id),
+        ...(reasoningCapabilities?.(id) !== undefined
+            ? { reasoning: reasoningCapabilities(id) }
+            : {})
+    }));
+}
+function cursorSelectionOf(model, selection) {
+    return selection.mode === "effort" && typeof selection.effort === "string"
+        ? { model, reasoningEffort: selection.effort }
+        : { model };
+}
 /**
  * Expand one served model into the opaque ids Cursor can put in its picker.
  *
@@ -60,30 +74,22 @@ export function cursorModelAliasId(id) {
  * so each discovered effort is represented as a model-name variant instead.
  */
 export function cursorModelVariants(id, reasoning) {
-    const variants = [{ model: cursorModelName(id) }];
-    if (!isObject(reasoning) || reasoning.status !== "supported")
-        return variants;
-    if (!Array.isArray(reasoning.efforts))
-        return variants;
-    const seen = new Set();
-    for (const option of reasoning.efforts) {
-        if (!isObject(option) || typeof option.id !== "string" || option.id.length === 0) {
-            continue;
-        }
-        if (seen.has(option.id))
-            continue;
-        seen.add(option.id);
-        variants.push({
-            model: cursorModelName(`${id}:${option.id}`),
-            reasoningEffort: option.id
-        });
-    }
-    return variants;
+    const capabilities = isObject(reasoning) &&
+        (reasoning.status === "supported" ||
+            reasoning.status === "unsupported" ||
+            reasoning.status === "unknown")
+        ? reasoning
+        : undefined;
+    return enumerateModelEffortVariants({
+        model: id,
+        clientModel: cursorModelName(id),
+        ...(capabilities !== undefined ? { reasoning: capabilities } : {})
+    }, EFFORT_QUALIFIED_MODEL_CODEC).map((variant) => cursorSelectionOf(variant.id, variant.selection));
 }
 /**
  * Resolve a Cursor-facing model variant back to its served model and effort.
  *
- * Exact served ids win before suffix parsing, so a provider model whose real
+ * Exact served ids win before qualification, so a provider model whose real
  * id contains a colon remains addressable. Effort aliases are accepted but
  * normalized to the provider's canonical id.
  */
@@ -95,13 +101,25 @@ export function resolveCursorModelSelection(model, servedIds, reasoningCapabilit
     const candidate = stripped ?? model;
     if (servedIds.includes(candidate))
         return { model: candidate };
-    const suffixed = resolveCursorReasoningSuffix(candidate, servedIds, reasoningCapabilities);
-    if (suffixed !== undefined)
-        return suffixed;
+    const resolved = resolveModelEffortVariant(candidate, cursorVariantEntries(servedIds, reasoningCapabilities), EFFORT_QUALIFIED_MODEL_CODEC);
+    if (resolved.ok)
+        return cursorSelectionOf(resolved.model, resolved.selection);
     const legacy = servedIds.find((id) => id.includes("/") && cursorModelAliasId(id) === candidate);
     if (legacy !== undefined)
         return { model: legacy };
-    return resolveLegacyCursorReasoningSuffix(candidate, servedIds, reasoningCapabilities);
+    const legacyEntries = servedIds
+        .filter((id) => id.includes("/"))
+        .map((id) => ({
+        model: id,
+        clientModel: cursorModelAliasId(id),
+        ...(reasoningCapabilities?.(id) !== undefined
+            ? { reasoning: reasoningCapabilities(id) }
+            : {})
+    }));
+    const legacyResolved = resolveModelEffortVariant(candidate, legacyEntries, EFFORT_QUALIFIED_MODEL_CODEC);
+    return legacyResolved.ok
+        ? cursorSelectionOf(legacyResolved.model, legacyResolved.selection)
+        : undefined;
 }
 /**
  * Resolve a Cursor-facing model name back to a served id.
@@ -113,44 +131,6 @@ export function resolveCursorModelSelection(model, servedIds, reasoningCapabilit
 export function resolveCursorModelAlias(model, servedIds) {
     return resolveCursorModelSelection(model, servedIds)?.model;
 }
-function resolveCursorReasoningSuffix(candidate, servedIds, reasoningCapabilities) {
-    if (reasoningCapabilities === undefined)
-        return undefined;
-    for (const id of [...servedIds].sort((left, right) => right.length - left.length)) {
-        const prefix = `${id}:`;
-        if (!candidate.startsWith(prefix))
-            continue;
-        const requested = candidate.slice(prefix.length);
-        if (requested.length === 0)
-            continue;
-        const capabilities = reasoningCapabilities(id);
-        if (capabilities === undefined || capabilities.status !== "supported")
-            continue;
-        const effort = resolveReasoningEffort(capabilities, requested);
-        if (effort !== undefined)
-            return { model: id, reasoningEffort: effort };
-    }
-    return undefined;
-}
-function resolveLegacyCursorReasoningSuffix(candidate, servedIds, reasoningCapabilities) {
-    if (reasoningCapabilities === undefined)
-        return undefined;
-    for (const id of servedIds) {
-        if (!id.includes("/"))
-            continue;
-        const prefix = `${cursorModelAliasId(id)}:`;
-        if (!candidate.startsWith(prefix))
-            continue;
-        const requested = candidate.slice(prefix.length);
-        const capabilities = reasoningCapabilities(id);
-        if (capabilities === undefined || capabilities.status !== "supported")
-            continue;
-        const effort = resolveReasoningEffort(capabilities, requested);
-        if (effort !== undefined)
-            return { model: id, reasoningEffort: effort };
-    }
-    return undefined;
-}
 /**
  * Map a Cursor BYOK request body onto a Chat Completions body.
  *

package/dist/index.d.ts

@@ -21,8 +21,8 @@ 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, claudeModelAlias, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic } from "./adapters/anthropic.js";
-export type { AnthropicRequest } from "./adapters/anthropic.js";
+export { anthropicModelsResponse, anthropicToChat, CLAUDE_ALIAS_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";
 export { MAX_WEB_SEARCHES_PER_TURN, resolveWebSearchExecutor } from "./adapters/web-search.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, claudeModelAlias, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic } from "./adapters/anthropic.js";
+export { anthropicModelsResponse, anthropicToChat, CLAUDE_ALIAS_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/router.js

@@ -1,4 +1,4 @@
-import { resolveReasoningEffort } from "@velum-labs/routekit-contracts";
+import { resolveReasoningSelection } from "@velum-labs/routekit-contracts";
 import { z } from "zod";
 import { attachReasoningSelection, reasoningSelectionOf, routeKitRequestValidationErrorOf } from "./adapters/openai-chat-wire.js";
 import { BedrockProviderSource } from "./bedrock-source.js";
@@ -686,9 +686,6 @@ export class CatalogBackend {
         };
     }
     #validatedReasoning(entry, selection) {
-        if (selection.mode === "auto" || selection.mode === "disabled") {
-            return selection;
-        }
         const capability = entry.reasoning;
         if (selection.mode === "effort" &&
             selection.effort === "none" &&
@@ -697,34 +694,25 @@ export class CatalogBackend {
                 capability.status === "unsupported")) {
             return { mode: "disabled" };
         }
-        if (capability === undefined || capability.status === "unknown") {
+        const resolved = resolveReasoningSelection(capability, selection);
+        if (resolved.ok)
+            return resolved.selection;
+        if (resolved.code === "unknown_capability") {
             return `model "${entry.publicId}" has no discovered reasoning controls`;
         }
-        if (capability.status === "unsupported") {
+        if (resolved.code === "unsupported") {
             return `model "${entry.publicId}" does not support reasoning controls`;
         }
-        if (selection.mode === "effort") {
-            const effort = resolveReasoningEffort(capability, selection.effort);
-            return effort === undefined
-                ? `reasoning effort "${selection.effort}" is not supported by model "${entry.publicId}"`
-                : { mode: "effort", effort };
+        if (resolved.code === "unsupported_effort") {
+            return `reasoning effort "${selection.mode === "effort" ? selection.effort : ""}" is not supported by model "${entry.publicId}"`;
         }
-        if (selection.mode === "adaptive") {
-            return capability.adaptive === true
-                ? selection
-                : `adaptive reasoning is not supported by model "${entry.publicId}"`;
+        if (resolved.code === "unsupported_adaptive") {
+            return `adaptive reasoning is not supported by model "${entry.publicId}"`;
         }
-        const budget = capability.budget;
-        if (budget === undefined) {
+        if (resolved.code === "unsupported_budget") {
             return `reasoning token budgets are not supported by model "${entry.publicId}"`;
         }
-        if (budget.minTokens !== undefined && selection.budgetTokens < budget.minTokens) {
-            return `reasoning budget must be at least ${budget.minTokens} tokens`;
-        }
-        if (budget.maxTokens !== undefined && selection.budgetTokens > budget.maxTokens) {
-            return `reasoning budget must be at most ${budget.maxTokens} tokens`;
-        }
-        return selection;
+        return resolved.message;
     }
 }
 export function isSubscriptionProvider(provider) {

package/dist/server.js

@@ -1,6 +1,6 @@
 import { createServer } from "node:http";
-import { isCodexPickerEligibleModel, ProviderFailureError } from "@velum-labs/routekit-contracts";
-import { anthropicModelsResponse, handleAnthropicMessages, handleCountTokens, resolveClaudeModelAlias } from "./adapters/anthropic.js";
+import { isCodexPickerEligibleModel, ProviderFailureError, reasoningEffortDescriptors } from "@velum-labs/routekit-contracts";
+import { anthropicModelsResponse, handleAnthropicMessages, handleCountTokens, resolveClaudeModelSelection, withClaudeReasoningSelection } from "./adapters/anthropic.js";
 import { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
 import { authorizedRequest, parsePrincipalHeader, ROUTEKIT_PRINCIPAL_HEADER } from "./auth.js";
 import { cursorModelVariants, isCursorChatBody, resolveCursorModelSelection, translateCursorRequest } from "./adapters/cursor.js";
@@ -12,9 +12,9 @@ import { buildModelCallRecord, MODEL_CALL_ID_HEADER, modelCallId } from "./prove
 import { waitForDrainOrClose } from "./http-response.js";
 import { NoModelAvailableError, UnknownModelError } from "./router.js";
 function codexModelInfo(id, priority, reasoning) {
-    const levels = (reasoning?.efforts ?? []).map((effort) => ({
+    const levels = reasoningEffortDescriptors(reasoning).map((effort) => ({
         effort: effort.id,
-        description: effort.description ?? effort.label ?? effort.id
+        description: effort.label
     }));
     return {
         slug: id,
@@ -67,6 +67,18 @@ function catalogModelRoutes(backend) {
         return route === undefined ? [] : [route];
     });
 }
+function resolveClaudeSelection(backend, requested) {
+    return resolveClaudeModelSelection(requested, backend.listModelIds?.() ?? [], catalogModelRoutes(backend));
+}
+function writeClaudeSelectionError(res, selection) {
+    writeJson(res, 400, {
+        type: "error",
+        error: {
+            type: "invalid_request_error",
+            message: selection.message
+        }
+    });
+}
 function resolveNativeModelRoute(backend, provider, requested) {
     if (backend.resolveModelRoute === undefined)
         return undefined;
@@ -314,13 +326,19 @@ export async function startGateway(options) {
         }
         // Anthropic single-model retrieve (`GET /v1/models/{id}`): Claude Code probes
         // this to validate a selected model before its first turn. Echo the id back
-        // so any advertised/aliased id validates; routing is decided at chat time.
+        // so any advertised/aliased/effort-qualified id validates; routing is decided
+        // at chat time.
         if (method === "GET" && path.startsWith("/v1/models/")) {
             const id = decodeURIComponent(path.slice("/v1/models/".length));
-            const alias = resolveClaudeModelAlias(id, backend.listModelIds?.());
+            const selection = resolveClaudeSelection(backend, id);
+            if (selection.status === "unsupported_effort") {
+                writeClaudeSelectionError(res, selection);
+                return;
+            }
+            const alias = selection.model;
             const route = backend.resolveModelRoute?.(alias, "claude-code");
             const resolved = route?.publicId ?? alias;
-            if (resolved === undefined ||
+            if (resolved.length === 0 ||
                 (backend.resolveModelRoute !== undefined && route === undefined) ||
                 (backend.resolveModelRoute === undefined &&
                     !(backend.servesModel?.(resolved) ?? false) &&
@@ -450,7 +468,12 @@ export async function startGateway(options) {
             if (rejectInvalid(res, validateCountTokensRequest(raw)))
                 return;
             const rawBody = raw;
-            const alias = resolveClaudeModelAlias(rawBody.model, backend.listModelIds?.());
+            const selection = resolveClaudeSelection(backend, rawBody.model);
+            if (selection.status === "unsupported_effort") {
+                writeClaudeSelectionError(res, selection);
+                return;
+            }
+            const alias = selection.model.length > 0 ? selection.model : undefined;
             const route = backend.resolveModelRoute?.(alias, "claude-code");
             if (alias !== undefined &&
                 backend.resolveModelRoute !== undefined &&
@@ -464,16 +487,21 @@ export async function startGateway(options) {
                 });
                 return;
             }
+            const normalizedBody = selection.status === "resolved" &&
+                alias !== undefined &&
+                alias !== rawBody.model
+                ? withModel(rawBody, alias)
+                : rawBody;
             if (anthropicRelay?.countTokens !== undefined &&
                 (route?.provider === "claude-code" ||
                     backend.resolveModelRoute === undefined)) {
                 const relayBody = route?.provider === "claude-code"
-                    ? withModel(rawBody, route.nativeId)
-                    : rawBody;
+                    ? withModel(normalizedBody, route.nativeId)
+                    : normalizedBody;
                 await pipeUpstream(res, await anthropicRelay.countTokens(req.headers, relayBody));
                 return;
             }
-            await pipeUpstream(res, handleCountTokens(rawBody));
+            await pipeUpstream(res, handleCountTokens(normalizedBody));
             return;
         }
         if (method === "POST" && path === "/v1/messages") {
@@ -483,19 +511,33 @@ export async function startGateway(options) {
             if (rejectInvalid(res, validateAnthropicRequest(raw)))
                 return;
             const rawBody = raw;
-            const resolvedModel = resolveClaudeModelAlias(rawBody.model, backend.listModelIds?.());
+            const selection = resolveClaudeSelection(backend, rawBody.model);
+            if (selection.status === "unsupported_effort") {
+                writeClaudeSelectionError(res, selection);
+                return;
+            }
+            const resolvedModel = selection.status === "resolved"
+                ? selection.model
+                : selection.model.length > 0
+                    ? selection.model
+                    : undefined;
             // Defer an unknown Claude model to the Anthropic adapter so it can emit
             // the native Anthropic error envelope. The later handleModelCall wrapper
             // still records attribution and provenance for the rejected request.
             const route = backend.resolveModelRoute?.(resolvedModel, "claude-code");
             const canonicalModel = route?.publicId ?? resolvedModel;
-            const body = canonicalModel === rawBody.model || canonicalModel === undefined
-                ? rawBody
-                : withModel(rawBody, canonicalModel);
+            const selectedBody = selection.status === "resolved"
+                ? withClaudeReasoningSelection(canonicalModel === rawBody.model || canonicalModel === undefined
+                    ? rawBody
+                    : withModel(rawBody, canonicalModel), selection.selection)
+                : canonicalModel === rawBody.model || canonicalModel === undefined
+                    ? rawBody
+                    : withModel(rawBody, canonicalModel);
+            const body = selectedBody;
             const requestedModel = typeof body.model === "string" ? body.model : undefined;
             if (anthropicRelay !== undefined &&
                 route?.provider === "claude-code") {
-                const relayBody = withModel(rawBody, route.nativeId);
+                const relayBody = withClaudeReasoningSelection(withModel(rawBody, route.nativeId), selection.status === "resolved" ? selection.selection : { mode: "auto" });
                 await dispatchModelCall({
                     dialect: "anthropic-messages",
                     body,

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 } from "../adapters/anthropic.js";
+import { anthropicModelsResponse, anthropicToChat, chatToAnthropicMessage, claudeModelAlias, 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";
@@ -83,6 +83,74 @@ test("anthropicModelsResponse exposes Claude subscription models as bare native
         }
     ]);
 });
+test("anthropicModelsResponse emits base plus discovered effort variants", async () => {
+    const reasoning = {
+        status: "supported",
+        efforts: [
+            { id: "low" },
+            { id: "high", aliases: ["max"] },
+            { id: "high" }
+        ],
+        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
+        }
+    ]), {
+        status: "resolved",
+        model: "codex/gpt-5.5",
+        clientModel: "claude-codex/gpt-5.5",
+        selection: { mode: "effort", effort: "high" }
+    });
+    assert.equal(resolveClaudeModelSelection("claude-codex/gpt-5.5:unknown", ["codex/gpt-5.5"], [
+        {
+            publicId: "codex/gpt-5.5",
+            nativeId: "gpt-5.5",
+            provider: "codex",
+            reasoning
+        }
+    ]).status, "unsupported_effort");
+    assert.deepEqual(withClaudeReasoningSelection({ model: "claude-x", messages: [{ role: "user", content: "hi" }] }, { mode: "effort", effort: "high" }), {
+        model: "claude-x",
+        messages: [{ role: "user", content: "hi" }],
+        thinking: { type: "adaptive" },
+        output_config: { effort: "high" }
+    });
+});
 test("anthropicToChat tolerates thinking: null (same failure class as Responses reasoning: null)", () => {
     const chat = anthropicToChat({ model: "claude-x", messages: [{ role: "user", content: "hi" }], thinking: null }, "claude-x");
     assert.equal(chat.reasoning_effort, undefined);
@@ -791,3 +859,151 @@ 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 () => {
+    const reasoning = {
+        status: "supported",
+        efforts: [{ id: "low" }, { id: "high", aliases: ["max"] }],
+        provenance: "provider"
+    };
+    const sourceCalls = [];
+    const source = (sourceId) => ({
+        sourceId,
+        discoverModels: async () => [
+            {
+                id: sourceId === "claude-code" ? "claude-sonnet-4-6" : "gpt-5.5",
+                reasoning
+            }
+        ],
+        chat: async (body) => {
+            sourceCalls.push(body);
+            return Response.json({
+                id: "chatcmpl_effort",
+                choices: [
+                    {
+                        index: 0,
+                        message: { role: "assistant", content: "TRANSLATED_OK" },
+                        finish_reason: "stop"
+                    }
+                ],
+                usage: { prompt_tokens: 1, completion_tokens: 1 }
+            });
+        },
+        embeddings: async () => Response.json({})
+    });
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { "claude-code": {}, codex: {} },
+            defaultModel: "claude-code/claude-sonnet-4-6"
+        },
+        sources: {
+            "claude-code": source("claude-code"),
+            codex: source("codex")
+        }
+    });
+    const relayedBodies = [];
+    const relay = {
+        dialect: "anthropic",
+        shouldRelay: () => false,
+        relay: async (_headers, body) => {
+            relayedBodies.push(body);
+            return Response.json({
+                id: "msg_effort",
+                type: "message",
+                role: "assistant",
+                model: body.model,
+                content: [{ type: "text", text: "NATIVE_OK" }],
+                stop_reason: "end_turn",
+                stop_sequence: null,
+                usage: { input_tokens: 1, output_tokens: 1 }
+            });
+        }
+    };
+    const gateway = await startGateway({
+        backend,
+        providerRelays: { anthropic: relay }
+    });
+    try {
+        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"));
+        for (const effort of ["low", "high"]) {
+            const response = 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:${effort}`,
+                    max_tokens: 32,
+                    messages: [{ role: "user", content: "hi" }]
+                })
+            });
+            assert.equal(response.status, 200);
+        }
+        assert.deepEqual(relayedBodies.map((body) => [
+            body.model,
+            body.thinking?.type,
+            body.output_config?.effort
+        ]), [
+            ["claude-sonnet-4-6", "adaptive", "low"],
+            ["claude-sonnet-4-6", "adaptive", "high"]
+        ]);
+        const base = 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",
+                max_tokens: 32,
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(base.status, 200);
+        assert.equal(relayedBodies.at(-1)?.output_config, undefined);
+        assert.equal(relayedBodies.at(-1)?.thinking, undefined);
+        const translated = await fetch(`${gateway.url()}/v1/messages`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify({
+                model: "claude-codex/gpt-5.5:max",
+                max_tokens: 32,
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(translated.status, 200);
+        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`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify({
+                model: "claude-sonnet-4-6:bogus",
+                max_tokens: 32,
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(rejected.status, 400);
+        assert.match(await rejected.text(), /not supported/);
+        assert.equal(relayedBodies.length, 3);
+        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" } });
+        assert.equal(retrieve.status, 200);
+        assert.equal((await retrieve.json()).id, "claude-sonnet-4-6:high");
+    }
+    finally {
+        await gateway.close();
+    }
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "0.16.4",
+  "version": "0.16.6",
   "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.16.4",
-    "@velum-labs/routekit-registry": "0.16.4",
-    "@velum-labs/routekit-runtime": "0.16.4",
-    "@velum-labs/routekit-tracing": "0.16.4"
+    "@velum-labs/routekit-contracts": "0.16.6",
+    "@velum-labs/routekit-registry": "0.16.6",
+    "@velum-labs/routekit-runtime": "0.16.6",
+    "@velum-labs/routekit-tracing": "0.16.6"
   },
   "keywords": [
     "routekit",