@velum-labs/routekit-gateway 0.15.0 → 0.16.0

package/dist/adapters/responses.js

@@ -825,13 +825,17 @@ export async function handleResponses(backend, body, modelCallId, signal, backen
             }
         });
     }
-    if (body.previous_response_id != null) {
+    const destinationWireShape = backend.reasoningWireShape?.(upstreamModel);
+    const nativeResponses = backend.responses?.bind(backend);
+    const supportsNativeResponses = nativeResponses !== undefined &&
+        (backend.supportsResponses?.(upstreamModel) ?? true);
+    if (body.previous_response_id != null && !supportsNativeResponses) {
         return jsonResponse(400, {
             error: {
                 type: "invalid_request_error",
                 code: "unsupported_previous_response_id",
                 param: "previous_response_id",
-                message: "previous_response_id is not supported by this stateless gateway; replay prior output items in input"
+                message: "previous_response_id cannot be translated to this destination; replay prior output items in input"
             }
         });
     }
@@ -840,8 +844,9 @@ export async function handleResponses(backend, body, modelCallId, signal, backen
             typeof item.encrypted_content === "string" &&
             item.encrypted_content.length > 0);
     const requestsEncryptedReasoning = Array.isArray(body.include) && body.include.includes("reasoning.encrypted_content");
-    const destinationWireShape = backend.reasoningWireShape?.(upstreamModel);
-    const preservesOpaqueReasoning = destinationWireShape === "openai-responses" || destinationWireShape === "routekit-envelope";
+    const preservesOpaqueReasoning = supportsNativeResponses ||
+        destinationWireShape === "openai-responses" ||
+        destinationWireShape === "routekit-envelope";
     if (hasEncryptedReasoning && !preservesOpaqueReasoning) {
         return jsonResponse(400, {
             error: {
@@ -852,6 +857,12 @@ export async function handleResponses(backend, body, modelCallId, signal, backen
             }
         });
     }
+    if (supportsNativeResponses && nativeResponses !== undefined) {
+        return nativeResponses(body, signal, {
+            ...backendOptions,
+            modelCallId
+        });
+    }
     // Server-executed web search is honored when the caller declared the tool,
     // an executor is available (a provider key exists), and no *client* tool
     // already owns the projected name; otherwise the ingress keeps its

package/dist/backend.d.ts

@@ -61,6 +61,10 @@ export type Backend = {
     reasoningWireShape?(model: string): string | undefined;
     /** POST <base>/chat/completions — supports streaming (SSE) upstream. */
     chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    /** Whether this model can egress through the provider's native Responses API. */
+    supportsResponses?(model: string): boolean;
+    /** POST <base>/responses without translating through Chat Completions. */
+    responses?(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     /** GET <base>/models. */
     models(signal?: AbortSignal): Promise<Response>;
     /** POST <base>/embeddings. */
@@ -122,12 +126,14 @@ export type OpenAiBackendOptions = {
 };
 /** Join a base URL (which may end in `/`) with a route path. */
 export declare function joinPath(baseUrl: string, path: string): string;
-/** An OpenAI Chat Completions backend reached over HTTP. */
+/** An OpenAI HTTP backend supporting Chat Completions and native Responses. */
 export declare class OpenAiBackend implements Backend {
     #private;
     readonly defaultModel: string | undefined;
     constructor(options: OpenAiBackendOptions);
     chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    supportsResponses(): boolean;
+    responses(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     models(signal?: AbortSignal): Promise<Response>;
     embeddings(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
 }
@@ -152,6 +158,8 @@ export declare class ModelRoutedBackend implements Backend {
     resolveModel(requested: string | undefined): string | undefined;
     reasoningWireShape(model: string): string | undefined;
     chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    supportsResponses(model: string): boolean;
+    responses(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     models(signal?: AbortSignal): Promise<Response>;
     embeddings(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     close(): Promise<void>;

package/dist/backend.js

@@ -8,7 +8,7 @@ export function joinPath(baseUrl, path) {
 function invalidReasoningControlResponse(message, metadata = false, path) {
     return Response.json({ error: { type: "invalid_request_error", code: metadata ? "invalid_reasoning_metadata" : "invalid_reasoning_control", ...(path !== undefined ? { param: path } : {}), message } }, { status: 400 });
 }
-/** An OpenAI Chat Completions backend reached over HTTP. */
+/** An OpenAI HTTP backend supporting Chat Completions and native Responses. */
 export class OpenAiBackend {
     #baseUrl;
     #apiKey;
@@ -76,6 +76,23 @@ export class OpenAiBackend {
             ...(signal ? { signal } : {})
         });
     }
+    supportsResponses() {
+        return true;
+    }
+    responses(body, signal, options = {}) {
+        const routed = this.#forceModel !== undefined &&
+            typeof body === "object" &&
+            body !== null &&
+            !Array.isArray(body)
+            ? { ...body, model: this.#forceModel }
+            : body;
+        return fetch(joinPath(this.#baseUrl, "/responses"), {
+            method: "POST",
+            headers: this.#headers(options),
+            body: JSON.stringify(withoutRouteKitExtensions(routed)),
+            ...(signal ? { signal } : {})
+        });
+    }
     #openRouterReasoning(body, selection) {
         const payload = { ...body };
         delete payload.reasoning_effort;
@@ -154,6 +171,24 @@ export class ModelRoutedBackend {
             : undefined;
         return this.#backendFor(model).chat(body, signal, options);
     }
+    supportsResponses(model) {
+        const backend = this.#backendFor(model);
+        const delegatedModel = backend.resolveModel?.(model) ?? backend.defaultModel ?? model;
+        return (backend.responses !== undefined &&
+            (backend.supportsResponses?.(delegatedModel) ?? true));
+    }
+    responses(body, signal, options = {}) {
+        const model = typeof body === "object" &&
+            body !== null &&
+            typeof body.model === "string"
+            ? body.model
+            : undefined;
+        const backend = this.#backendFor(model);
+        if (backend.responses === undefined) {
+            return Promise.resolve(Response.json({ error: { type: "not_supported", message: "native Responses egress is not supported" } }, { status: 501 }));
+        }
+        return backend.responses(body, signal, options);
+    }
     models(signal) {
         return this.#primary.models(signal);
     }

package/dist/http-response.d.ts

@@ -0,0 +1,6 @@
+import type { ServerResponse } from "node:http";
+/**
+ * Wait for backpressure to clear or the client to disconnect, removing the
+ * listener for whichever event loses the race.
+ */
+export declare function waitForDrainOrClose(res: ServerResponse): Promise<"drain" | "close">;

package/dist/http-response.js

@@ -0,0 +1,19 @@
+/**
+ * Wait for backpressure to clear or the client to disconnect, removing the
+ * listener for whichever event loses the race.
+ */
+export function waitForDrainOrClose(res) {
+    if (res.destroyed)
+        return Promise.resolve("close");
+    return new Promise((resolve) => {
+        const settle = (event) => {
+            res.off("drain", onDrain);
+            res.off("close", onClose);
+            resolve(event);
+        };
+        const onDrain = () => settle("drain");
+        const onClose = () => settle("close");
+        res.once("drain", onDrain);
+        res.once("close", onClose);
+    });
+}

package/dist/provider-source.d.ts

@@ -16,6 +16,8 @@ export type ProviderSource = {
     readonly sourceId: ProviderId;
     discoverModels(signal?: AbortSignal): Promise<readonly DiscoveredModel[]>;
     chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    supportsResponses?(model: string): boolean;
+    responses?(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     embeddings(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     capabilities?(model: string): Readonly<Record<string, string>>;
     reasoningCapabilities?(model: string): ModelReasoningCapabilities | undefined;
@@ -35,6 +37,8 @@ export declare class ApiProviderSource implements ProviderSource {
     constructor(options: ApiProviderSourceOptions);
     discoverModels(signal?: AbortSignal): Promise<readonly DiscoveredModel[]>;
     chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    supportsResponses(model: string): boolean;
+    responses(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     embeddings(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     close(): Promise<void> | void;
 }

package/dist/provider-source.js

@@ -342,6 +342,17 @@ export class ApiProviderSource {
     chat(body, signal, options) {
         return this.#backend.chat(body, signal, options);
     }
+    supportsResponses(model) {
+        return (this.sourceId === "openai" &&
+            this.#backend.responses !== undefined &&
+            (this.#backend.supportsResponses?.(model) ?? true));
+    }
+    responses(body, signal, options) {
+        if (this.#backend.responses === undefined) {
+            return Promise.resolve(Response.json({ error: { type: "not_supported", message: "native Responses egress is not supported" } }, { status: 501 }));
+        }
+        return this.#backend.responses(body, signal, options);
+    }
     embeddings(body, signal, options) {
         return this.#backend.embeddings(body, signal, options);
     }

package/dist/router.d.ts

@@ -208,7 +208,9 @@ export declare class CatalogBackend implements Backend {
     capabilities(model: string): Readonly<Record<string, string>>;
     reasoningCapabilities(model: string): ModelReasoningCapabilities | undefined;
     reasoningWireShape(model: string): string | undefined;
+    supportsResponses(model: string): boolean;
     chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    responses(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     models(): Promise<Response>;
     embeddings(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     close(): Promise<void>;

package/dist/router.js

@@ -280,6 +280,16 @@ export function modelPolicyAllowsModel(policy, canonicalModel) {
  * verified; provider discovery and explicit config always take precedence.
  */
 export function inferKnownReasoningCapabilities(provider, model) {
+    if (provider === "openai" &&
+        /^gpt-5\.6(?:-(?:sol|terra|luna))?(?:-\d{4}-\d{2}-\d{2})?$/.test(model)) {
+        return {
+            status: "supported",
+            efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
+            defaultEffort: "medium",
+            wireShape: "openai-responses",
+            provenance: "builtin"
+        };
+    }
     if (provider === "openai" && /^gpt-5\.5(?:-\d{4}-\d{2}-\d{2})?$/.test(model)) {
         return {
             status: "supported",
@@ -486,6 +496,12 @@ export class CatalogBackend {
         // reasoning controls for a particular model.
         return entry.provider === "codex" ? "openai-responses" : entry.reasoning?.wireShape;
     }
+    supportsResponses(model) {
+        const entry = this.#entries.get(model);
+        if (entry === undefined || entry.source.responses === undefined)
+            return false;
+        return entry.source.supportsResponses?.(entry.nativeId) ?? true;
+    }
     chat(body, signal, options) {
         const entry = this.#entry(this.#requestedModel(body));
         const validationError = routeKitRequestValidationErrorOf(body);
@@ -538,6 +554,80 @@ export class CatalogBackend {
             ...(entry.reasoning !== undefined ? { reasoningCapabilities: entry.reasoning } : {})
         });
     }
+    responses(body, signal, options) {
+        const entry = this.#entry(this.#requestedModel(body));
+        if (entry.source.responses === undefined ||
+            entry.source.supportsResponses?.(entry.nativeId) === false) {
+            return Promise.resolve(Response.json({ error: { type: "not_supported", message: "native Responses egress is not supported" } }, { status: 501 }));
+        }
+        const validationError = routeKitRequestValidationErrorOf(body);
+        if (validationError !== undefined) {
+            return Promise.resolve(Response.json({
+                error: {
+                    type: "invalid_request_error",
+                    code: validationError.code,
+                    param: validationError.path,
+                    message: validationError.message
+                }
+            }, { status: 400 }));
+        }
+        const record = typeof body === "object" && body !== null && !Array.isArray(body)
+            ? body
+            : {};
+        const nativeReasoning = typeof record.reasoning === "object" &&
+            record.reasoning !== null &&
+            !Array.isArray(record.reasoning)
+            ? record.reasoning
+            : undefined;
+        const nativeEffort = typeof nativeReasoning?.effort === "string" && nativeReasoning.effort.length > 0
+            ? nativeReasoning.effort
+            : undefined;
+        const envelopeSelection = reasoningSelectionOf(body);
+        if (nativeEffort !== undefined &&
+            envelopeSelection.mode !== "auto" &&
+            (envelopeSelection.mode !== "effort" || envelopeSelection.effort !== nativeEffort)) {
+            return Promise.resolve(Response.json({
+                error: {
+                    type: "invalid_request_error",
+                    code: "invalid_reasoning_control",
+                    param: "reasoning",
+                    message: "reasoning.effort conflicts with x_routekit.selection"
+                }
+            }, { status: 400 }));
+        }
+        const requestedSelection = envelopeSelection.mode === "auto" && nativeEffort !== undefined
+            ? { mode: "effort", effort: nativeEffort }
+            : envelopeSelection;
+        const selection = this.#validatedReasoning(entry, requestedSelection);
+        if (typeof selection === "string") {
+            return Promise.resolve(Response.json({
+                error: {
+                    type: "invalid_request_error",
+                    code: "unsupported_reasoning_control",
+                    message: selection
+                }
+            }, { status: 400 }));
+        }
+        const nativeBody = this.#withNativeModel(record, entry.nativeId);
+        if (selection.mode === "effort") {
+            nativeBody.reasoning = { ...nativeReasoning, effort: selection.effort };
+        }
+        else if (selection.mode === "disabled") {
+            nativeBody.reasoning = { ...nativeReasoning, effort: "none" };
+        }
+        options?.onAttribution?.({
+            effective_model: entry.publicId,
+            native_model: entry.nativeId,
+            provider: entry.provider,
+            billing_mode: isSubscriptionProvider(entry.provider) || entry.provider === "cliproxy"
+                ? "subscription"
+                : "api_key"
+        });
+        return entry.source.responses(nativeBody, signal, {
+            ...options,
+            ...(entry.reasoning !== undefined ? { reasoningCapabilities: entry.reasoning } : {})
+        });
+    }
     models() {
         const data = [...this.#entries.values()].map((entry) => ({
             id: entry.publicId,

package/dist/server.js

@@ -1,4 +1,3 @@
-import { once } from "node:events";
 import { createServer } from "node:http";
 import { ProviderFailureError } from "@velum-labs/routekit-contracts";
 import { anthropicModelsResponse, handleAnthropicMessages, handleCountTokens, resolveClaudeModelAlias } from "./adapters/anthropic.js";
@@ -10,6 +9,7 @@ import { handleResponses } from "./adapters/responses.js";
 import { routeKitRequestValidationErrorOf } from "./adapters/openai-chat-wire.js";
 import { validateAnthropicRequest, validateChatRequest, validateCountTokensRequest, validateResponsesRequest } from "./adapters/validate.js";
 import { buildModelCallRecord, MODEL_CALL_ID_HEADER, modelCallId } from "./provenance.js";
+import { waitForDrainOrClose } from "./http-response.js";
 import { NoModelAvailableError, UnknownModelError } from "./router.js";
 function codexModelInfo(id, priority, reasoning) {
     const levels = (reasoning?.efforts ?? []).map((effort) => ({
@@ -952,7 +952,7 @@ async function pipeUpstream(res, upstream, collectBody = false, signal) {
                     collectedBytes += chunk.length;
                 }
                 if (!res.write(chunk)) {
-                    await Promise.race([once(res, "drain"), once(res, "close")]);
+                    await waitForDrainOrClose(res);
                 }
             }
         }

package/dist/switching-proxy.js

@@ -10,6 +10,7 @@
 import { createServer } from "node:http";
 import { assertAuthenticatedBind, trimTrailingSlashes } from "@velum-labs/routekit-runtime";
 import { ROUTEKIT_PRINCIPAL_HEADER, authorizedRequest, resolvePrincipal } from "./auth.js";
+import { waitForDrainOrClose } from "./http-response.js";
 const MAX_BODY_BYTES = 16 * 1024 * 1024;
 const HOP_BY_HOP = new Set([
     "connection",
@@ -85,10 +86,7 @@ async function pipe(res, upstream) {
             if (done)
                 break;
             if (value !== undefined && !res.write(Buffer.from(value))) {
-                await Promise.race([
-                    new Promise((resolve) => res.once("drain", resolve)),
-                    new Promise((resolve) => res.once("close", resolve))
-                ]);
+                await waitForDrainOrClose(res);
                 if (res.destroyed)
                     break;
             }

package/dist/test/responses.test.js

@@ -59,6 +59,15 @@ async function startMock() {
         close: () => new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())))
     };
 }
+function chatOnlyOpenAiBackend(baseUrl, defaultModel) {
+    const backend = new OpenAiBackend({ baseUrl, defaultModel });
+    return {
+        defaultModel,
+        chat: (body, signal, options) => backend.chat(body, signal, options),
+        models: (signal) => backend.models(signal),
+        embeddings: (body, signal) => backend.embeddings(body, signal)
+    };
+}
 test("responsesToChat maps instructions, input items, and function output", () => {
     const chat = responsesToChat({
         model: "gpt-x",
@@ -291,12 +300,204 @@ test("Responses accepts identical native and envelope effort controls", () => {
     }, "model");
     assert.deepEqual(reasoningSelectionOf(chat), { mode: "effort", effort: "high" });
 });
+test("GPT-5.6 API routes Responses tools and reasoning without Chat translation", async () => {
+    let upstreamPath;
+    let upstreamBody;
+    let upstreamModelCallId;
+    const upstream = createServer((req, res) => {
+        void (async () => {
+            upstreamPath = req.url;
+            upstreamModelCallId =
+                typeof req.headers[MODEL_CALL_ID_HEADER] === "string"
+                    ? req.headers[MODEL_CALL_ID_HEADER]
+                    : undefined;
+            upstreamBody = JSON.parse((await readAll(req)).toString("utf8"));
+            sendJson(res, 200, {
+                id: "resp_native",
+                object: "response",
+                status: "completed",
+                model: upstreamBody.model,
+                output: [
+                    {
+                        id: "msg_native",
+                        type: "message",
+                        role: "assistant",
+                        status: "completed",
+                        content: [{ type: "output_text", text: "NATIVE_OK", annotations: [] }]
+                    }
+                ],
+                usage: { input_tokens: 3, output_tokens: 2, total_tokens: 5 }
+            });
+        })();
+    });
+    await new Promise((resolve) => upstream.listen(0, "127.0.0.1", resolve));
+    const address = upstream.address();
+    const port = typeof address === "object" && address !== null ? address.port : 0;
+    const openai = new OpenAiBackend({
+        baseUrl: `http://127.0.0.1:${port}/v1`,
+        apiKey: "test-key"
+    });
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { openai: {} },
+            defaultModel: "openai/gpt-5.6-sol"
+        },
+        sources: {
+            openai: {
+                sourceId: "openai",
+                async discoverModels() {
+                    return [{ id: "gpt-5.6-sol" }];
+                },
+                chat: () => {
+                    throw new Error("Chat Completions must not be used for GPT-5.6 Responses");
+                },
+                supportsResponses: () => openai.supportsResponses(),
+                responses: (body, signal, options) => openai.responses(body, signal, options),
+                embeddings: async () => Response.json({})
+            }
+        }
+    });
+    const gateway = await startGateway({ backend });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "openai/gpt-5.6-sol",
+                input: [
+                    {
+                        role: "user",
+                        content: [{ type: "input_text", text: "Use the tool." }]
+                    }
+                ],
+                reasoning: { effort: "high" },
+                tools: [
+                    {
+                        type: "function",
+                        name: "lookup",
+                        description: "Look up a value",
+                        parameters: {
+                            type: "object",
+                            properties: { id: { type: "string" } },
+                            required: ["id"],
+                            additionalProperties: false
+                        },
+                        strict: true
+                    }
+                ],
+                x_routekit: {
+                    version: 1,
+                    selection: { mode: "effort", effort: "high" }
+                }
+            })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(upstreamPath, "/v1/responses");
+        assert.equal(upstreamBody?.model, "gpt-5.6-sol");
+        assert.deepEqual(upstreamBody?.reasoning, { effort: "high" });
+        assert.equal(upstreamBody?.tools?.length, 1);
+        assert.equal(Object.hasOwn(upstreamBody ?? {}, "x_routekit"), false);
+        assert.ok(upstreamModelCallId);
+        assert.equal((await response.json())
+            .output?.[0]?.content?.[0]?.text, "NATIVE_OK");
+        assert.deepEqual(backend.modelInfo("openai/gpt-5.6-sol")?.reasoning, {
+            status: "supported",
+            efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
+            defaultEffort: "medium",
+            wireShape: "openai-responses",
+            provenance: "builtin"
+        });
+    }
+    finally {
+        await gateway.close();
+        await new Promise((resolve, reject) => upstream.close((error) => (error ? reject(error) : resolve())));
+    }
+});
+test("OpenAI API keeps non-reasoning models on native Responses", async () => {
+    let upstreamPath;
+    let upstreamBody;
+    const upstream = createServer((req, res) => {
+        void (async () => {
+            upstreamPath = req.url;
+            upstreamBody = JSON.parse((await readAll(req)).toString("utf8"));
+            sendJson(res, 200, {
+                id: "resp_general",
+                object: "response",
+                status: "completed",
+                model: upstreamBody.model,
+                output: []
+            });
+        })();
+    });
+    await new Promise((resolve) => upstream.listen(0, "127.0.0.1", resolve));
+    const address = upstream.address();
+    const port = typeof address === "object" && address !== null ? address.port : 0;
+    const openai = new OpenAiBackend({
+        baseUrl: `http://127.0.0.1:${port}/v1`,
+        apiKey: "test-key"
+    });
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { openai: {} },
+            defaultModel: "openai/gpt-4.1"
+        },
+        sources: {
+            openai: {
+                sourceId: "openai",
+                async discoverModels() {
+                    return [{ id: "gpt-4.1" }];
+                },
+                chat: () => {
+                    throw new Error("Chat Completions must not be used for OpenAI Responses");
+                },
+                supportsResponses: () => openai.supportsResponses(),
+                responses: (body, signal, options) => openai.responses(body, signal, options),
+                embeddings: async () => Response.json({})
+            }
+        }
+    });
+    const gateway = await startGateway({ backend });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "openai/gpt-4.1",
+                input: "Use the tool.",
+                previous_response_id: "resp_previous",
+                tools: [
+                    {
+                        type: "function",
+                        name: "lookup",
+                        description: "Look up a value",
+                        parameters: {
+                            type: "object",
+                            properties: { id: { type: "string" } },
+                            required: ["id"],
+                            additionalProperties: false
+                        },
+                        strict: true
+                    }
+                ]
+            })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(upstreamPath, "/v1/responses");
+        assert.equal(upstreamBody?.model, "gpt-4.1");
+        assert.equal(upstreamBody?.previous_response_id, "resp_previous");
+        assert.equal(upstreamBody?.tools?.length, 1);
+    }
+    finally {
+        await gateway.close();
+        await new Promise((resolve, reject) => upstream.close((error) => (error ? reject(error) : resolve())));
+    }
+});
 test("serves a Responses request carrying reasoning: null end to end", async () => {
     // The member capture gateway path: codex exec -> /v1/responses with
     // `reasoning: null` -> chat completion upstream. Must be a 200, never a 502.
     const mock = await startMock();
     const gateway = await startGateway({
-        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "grok-4" })
+        backend: chatOnlyOpenAiBackend(`${mock.url}/v1`, "grok-4")
     });
     try {
         const response = await fetch(`${gateway.url()}/v1/responses`, {
@@ -405,7 +606,7 @@ test("Responses routes discovered Claude efforts to adaptive Anthropic egress",
 test("serves a Responses request with null optional fields end to end", async () => {
     const mock = await startMock();
     const gateway = await startGateway({
-        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "local-model" })
+        backend: chatOnlyOpenAiBackend(`${mock.url}/v1`, "local-model")
     });
     try {
         const response = await fetch(`${gateway.url()}/v1/responses`, {
@@ -435,7 +636,7 @@ test("serves a Responses request with null optional fields end to end", async ()
 test("serves a non-streaming Responses object end to end", async () => {
     const mock = await startMock();
     const gateway = await startGateway({
-        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "local-model" })
+        backend: chatOnlyOpenAiBackend(`${mock.url}/v1`, "local-model")
     });
     try {
         const response = await fetch(`${gateway.url()}/v1/responses`, {
@@ -1226,7 +1427,7 @@ test("a mid-stream provider error event becomes response.failed with the upstrea
 test("translates a streamed Responses event sequence", async () => {
     const mock = await startMock();
     const gateway = await startGateway({
-        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "local-model" })
+        backend: chatOnlyOpenAiBackend(`${mock.url}/v1`, "local-model")
     });
     try {
         const response = await fetch(`${gateway.url()}/v1/responses`, {

package/dist/test/server-resilience.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
 import { startGateway } from "../server.js";
+import { startSwitchingGatewayProxy } from "../switching-proxy.js";
 /**
  * Crash resilience: an upstream stream that dies mid-response (the shape of a
  * local model server being OOM-killed during a turn) must fail only that one
@@ -167,3 +168,53 @@ test("oversized request bodies are rejected before the backend is called", async
         await gateway.close();
     }
 });
+test("stream backpressure does not retain close listeners", async () => {
+    const warnings = [];
+    const onWarning = (warning) => {
+        if (warning.name === "MaxListenersExceededWarning" &&
+            warning.message.includes("ServerResponse")) {
+            warnings.push(warning);
+        }
+    };
+    process.on("warning", onWarning);
+    const chunk = Buffer.alloc(128 * 1024, "x");
+    const chunkCount = 24;
+    let emitted = 0;
+    const backend = {
+        defaultModel: "mock-model",
+        chat: async () => new Response(new ReadableStream({
+            pull(controller) {
+                if (emitted === chunkCount) {
+                    controller.close();
+                    return;
+                }
+                emitted += 1;
+                controller.enqueue(chunk);
+            }
+        }), { status: 200, headers: { "content-type": "application/octet-stream" } }),
+        models: async () => Response.json({ data: [] }),
+        embeddings: async () => Response.json({})
+    };
+    const gateway = await startGateway({ backend });
+    const proxy = await startSwitchingGatewayProxy({ target: gateway.url() });
+    try {
+        const response = await fetch(`${proxy.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "mock-model",
+                stream: true,
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(response.status, 200);
+        assert.equal((await response.arrayBuffer()).byteLength, chunk.length * chunkCount);
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.deepEqual(warnings, []);
+    }
+    finally {
+        process.off("warning", onWarning);
+        await proxy.close();
+        await gateway.close();
+    }
+});

package/package.json

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