@velum-labs/routekit-gateway 0.9.2 → 0.9.3

package/dist/router.js

@@ -367,6 +367,9 @@ export class CatalogBackend {
                 nativeBody.reasoning_effort =
                     selection.effort;
             }
+            else {
+                delete nativeBody.reasoning_effort;
+            }
         }
         return entry.source.chat(nativeBody, signal, {
             ...options,
@@ -437,6 +440,13 @@ export class CatalogBackend {
             return selection;
         }
         const capability = entry.reasoning;
+        if (selection.mode === "effort" &&
+            selection.effort === "none" &&
+            (capability === undefined ||
+                capability.status === "unknown" ||
+                capability.status === "unsupported")) {
+            return { mode: "disabled" };
+        }
         if (capability === undefined || capability.status === "unknown") {
             return `model "${entry.publicId}" has no discovered reasoning controls`;
         }

package/dist/server.js

@@ -247,6 +247,7 @@ export async function startGateway(options) {
                         : base.data ?? [];
                     writeJson(res, 200, {
                         object: "list",
+                        default_model: backend.defaultModel,
                         data,
                         models: codexPickerModels(backend, base.data ?? [], merged.models, codexProviderRelay === undefined)
                     });
@@ -263,6 +264,7 @@ export async function startGateway(options) {
             writeJson(res, 200, {
                 ...modelPayload,
                 object: typeof modelPayload.object === "string" ? modelPayload.object : "list",
+                default_model: backend.defaultModel,
                 data,
                 models: codexPickerModels(backend, data.flatMap((entry) => typeof entry.id === "string"
                     ? [{ ...entry, id: entry.id }]

package/dist/test/chat.test.js

@@ -333,12 +333,16 @@ test("forceModel overrides the requested model on every upstream call", async ()
 test("lists models from the backend", async () => {
     const mock = await startMock();
     const gateway = await startGateway({
-        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1` })
+        backend: new OpenAiBackend({
+            baseUrl: `${mock.url}/v1`,
+            defaultModel: "mlx-default"
+        })
     });
     try {
         const response = await fetch(`${gateway.url()}/v1/models`);
         assert.equal(response.status, 200);
         const json = (await response.json());
+        assert.equal(json.default_model, "mlx-default");
         assert.equal(json.data.length, 1);
     }
     finally {

package/dist/test/responses.test.js

@@ -657,6 +657,7 @@ test("Codex picker aliases use the canonical catalog and pooled native relay", a
         const catalogResponse = await fetch(`${gateway.url()}/v1/models?client_version=1.0.0`);
         assert.equal(catalogResponse.headers.get("etag"), null, "a projected managed catalog must not reuse the upstream ETag");
         const catalog = (await catalogResponse.json());
+        assert.equal(catalog.default_model, "codex/gpt-5.5");
         assert.deepEqual(catalog.data.map((model) => model.id), ["codex/gpt-5.5", "claude-code/claude-sonnet-4-6"]);
         assert.deepEqual(catalog.models.map(({ slug, display_name }) => [slug, display_name]), [
             ["gpt-5.5", "GPT-5.5"],
@@ -693,11 +694,13 @@ test("Codex picker aliases use the canonical catalog and pooled native relay", a
             body: JSON.stringify({
                 model: "claude-code/claude-sonnet-4-6",
                 instructions: "You are Codex, a coding agent based on GPT-5.",
-                input: "hi"
+                input: "hi",
+                reasoning: { effort: "none" }
             })
         });
         assert.equal(foreign.status, 200);
         assert.deepEqual(sourceCalls, ["claude-sonnet-4-6"]);
+        assert.equal(sourceBodies[0]?.reasoning_effort, undefined);
         assert.ok(!JSON.stringify(sourceBodies[0]?.messages).includes("based on GPT-5"), "a stale startup-model identity must not cross into a foreign provider");
         const unknown = await fetch(`${gateway.url()}/v1/responses`, {
             method: "POST",

package/dist/test/router.test.js

@@ -268,6 +268,67 @@ test("catalog applies configured opaque efforts and rejects unavailable values b
     assert.equal(calls.length, 1);
     assert.equal(backend.reasoningCapabilities("openai/opaque")?.provenance, "config");
 });
+test("catalog treats Codex none as disabled only for models without reasoning controls", async () => {
+    const exercise = async (reasoning, effort) => {
+        const bodies = [];
+        const backend = await CatalogBackend.create({
+            config: {
+                providers: { openai: {} },
+                defaultModel: "openai/model"
+            },
+            sources: {
+                openai: {
+                    sourceId: "openai",
+                    async discoverModels() {
+                        return [{ id: "model", ...(reasoning !== undefined ? { reasoning } : {}) }];
+                    },
+                    async chat(body) {
+                        bodies.push(body);
+                        return Response.json({});
+                    },
+                    async embeddings() {
+                        return Response.json({});
+                    }
+                }
+            }
+        });
+        return {
+            response: await backend.chat({
+                model: "openai/model",
+                reasoning_effort: effort,
+                messages: []
+            }),
+            bodies
+        };
+    };
+    for (const reasoning of [
+        undefined,
+        { status: "unknown", provenance: "unknown" },
+        { status: "unsupported", provenance: "provider" }
+    ]) {
+        const normalized = await exercise(reasoning, "none");
+        assert.equal(normalized.response.status, 200);
+        assert.equal(normalized.bodies.length, 1);
+        assert.equal(normalized.bodies[0]?.reasoning_effort, undefined);
+    }
+    const undiscoveredEffort = await exercise(undefined, "medium");
+    assert.equal(undiscoveredEffort.response.status, 400);
+    assert.equal(undiscoveredEffort.bodies.length, 0);
+    const advertisedNone = await exercise({
+        status: "supported",
+        efforts: [{ id: "none" }, { id: "high" }],
+        provenance: "provider"
+    }, "none");
+    assert.equal(advertisedNone.response.status, 200);
+    assert.equal(advertisedNone.bodies[0]?.reasoning_effort, "none");
+    const unsupportedNone = await exercise({
+        status: "supported",
+        efforts: [{ id: "low" }, { id: "high" }],
+        provenance: "provider"
+    }, "none");
+    assert.equal(unsupportedNone.response.status, 400);
+    assert.equal(unsupportedNone.bodies.length, 0);
+});
 test("unknown models never fall through to the default source", async () => {
     const backend = await CatalogBackend.create({
         config: { providers: { openai: {} } },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "0.9.2",
+  "version": "0.9.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/handoffkit.git",
@@ -27,10 +27,10 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@velum-labs/routekit-registry": "0.9.2",
-    "@velum-labs/routekit-contracts": "0.9.2",
-    "@velum-labs/routekit-tracing": "0.9.2",
-    "@velum-labs/routekit-runtime": "0.9.2"
+    "@velum-labs/routekit-contracts": "0.9.3",
+    "@velum-labs/routekit-registry": "0.9.3",
+    "@velum-labs/routekit-tracing": "0.9.3",
+    "@velum-labs/routekit-runtime": "0.9.3"
   },
   "keywords": [
     "routekit",