@velum-labs/routekit-gateway 1.0.0 → 1.0.2

package/dist/adapters/responses.js

@@ -179,7 +179,9 @@ export function handleResponses(backend, body, modelCallId, signal, backendOptio
         const upstream = yield* backend.chat(chat, signal, requestOptions);
         if (!upstream.ok) {
             const detail = yield* gatewayTryPromise(() => upstream.text());
-            return jsonResponse(upstream.status, { error: unwrapUpstreamError(detail) });
+            return jsonResponse(upstream.status, {
+                error: unwrapUpstreamError(detail, { preserveMetadata: true })
+            });
         }
         if (executor !== undefined) {
             const loopOptions = {

package/dist/adapters/upstream-error.d.ts

@@ -8,7 +8,11 @@
  * `invalid_request_error` from the backend must stay an
  * `invalid_request_error` on the door.
  */
-export declare function unwrapUpstreamError(detail: string): {
+export declare function unwrapUpstreamError(detail: string, options?: {
+    readonly preserveMetadata?: boolean;
+}): {
     type: string;
     message: string;
+    code?: string;
+    param?: string;
 };

package/dist/adapters/upstream-error.js

@@ -8,13 +8,23 @@
  * `invalid_request_error` from the backend must stay an
  * `invalid_request_error` on the door.
  */
-export function unwrapUpstreamError(detail) {
+export function unwrapUpstreamError(detail, options = {}) {
     try {
         const parsed = JSON.parse(detail);
         if (typeof parsed.error?.message === "string") {
             return {
                 type: typeof parsed.error.type === "string" ? parsed.error.type : "api_error",
-                message: parsed.error.message
+                message: parsed.error.message,
+                ...(options.preserveMetadata === true &&
+                    typeof parsed.error.code === "string" &&
+                    parsed.error.code.length > 0
+                    ? { code: parsed.error.code }
+                    : {}),
+                ...(options.preserveMetadata === true &&
+                    typeof parsed.error.param === "string" &&
+                    parsed.error.param.length > 0
+                    ? { param: parsed.error.param }
+                    : {})
             };
         }
     }

package/dist/providers/openai-backend.js

@@ -7,6 +7,7 @@ import { Effect } from "effect";
 import { REASONING_SELECTION, reasoningSelectionOf, routeKitRequestValidationErrorOf, withoutRouteKitExtensions } from "../adapters/openai-chat-wire.js";
 import { normalizeOpenAiResponsesCallIds } from "../adapters/openai-responses-wire.js";
 import { joinPath, staticBackendModelPort } from "./backend.js";
+import { openaiChatUsesMaxCompletionTokens } from "./openai-reasoning.js";
 function invalidReasoningControlResponse(message, metadata = false, path) {
     return Response.json({
         error: {
@@ -17,6 +18,23 @@ function invalidReasoningControlResponse(message, metadata = false, path) {
         }
     }, { status: 400 });
 }
+function withChatCompletionTokenBudget(payload) {
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return payload;
+    }
+    const body = payload;
+    const model = typeof body.model === "string" ? body.model : "";
+    if (!openaiChatUsesMaxCompletionTokens(model))
+        return payload;
+    if (!Object.hasOwn(body, "max_tokens"))
+        return payload;
+    const next = { ...body };
+    if (!Object.hasOwn(next, "max_completion_tokens")) {
+        next.max_completion_tokens = next.max_tokens;
+    }
+    delete next.max_tokens;
+    return next;
+}
 /** An OpenAI HTTP backend supporting Chat Completions and native Responses. */
 export class OpenAiBackend {
     #baseUrl;
@@ -97,7 +115,7 @@ export class OpenAiBackend {
             !Array.isArray(selectedPayload)
             ? this.#openRouterReasoning(selectedPayload, selection)
             : selectedPayload;
-        const providerPayload = withoutRouteKitExtensions(payload);
+        const providerPayload = withChatCompletionTokenBudget(withoutRouteKitExtensions(payload));
         return this.#request("/chat/completions", {
             method: "POST",
             headers: this.#headers(options),

package/dist/providers/openai-reasoning.d.ts

@@ -5,3 +5,5 @@
  */
 import type { ModelReasoningCapabilities } from "@velum-labs/routekit-contracts";
 export declare function openaiReasoningCapabilities(modelId: string): ModelReasoningCapabilities | undefined;
+/** GPT-5.x Chat Completions reject legacy `max_tokens`; use `max_completion_tokens`. */
+export declare function openaiChatUsesMaxCompletionTokens(modelId: string): boolean;

package/dist/providers/openai-reasoning.js

@@ -23,3 +23,7 @@ export function openaiReasoningCapabilities(modelId) {
     }
     return undefined;
 }
+/** GPT-5.x Chat Completions reject legacy `max_tokens`; use `max_completion_tokens`. */
+export function openaiChatUsesMaxCompletionTokens(modelId) {
+    return /(?:^|[./])gpt-5(?:[.:-]|$)/.test(modelId);
+}

package/dist/routing/router.js

@@ -332,6 +332,7 @@ export class RoutingBackend {
                 error: {
                     type: "invalid_request_error",
                     code: "unsupported_reasoning_control",
+                    param: requestedSelection.mode === "effort" ? "reasoning.effort" : "reasoning",
                     message: selection
                 }
             }, { status: 400 }));
@@ -422,6 +423,7 @@ export class RoutingBackend {
                 error: {
                     type: "invalid_request_error",
                     code: "unsupported_reasoning_control",
+                    param: requestedSelection.mode === "effort" ? "reasoning.effort" : "reasoning",
                     message: selection
                 }
             }, { status: 400 }));

package/dist/test/chat.test.js

@@ -126,6 +126,64 @@ test("injects the default model and pipes the completion back", async () => {
         await mock.close();
     }
 });
+test("GPT-5 Chat Completions translate max_tokens to max_completion_tokens", async () => {
+    const mock = await startMock();
+    const backend = new OpenAiBackend({ baseUrl: `${mock.url}/v1` });
+    const gateway = await startGateway({ backend });
+    try {
+        for (const model of [
+            "gpt-5.6-sol",
+            "openai.gpt-5.6-luna",
+            "bedrock/openai.gpt-5.5",
+            "routekit/bedrock/us.openai.gpt-5.7"
+        ]) {
+            const response = await fetch(`${gateway.url()}/v1/chat/completions`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    model,
+                    max_tokens: 128,
+                    messages: [{ role: "user", content: "hi" }]
+                })
+            });
+            assert.equal(response.status, 200, model);
+            const body = mock.lastChatBody();
+            assert.equal(body?.max_completion_tokens, 128, model);
+            assert.equal("max_tokens" in (body ?? {}), false, model);
+        }
+        const modern = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "bedrock/openai.gpt-5.6-terra",
+                max_tokens: 128,
+                max_completion_tokens: 256,
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(modern.status, 200);
+        const modernBody = mock.lastChatBody();
+        assert.equal(modernBody?.max_completion_tokens, 256);
+        assert.equal("max_tokens" in (modernBody ?? {}), false);
+        const legacy = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "gpt-4o",
+                max_tokens: 64,
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(legacy.status, 200);
+        const legacyBody = mock.lastChatBody();
+        assert.equal(legacyBody?.max_tokens, 64);
+        assert.equal("max_completion_tokens" in (legacyBody ?? {}), false);
+    }
+    finally {
+        await Effect.runPromise(gateway.close);
+        await mock.close();
+    }
+});
 test("compound provider operations are not counted as retries", () => {
     const attribution = collectAttribution({
         effective_model: "codex/gpt-test",

package/dist/test/openai-reasoning.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { openaiReasoningCapabilities } from "../providers/openai-reasoning.js";
+import { openaiChatUsesMaxCompletionTokens, openaiReasoningCapabilities } from "../providers/openai-reasoning.js";
 test("OpenAI source authors verified GPT-5.5 and GPT-5.6 reasoning controls", () => {
     assert.deepEqual(openaiReasoningCapabilities("gpt-5.6-sol"), {
         status: "supported",
@@ -25,3 +25,23 @@ test("OpenAI source authors verified GPT-5.5 and GPT-5.6 reasoning controls", ()
     assert.equal(openaiReasoningCapabilities("gpt-4o"), undefined);
     assert.equal(openaiReasoningCapabilities("gpt-5.4"), undefined);
 });
+test("GPT-5 Chat Completions family uses max_completion_tokens", () => {
+    for (const model of [
+        "gpt-5",
+        "gpt-5.5",
+        "gpt-5.6",
+        "gpt-5.6-sol",
+        "gpt-5.6-terra",
+        "gpt-5.6-luna",
+        "gpt-5-mini",
+        "openai/gpt-5.5",
+        "openai.gpt-5.6-sol",
+        "bedrock/openai.gpt-5.6-sol",
+        "routekit/bedrock/us.openai.gpt-5.6-sol"
+    ]) {
+        assert.equal(openaiChatUsesMaxCompletionTokens(model), true, model);
+    }
+    for (const model of ["gpt-4o", "gpt-4.1", "o3", "claude-sonnet-4-6", "not-gpt-5.6"]) {
+        assert.equal(openaiChatUsesMaxCompletionTokens(model), false, model);
+    }
+});

package/dist/test/responses-reasoning.test.js

@@ -320,7 +320,9 @@ test("Responses routes discovered Claude efforts to adaptive Anthropic egress",
             })
         });
         assert.equal(unsupported.status, 400);
-        assert.equal((await unsupported.json()).error?.message, 'reasoning effort "max" is not supported by model "claude-code/claude-fable-5"');
+        const error = (await unsupported.json());
+        assert.equal(error.error?.param, "reasoning.effort");
+        assert.equal(error.error?.message, 'reasoning effort "max" is not supported by model "claude-code/claude-fable-5"');
         assert.equal(requests.length, 1);
     }
     finally {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "1.0.0",
+  "version": "1.0.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -45,12 +45,12 @@
     "@aws-sdk/client-bedrock": "3.1095.0",
     "@aws-sdk/client-bedrock-runtime": "3.1095.0",
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-config-core": "1.0.0",
-    "@velum-labs/routekit-contracts": "1.0.0",
-    "@velum-labs/routekit-eval-contracts": "1.0.0",
-    "@velum-labs/routekit-eval-core": "1.0.0",
-    "@velum-labs/routekit-registry": "1.0.0",
-    "@velum-labs/routekit-runtime": "1.0.0"
+    "@velum-labs/routekit-config-core": "1.0.2",
+    "@velum-labs/routekit-contracts": "1.0.2",
+    "@velum-labs/routekit-eval-contracts": "1.0.2",
+    "@velum-labs/routekit-eval-core": "1.0.2",
+    "@velum-labs/routekit-registry": "1.0.2",
+    "@velum-labs/routekit-runtime": "1.0.2"
   },
   "keywords": [
     "routekit",