@velum-labs/routekit-gateway 0.18.0 → 0.18.2

package/dist/backend.d.ts

@@ -44,8 +44,8 @@ export type Backend = {
     resolveModelRoute?(requested: string | undefined, nativeProvider?: string): BackendModelRoute | undefined;
     /**
      * Whether the backend serves this exact model id itself. Unlike
-     * {@link resolveModel} — which folds unknown
-     * ids into the default — this distinguishes "mine" from "unknown", so the
+     * The defaulting resolver folds unknown ids into the default; this
+     * distinguishes "mine" from "unknown", so the
      * gateway can hand unknown ids to a relay (e.g. the Codex backend relay)
      * instead of silently routing them to the default.
      */

package/dist/bedrock-source.d.ts

@@ -17,6 +17,6 @@ export declare class BedrockProviderSource implements ProviderSource {
     discoverModels(signal?: AbortSignal): Promise<readonly DiscoveredModel[]>;
     chat(body: unknown, signal?: AbortSignal, _options?: BackendRequestOptions): Promise<Response>;
     embeddings(): Promise<Response>;
-    reasoningCapabilities(): DiscoveredModel["reasoning"];
+    reasoningCapabilities(model?: string): DiscoveredModel["reasoning"];
     close(): void;
 }

package/dist/bedrock-source.js

@@ -27,6 +27,34 @@ function activeAnthropicProfile(profile, anthropicModels) {
             return id !== undefined && anthropicModels.has(id);
         });
 }
