@velum-labs/routekit-gateway 0.16.8 → 0.17.0

package/dist/server.js

@@ -79,6 +79,23 @@ function writeClaudeSelectionError(res, selection) {
         }
     });
 }
+/**
+ * Recent Claude Code versions send adaptive thinking and an effort on every
+ * turn, including for picker entries that advertise no reasoning controls.
+ * The picker is authoritative here: forwarding that implicit client default
+ * would make the router reject an otherwise valid model before it reaches its
+ * provider. Keep explicit RouteKit effort variants strict, but remove the
+ * unrepresentable native default for a base, non-reasoning route.
+ */
+function withoutUnsupportedClaudeReasoning(body) {
+    const { thinking: _thinking, output_config: outputConfig, ...rest } = body;
+    if (outputConfig === undefined || outputConfig === null)
+        return rest;
+    const { effort: _effort, ...remainingOutputConfig } = outputConfig;
+    return Object.keys(remainingOutputConfig).length === 0
+        ? rest
+        : { ...rest, output_config: remainingOutputConfig };
+}
 function resolveNativeModelRoute(backend, provider, requested) {
     if (backend.resolveModelRoute === undefined)
         return undefined;
@@ -529,13 +546,19 @@ export async function startGateway(options) {
             // still records attribution and provenance for the rejected request.
             const route = backend.resolveModelRoute?.(resolvedModel, "claude-code");
             const canonicalModel = route?.publicId ?? resolvedModel;
+            const normalizedRawBody = selection.status === "resolved" &&
+                selection.selection.mode === "auto" &&
+                route !== undefined &&
+                route?.reasoning?.status !== "supported"
+                ? withoutUnsupportedClaudeReasoning(rawBody)
+                : rawBody;
             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);
+                ? withClaudeReasoningSelection(canonicalModel === normalizedRawBody.model || canonicalModel === undefined
+                    ? normalizedRawBody
+                    : withModel(normalizedRawBody, canonicalModel), selection.selection)
+                : canonicalModel === normalizedRawBody.model || canonicalModel === undefined
+                    ? normalizedRawBody
+                    : withModel(normalizedRawBody, canonicalModel);
             const body = selectedBody;
             const requestedModel = typeof body.model === "string" ? body.model : undefined;
             if (anthropicRelay !== undefined &&

package/dist/test/anthropic.test.js

@@ -742,6 +742,60 @@ test("estimates tokens and serves Anthropic discovery", async () => {
         await mock.close();
     }
 });
+test("Claude's implicit thinking default does not reject a base model without reasoning controls", async () => {
+    const calls = [];
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { openai: {} },
+            defaultModel: "openai/mock-model"
+        },
+        sources: {
+            openai: {
+                sourceId: "openai",
+                async discoverModels() {
+                    return [{ id: "mock-model" }];
+                },
+                async chat(body) {
+                    calls.push(body);
+                    return Response.json({
+                        id: "chatcmpl_no_reasoning",
+                        choices: [
+                            {
+                                index: 0,
+                                message: { role: "assistant", content: "OK" },
+                                finish_reason: "stop"
+                            }
+                        ],
+                        usage: { prompt_tokens: 1, completion_tokens: 1 }
+                    });
+                },
+                async embeddings() {
+                    return Response.json({});
+                }
+            }
+        }
+    });
+    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: "claude-openai/mock-model",
+                max_tokens: 32,
+                thinking: { type: "adaptive" },
+                output_config: { effort: "high" },
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(calls.length, 1);
+        assert.equal(calls[0]?.reasoning_effort, undefined);
+    }
+    finally {
+        await gateway.close();
+    }
+});
 test("Claude picker aliases use the canonical catalog and pooled native relay", async () => {
     const sourceCalls = [];
     const source = (sourceId) => ({

package/package.json

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