+function isOpusFiveModel(modelId) {
+    return /(?:^|\.)anthropic\.claude-opus-5$/.test(modelId);
+}
+function inferenceProfilePriority(profileId) {
+    if (profileId.startsWith("us."))
+        return 0;
+    if (profileId.startsWith("global."))
+        return 1;
+    return 2;
+}
+function preferredInferenceProfile(current, candidate) {
+    if (current === undefined)
+        return candidate;
+    return inferenceProfilePriority(candidate) < inferenceProfilePriority(current)
+        ? candidate
+        : current;
+}
+function bedrockReasoningCapabilities(modelId) {
+    if (modelId === undefined || !isOpusFiveModel(modelId))
+        return undefined;
+    return {
+        status: "supported",
+        efforts: ["low", "medium", "high", "max"].map((id) => ({ id })),
+        adaptive: true,
+        wireShape: "bedrock-converse",
+        provenance: "builtin"
+    };
+}
 function bedrockMetadata(model) {
     const inputModalities = (model.inputModalities ?? []).map((value) => value.toLowerCase());
     const outputModalities = (model.outputModalities ?? []).map((value) => value.toLowerCase());
@@ -43,9 +71,11 @@ function bedrockMetadata(model) {
     };
 }
 function bedrockDiscoveredModel(id, model) {
+    const reasoning = bedrockReasoningCapabilities(model.modelId);
     return {
         id,
         metadata: bedrockMetadata(model),
+        ...(reasoning !== undefined ? { reasoning } : {}),
         ...(model.responseStreamingSupported !== undefined
             ? {
                 capabilities: {
@@ -196,7 +226,15 @@ export function toBedrockConverseInput(body) {
     const selection = reasoningSelectionOf(body);
     const thinking = selection.mode === "budget"
         ? { thinking: { type: "enabled", budget_tokens: selection.budgetTokens } }
-        : undefined;
+        : isOpusFiveModel(canonical.model)
+            ? selection.mode === "effort"
+                ? { thinking: { type: "adaptive" }, output_config: { effort: selection.effort } }
+                : selection.mode === "adaptive"
+                    ? { thinking: { type: "adaptive" } }
+                    : selection.mode === "disabled"
+                        ? { thinking: { type: "disabled" } }
+                        : undefined
+            : undefined;
     const additionalModelRequestFields = thinking !== undefined || typeof canonical.top_k === "number"
         ? {
             ...thinking,
@@ -393,11 +431,13 @@ export class BedrockProviderSource {
     sourceId = "bedrock";
     #control;
     #runtime;
+    #inferenceProfilesByFoundation = new Map();
     constructor(options = {}) {
         this.#control = options.controlClient ?? new BedrockClient({});
         this.#runtime = options.runtimeClient ?? new BedrockRuntimeClient({});
     }
     async discoverModels(signal) {
+        this.#inferenceProfilesByFoundation.clear();
         const foundation = await this.#control.send(new ListFoundationModelsCommand({ byProvider: "Anthropic" }), signal === undefined ? undefined : { abortSignal: signal });
         const foundations = (foundation.modelSummaries ?? []).filter(anthropicFoundationModel);
         const byId = new Map(foundations.map((model) => [model.modelId, model]));
@@ -416,6 +456,7 @@ export class BedrockProviderSource {
                     .map((model) => foundationIdFromArn(model.modelArn))
                     .find((id) => id !== undefined && ids.has(id));
                 if (backingId !== undefined) {
+                    this.#inferenceProfilesByFoundation.set(backingId, preferredInferenceProfile(this.#inferenceProfilesByFoundation.get(backingId), profile.inferenceProfileId));
                     discovered.set(profile.inferenceProfileId, bedrockDiscoveredModel(profile.inferenceProfileId, byId.get(backingId)));
                 }
             }
@@ -437,14 +478,18 @@ export class BedrockProviderSource {
         const modelId = input.modelId;
         if (modelId === undefined)
             return errorResponse(new Error("Bedrock chat requires a model"));
+        const runtimeModelId = modelId === "anthropic.claude-opus-5"
+            ? this.#inferenceProfilesByFoundation.get(modelId) ?? modelId
+            : modelId;
+        const runtimeInput = runtimeModelId === modelId ? input : { ...input, modelId: runtimeModelId };
         try {
             if (stream) {
-                const output = await this.#runtime.send(new ConverseStreamCommand(input), signal === undefined ? undefined : { abortSignal: signal });
+                const output = await this.#runtime.send(new ConverseStreamCommand(runtimeInput), signal === undefined ? undefined : { abortSignal: signal });
                 if (output.stream === undefined)
                     throw new Error("Bedrock returned no response stream");
                 return streamResponse(output.stream, modelId, signal);
             }
-            const output = await this.#runtime.send(new ConverseCommand(input), signal === undefined ? undefined : { abortSignal: signal });
+            const output = await this.#runtime.send(new ConverseCommand(runtimeInput), signal === undefined ? undefined : { abortSignal: signal });
             return Response.json(fromBedrockConverseOutput(output, modelId));
         }
         catch (error) {
@@ -454,7 +499,10 @@ export class BedrockProviderSource {
     embeddings() {
         return Promise.resolve(Response.json({ error: { type: "not_implemented", message: "Bedrock embeddings are not supported" } }, { status: 501 }));
     }
-    reasoningCapabilities() {
+    reasoningCapabilities(model) {
+        const known = bedrockReasoningCapabilities(model);
+        if (known !== undefined)
+            return known;
         return {
             status: "unknown",
             wireShape: "bedrock-converse",

package/dist/codex-model-selection.js

@@ -120,27 +120,37 @@ export class OpenRouterModelMetadataClient {
         }
     }
     async #refresh() {
-        const timeout = AbortSignal.timeout(this.#timeoutMs);
-        const settled = await Promise.allSettled(TASK_CATALOGS.map(async (catalog) => {
-            const response = await this.#fetch(`${this.#baseUrl}${catalog.path}`, {
-                headers: { accept: "application/json" },
-                signal: timeout
-            });
-            if (!response.ok) {
-                throw new Error(`OpenRouter ${catalog.path} returned HTTP ${response.status}`);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort(new DOMException("OpenRouter model metadata timed out", "TimeoutError"));
+        }, this.#timeoutMs);
+        const settled = await (async () => {
+            try {
+                return await Promise.allSettled(TASK_CATALOGS.map(async (catalog) => {
+                    const response = await this.#fetch(`${this.#baseUrl}${catalog.path}`, {
+                        headers: { accept: "application/json" },
+                        signal: controller.signal
+                    });
+                    if (!response.ok) {
+                        throw new Error(`OpenRouter ${catalog.path} returned HTTP ${response.status}`);
+                    }
+                    const payload = record(await response.json());
+                    if (!Array.isArray(payload?.data)) {
+                        throw new Error(`OpenRouter ${catalog.path} returned an invalid model catalog`);
+                    }
+                    return {
+                        kind: catalog.kind,
+                        entries: payload.data.flatMap((entry) => {
+                            const parsed = metadataFromEntry(entry, catalog);
+                            return parsed === undefined ? [] : [parsed];
+                        })
+                    };
+                }));
             }
-            const payload = record(await response.json());
-            if (!Array.isArray(payload?.data)) {
-                throw new Error(`OpenRouter ${catalog.path} returned an invalid model catalog`);
+            finally {
+                clearTimeout(timeout);
             }
-            return {
-                kind: catalog.kind,
-                entries: payload.data.flatMap((entry) => {
-                    const parsed = metadataFromEntry(entry, catalog);
-                    return parsed === undefined ? [] : [parsed];
-                })
-            };
-        }));
+        })();
         const responses = settled.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
         if (responses.length === 0) {
             const firstFailure = settled.find((result) => result.status === "rejected");

package/dist/switching-proxy.d.ts

@@ -5,6 +5,7 @@ export type SwitchingGatewayProxy = {
     target(): string;
     swapTarget(target: string): string;
     waitForTargetIdle(target: string, graceMs: number): Promise<boolean>;
+    retire(graceMs?: number): Promise<void>;
     drain(graceMs?: number): Promise<void>;
     close(): Promise<void>;
 };

package/dist/switching-proxy.js

@@ -68,13 +68,17 @@ function writeJson(res, status, value) {
     res.setHeader("content-length", String(payload.length));
     res.end(payload);
 }
-async function pipe(res, upstream) {
+async function pipe(res, upstream, closeConnection) {
     res.statusCode = upstream.status;
     for (const [name, value] of upstream.headers) {
         if (!HOP_BY_HOP.has(name.toLowerCase()) && name.toLowerCase() !== "content-length") {
             res.setHeader(name, value);
         }
     }
+    if (closeConnection()) {
+        res.shouldKeepAlive = false;
+        res.setHeader("connection", "close");
+    }
     if (upstream.body === null) {
         res.end();
         return;
@@ -108,8 +112,13 @@ export async function startSwitchingGatewayProxy(input) {
     };
     const generations = new Map([[active.url, active]]);
     let draining = false;
+    let retiring = false;
     let inflight = 0;
     const server = createServer((req, res) => {
+        if (retiring) {
+            res.shouldKeepAlive = false;
+            res.setHeader("connection", "close");
+        }
         inflight += 1;
         res.once("close", () => {
             inflight -= 1;
@@ -170,7 +179,7 @@ export async function startSwitchingGatewayProxy(input) {
                         AbortSignal.timeout(10 * 60 * 1000)
                     ])
                 });
-                await pipe(res, upstream);
+                await pipe(res, upstream, () => retiring);
             }
             catch {
                 if (!res.destroyed && !res.headersSent) {
@@ -205,14 +214,33 @@ export async function startSwitchingGatewayProxy(input) {
     const address = server.address();
     const port = typeof address === "object" && address !== null ? address.port : input.port ?? 0;
     let drainRun;
+    let retireRun;
+    const waitForInflight = async (graceMs) => {
+        const deadline = Date.now() + graceMs;
+        while (inflight > 0 && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    };
+    const closeRetiringListener = async (graceMs) => {
+        server.closeIdleConnections();
+        const closed = new Promise((resolve) => server.close(() => resolve()));
+        await waitForInflight(graceMs);
+        if (inflight > 0)
+            server.closeAllConnections();
+        await closed;
+    };
+    const retire = (graceMs = 0) => {
+        retireRun ??= (async () => {
+            retiring = true;
+            await closeRetiringListener(graceMs);
+        })();
+        return retireRun;
+    };
     const drain = (graceMs = 0) => {
         drainRun ??= (async () => {
             draining = true;
             server.closeIdleConnections();
-            const deadline = Date.now() + graceMs;
-            while (inflight > 0 && Date.now() < deadline) {
-                await new Promise((resolve) => setTimeout(resolve, 50));
-            }
+            await waitForInflight(graceMs);
             const closed = new Promise((resolve) => server.close(() => resolve()));
             server.closeAllConnections();
             await closed;
@@ -252,6 +280,7 @@ export async function startSwitchingGatewayProxy(input) {
                 generations.delete(generation.url);
             return result;
         },
+        retire,
         drain,
         close: async () => await drain(0)
     };

package/dist/test/bedrock-source.test.js

@@ -20,6 +20,14 @@ test("Bedrock discovery includes active Anthropic foundations and paginated back
                                 outputModalities: ["TEXT"],
                                 responseStreamingSupported: true
                             },
+                            {
+                                modelId: "anthropic.claude-opus-5",
+                                providerName: "Anthropic",
+                                modelLifecycle: { status: "ACTIVE" },
+                                inputModalities: ["TEXT"],
+                                outputModalities: ["TEXT"],
+                                responseStreamingSupported: true
+                            },
                             { modelId: "anthropic.old", providerName: "Anthropic", modelLifecycle: { status: "LEGACY" } },
                             { modelId: "amazon.titan", providerName: "Amazon", modelLifecycle: { status: "ACTIVE" } }
                         ]
@@ -28,6 +36,7 @@ test("Bedrock discovery includes active Anthropic foundations and paginated back
                 return token === undefined ? {
                     inferenceProfileSummaries: [
                         { inferenceProfileId: "us.anthropic.claude-3", inferenceProfileName: "Claude", inferenceProfileArn: "arn:profile", status: "ACTIVE", type: "SYSTEM_DEFINED", createdAt: new Date("2026-07-09T00:00:00Z"), models: [{ modelArn: "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3" }] },
+                        { inferenceProfileId: "us.anthropic.claude-opus-5", inferenceProfileName: "Opus 5", inferenceProfileArn: "arn:profile-opus-5", status: "ACTIVE", type: "SYSTEM_DEFINED", models: [{ modelArn: "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-opus-5" }] },
                         { inferenceProfileId: "us.amazon.titan", inferenceProfileName: "Titan", inferenceProfileArn: "arn:profile2", status: "ACTIVE", type: "SYSTEM_DEFINED", models: [{ modelArn: "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan" }] }
                     ],
                     nextToken: "page-2"
@@ -42,16 +51,29 @@ test("Bedrock discovery includes active Anthropic foundations and paginated back
     });
     const discovered = await source.discoverModels();
     assert.deepEqual(discovered.map((model) => model.id), [
-        "anthropic.claude-3", "us.anthropic.claude-3", "eu.anthropic.claude-3"
+        "anthropic.claude-3",
+        "anthropic.claude-opus-5",
+        "us.anthropic.claude-3",
+        "us.anthropic.claude-opus-5",
+        "eu.anthropic.claude-3"
     ]);
     assert.deepEqual(discovered[0]?.metadata?.architecture, {
         modality: "text+image->text",
         inputModalities: ["text", "image"],
         outputModalities: ["text"]
     });
-    assert.deepEqual(discovered[1]?.metadata, discovered[0]?.metadata);
+    assert.deepEqual(discovered[2]?.metadata, discovered[0]?.metadata);
     assert.ok(discovered.every((model) => model.createdAt === undefined && model.providerPriority === undefined), "profile creation time is not model recency");
     assert.equal(discovered[0]?.capabilities?.streaming, "supported");
+    assert.equal(discovered[0]?.reasoning, undefined);
+    assert.deepEqual(discovered[1]?.reasoning, {
+        status: "supported",
+        efforts: [{ id: "low" }, { id: "medium" }, { id: "high" }, { id: "max" }],
+        adaptive: true,
+        wireShape: "bedrock-converse",
+        provenance: "builtin"
+    });
+    assert.deepEqual(discovered[3]?.reasoning, discovered[1]?.reasoning);
     assert.equal(commands.length, 3);
 });
 test("Bedrock request translation covers system, image, tools, results, and inference config", () => {
@@ -80,6 +102,79 @@ test("Bedrock request translation covers system, image, tools, results, and infe
     assert.deepEqual(input.inferenceConfig, { maxTokens: 256, temperature: 0.2, topP: 0.9, stopSequences: ["END"] });
     assert.deepEqual(input.additionalModelRequestFields, { top_k: 40 });
 });
+test("Bedrock Opus 5 translates effort and adaptive reasoning controls", () => {
+    assert.deepEqual(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: [],
+        reasoning_effort: "high"
+    }).additionalModelRequestFields, { thinking: { type: "adaptive" }, output_config: { effort: "high" } });
+    assert.deepEqual(toBedrockConverseInput({
+        model: "us.anthropic.claude-opus-5",
+        messages: [],
+        x_routekit: { version: 1, selection: { mode: "adaptive" } }
+    }).additionalModelRequestFields, { thinking: { type: "adaptive" } });
+    assert.deepEqual(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: [],
+        x_routekit: { version: 1, selection: { mode: "budget", budgetTokens: 2048 } }
+    }).additionalModelRequestFields, { thinking: { type: "enabled", budget_tokens: 2048 } });
+    assert.deepEqual(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: [],
+        x_routekit: { version: 1, selection: { mode: "disabled" } }
+    }).additionalModelRequestFields, { thinking: { type: "disabled" } });
+    assert.equal(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: []
+    }).additionalModelRequestFields, undefined);
+});
+test("Bedrock maps profile-required Opus 5 foundations to a discovered inference profile", async () => {
+    let command;
+    const source = new BedrockProviderSource({
+        controlClient: {
+            send: async (value) => {
+                if (value instanceof ListFoundationModelsCommand) {
+                    return {
+                        modelSummaries: [{
+                                modelId: "anthropic.claude-opus-5",
+                                providerName: "Anthropic",
+                                modelLifecycle: { status: "ACTIVE" }
+                            }]
+                    };
+                }
+                return {
+                    inferenceProfileSummaries: [{
+                            inferenceProfileId: "us.anthropic.claude-opus-5",
+                            status: "ACTIVE",
+                            models: [{
+                                    modelArn: "arn:aws:bedrock:us-west-2::foundation-model/anthropic.claude-opus-5"
+                                }]
+                        }]
+                };
+            }
+        },
+        runtimeClient: {
+            send: async (value) => {
+                command = value;
+                return {
+                    $metadata: { requestId: "req-opus-5" },
+                    output: { message: { role: "assistant", content: [{ text: "OK" }] } },
+                    stopReason: "end_turn"
+                };
+            }
+        }
+    });
+    await source.discoverModels();
+    const response = await source.chat({
+        model: "anthropic.claude-opus-5",
+        messages: [{ role: "user", content: "Reply with exactly OK." }],
+        reasoning_effort: "low"
+    });
+    assert.equal(response.status, 200);
+    assert.equal(command instanceof ConverseCommand, true);
+    assert.equal(command?.input.modelId, "us.anthropic.claude-opus-5");
+    assert.equal((await response.json()).model, "anthropic.claude-opus-5");
+});
 test("Bedrock Converse maps text, reasoning, tools, stop, and usage", async () => {
     let command;
     const source = new BedrockProviderSource({
@@ -302,6 +397,7 @@ test("Bedrock defaults reasoning to unknown and ordinary requests omit thinking"
         controlClient: { send: async () => ({}) },
         runtimeClient: { send: async () => ({}) }
     });
+    assert.equal(source.reasoningCapabilities("anthropic.claude-opus-5")?.status, "supported");
     assert.deepEqual(source.reasoningCapabilities(), {
         status: "unknown", wireShape: "bedrock-converse", provenance: "provider"
     });

package/dist/test/codex-model-selection.test.js

@@ -215,7 +215,7 @@ test("OpenRouter metadata propagates caller cancellation and enforces its timeou
     const fetch = async (_input, init) => await new Promise((_resolve, reject) => {
         init?.signal?.addEventListener("abort", () => reject(init.signal?.reason ?? new Error("aborted")), { once: true });
     });
-    const canceled = new OpenRouterModelMetadataClient({ fetch, timeoutMs: 1_000 });
+    const canceled = new OpenRouterModelMetadataClient({ fetch, timeoutMs: 25 });
     const controller = new AbortController();
     const pending = canceled.models(controller.signal);
     controller.abort(new Error("caller canceled"));

package/dist/test/router.test.js

@@ -714,3 +714,57 @@ test("Bedrock models use canonical ids and API-key billing attribution", async (
         }
     ]);
 });
+test("Bedrock Opus 5 exposes reasoning controls and accepts routed effort selections", async () => {
+    const bodies = [];
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { bedrock: {} },
+            defaultModel: "bedrock/anthropic.claude-opus-5"
+        },
+        sources: {
+            bedrock: {
+                ...fakeSource("bedrock", [{
+                        id: "anthropic.claude-opus-5",
+                        reasoning: {
+                            status: "supported",
+                            efforts: [{ id: "low" }, { id: "medium" }, { id: "high" }, { id: "max" }],
+                            adaptive: true,
+                            wireShape: "bedrock-converse",
+                            provenance: "builtin"
+                        }
+                    }]),
+                async chat(body) {
+                    bodies.push(body);
+                    return Response.json({ ok: true });
+                }
+            }
+        }
+    });
+    const models = (await (await backend.models()).json());
+    assert.deepEqual(models.data[0]?.reasoning, {
+        status: "supported",
+        efforts: [{ id: "low" }, { id: "medium" }, { id: "high" }, { id: "max" }],
+        adaptive: true,
+        wireShape: "bedrock-converse",
+        provenance: "builtin"
+    });
+    const accepted = await backend.chat({
+        model: "bedrock/anthropic.claude-opus-5",
+        messages: [],
+        reasoning_effort: "high"
+    });
+    assert.equal(accepted.status, 200);
+    assert.equal(bodies[0]?.model, "anthropic.claude-opus-5");
+    assert.deepEqual(bodies[0]?.x_routekit, {
+        version: 1,
+        selection: { mode: "effort", effort: "high" }
+    });
+    const rejected = await backend.chat({
+        model: "bedrock/anthropic.claude-opus-5",
+        messages: [],
+        reasoning_effort: "minimal"
+    });
+    assert.equal(rejected.status, 400);
+    const error = (await rejected.json());
+    assert.equal(error.error.code, "unsupported_reasoning_control");
+});

package/dist/test/switching-proxy-retire.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/switching-proxy-retire.test.js

@@ -0,0 +1,88 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import test from "node:test";
+import { startSwitchingGatewayProxy } from "../switching-proxy.js";
+async function heldTarget() {
+    let markStarted;
+    const started = new Promise((resolve) => {
+        markStarted = resolve;
+    });
+    let release;
+    const released = new Promise((resolve) => {
+        release = resolve;
+    });
+    const server = createServer((request, response) => {
+        if (request.url === "/stream") {
+            response.setHeader("content-type", "text/plain");
+            response.write("first\n");
+            markStarted();
+            void released.then(() => response.end("last\n"));
+            return;
+        }
+        response.end("ok");
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const port = server.address().port;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        started,
+        release,
+        close: async () => await new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))))
+    };
+}
+test("switching proxy retirement preserves an admitted streaming response", async () => {
+    const target = await heldTarget();
+    const proxy = await startSwitchingGatewayProxy({ target: target.url });
+    try {
+        const response = await fetch(`${proxy.url()}/stream`);
+        const reader = response.body?.getReader();
+        assert.ok(reader !== undefined);
+        const first = await reader.read();
+        assert.match(Buffer.from(first.value ?? []).toString("utf8"), /first/);
+        await target.started;
+        const retiring = proxy.retire(2_000);
+        target.release();
+        let remainder = "";
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            remainder += Buffer.from(value ?? []).toString("utf8");
+        }
+        assert.match(remainder, /last/);
+        await retiring;
+    }
+    finally {
+        await proxy.close();
+        await target.close();
+    }
+});
+test("switching proxy retirement deadline terminates a stream that never finishes", async () => {
+    const target = await heldTarget();
+    const proxy = await startSwitchingGatewayProxy({ target: target.url });
+    try {
+        const response = await fetch(`${proxy.url()}/stream`);
+        const reader = response.body?.getReader();
+        assert.ok(reader !== undefined);
+        await reader.read();
+        await target.started;
+        const startedAt = Date.now();
+        await proxy.retire(250);
+        assert.ok(Date.now() - startedAt >= 200);
+        await assert.rejects(async () => {
+            for (;;) {
+                const { done } = await reader.read();
+                if (done)
+                    break;
+            }
+        });
+    }
+    finally {
+        target.release();
+        await proxy.close();
+        await target.close();
+    }
+});

package/package.json

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