@velum-labs/routekit-gateway 0.9.0

package/dist/test/auth.test.d.ts

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

package/dist/test/auth.test.js

@@ -0,0 +1,25 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { authorizedRequest, timingSafeStringEqual, verifyBearerToken } from "../auth.js";
+function requestWithHeaders(headers) {
+    return { headers };
+}
+test("timingSafeStringEqual matches only exact strings", () => {
+    assert.equal(timingSafeStringEqual("secret", "secret"), true);
+    assert.equal(timingSafeStringEqual("secret", "secre_"), false);
+    assert.equal(timingSafeStringEqual("secret", "secret-longer"), false);
+    assert.equal(timingSafeStringEqual("", ""), true);
+});
+test("verifyBearerToken requires the Bearer prefix and exact token", () => {
+    assert.equal(verifyBearerToken("Bearer tok", "tok"), true);
+    assert.equal(verifyBearerToken("bearer tok", "tok"), false);
+    assert.equal(verifyBearerToken("tok", "tok"), false);
+    assert.equal(verifyBearerToken(undefined, "tok"), false);
+});
+test("authorizedRequest accepts bearer header or x-api-key, rejects otherwise", () => {
+    assert.equal(authorizedRequest(requestWithHeaders({ authorization: "Bearer tok" }), "tok"), true);
+    assert.equal(authorizedRequest(requestWithHeaders({ "x-api-key": "tok" }), "tok"), true);
+    assert.equal(authorizedRequest(requestWithHeaders({ authorization: "Bearer nope" }), "tok"), false);
+    assert.equal(authorizedRequest(requestWithHeaders({ "x-api-key": "nope" }), "tok"), false);
+    assert.equal(authorizedRequest(requestWithHeaders({}), "tok"), false);
+});

package/dist/test/boundary.test.d.ts

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

package/dist/test/boundary.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "../../..");
+function productionSources(root) {
+    const files = [];
+    const visit = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            if (entry.name === "test" || entry.name === "__tests__")
+                continue;
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(path);
+            else if (entry.isFile() && entry.name.endsWith(".ts"))
+                files.push(path);
+        }
+    };
+    visit(join(root, "src"));
+    return files;
+}
+test("RouteKit gateway and accounts have no FusionKit dependency edge", () => {
+    for (const directory of ["model-gateway", "accounts"]) {
+        const root = join(packageRoot, directory);
+        const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+        assert.equal(Object.keys(manifest.dependencies ?? {}).some((name) => name.startsWith("@fusionkit/")), false, `${directory} manifest`);
+        for (const path of productionSources(root)) {
+            assert.doesNotMatch(readFileSync(path, "utf8"), /@fusionkit\//, path);
+        }
+    }
+});

package/dist/test/chat.test.d.ts

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

package/dist/test/chat.test.js

@@ -0,0 +1,418 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { test } from "node:test";
+import { OpenAiBackend } from "../backend.js";
+import { MODEL_CALL_ID_HEADER } from "../provenance.js";
+import { collectAttribution, initialAttribution, startGateway } from "../server.js";
+function sendJson(res, status, value) {
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json");
+    res.end(Buffer.from(JSON.stringify(value), "utf8"));
+}
+async function readAll(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
+async function captureStderr(run) {
+    const original = process.stderr.write.bind(process.stderr);
+    let stderr = "";
+    process.stderr.write = ((chunk) => {
+        stderr += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+        return true;
+    });
+    try {
+        return { result: await run(), stderr };
+    }
+    finally {
+        process.stderr.write = original;
+    }
+}
+async function startMock() {
+    let lastChatBody;
+    let lastModelCallId;
+    const server = createServer((req, res) => {
+        void (async () => {
+            const path = new URL(req.url ?? "/", "http://localhost").pathname;
+            if (req.method === "GET" && path === "/v1/models") {
+                sendJson(res, 200, { object: "list", data: [{ id: "mock-model", object: "model" }] });
+                return;
+            }
+            if (req.method === "POST" && path === "/v1/chat/completions") {
+                const body = JSON.parse((await readAll(req)).toString("utf8"));
+                lastChatBody = body;
+                lastModelCallId =
+                    typeof req.headers[MODEL_CALL_ID_HEADER] === "string"
+                        ? req.headers[MODEL_CALL_ID_HEADER]
+                        : undefined;
+                if (body.model === "fail-model") {
+                    sendJson(res, 500, { error: { message: "upstream failed" } });
+                    return;
+                }
+                if (body.stream === true) {
+                    res.statusCode = 200;
+                    res.setHeader("content-type", "text/event-stream");
+                    res.write('data: {"choices":[{"delta":{"content":"hi"}}]}\n\n');
+                    res.write('data: {"usage":{"prompt_tokens":1,"completion_tokens":1}}\n\n');
+                    res.write("data: [DONE]\n\n");
+                    res.end();
+                    return;
+                }
+                sendJson(res, 200, {
+                    id: "chatcmpl-mock",
+                    object: "chat.completion",
+                    model: body.model,
+                    choices: [
+                        { index: 0, message: { role: "assistant", content: "ok" }, finish_reason: "stop" }
+                    ],
+                    usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 }
+                });
+                return;
+            }
+            sendJson(res, 404, { error: "not found" });
+        })();
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    const address = server.address();
+    const port = typeof address === "object" && address !== null ? address.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        lastChatBody: () => lastChatBody,
+        lastModelCallId: () => lastModelCallId,
+        close: () => new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())))
+    };
+}
+test("injects the default model and pipes the completion back", async () => {
+    const mock = await startMock();
+    const backend = new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "mlx-default" });
+    const records = [];
+    const gateway = await startGateway({
+        backend,
+        provenance: { onModelCall: (record) => records.push(record) }
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ messages: [{ role: "user", content: "hi" }] })
+        });
+        assert.equal(response.status, 200);
+        const callId = response.headers.get(MODEL_CALL_ID_HEADER);
+        assert.ok(callId?.startsWith("model_call_"));
+        assert.equal(mock.lastModelCallId(), callId);
+        const json = (await response.json());
+        assert.equal(json.object, "chat.completion");
+        assert.equal(mock.lastChatBody()?.model, "mlx-default");
+        assert.equal(records.length, 1);
+        assert.equal(records[0]?.call_id, callId);
+        assert.equal(records[0]?.metadata?.dialect, "openai-chat");
+        assert.equal(records[0]?.model, "mlx-default");
+        assert.equal(records[0]?.metadata?.stream, false);
+        assert.equal(records[0]?.usage?.total_tokens, 5);
+        assert.equal(records[0]?.metadata?.unknown_usage, false);
+        assert.equal(records[0]?.metadata?.unknown_cost, true);
+        assert.ok(!JSON.stringify(records[0]).includes('"hi"'));
+        assert.ok(!JSON.stringify(records[0]).includes('"ok"'));
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("compound provider operations are not counted as retries", () => {
+    const attribution = collectAttribution({
+        effective_model: "codex/gpt-test",
+        native_model: "gpt-test",
+        provider: "codex",
+        billing_mode: "subscription"
+    });
+    attribution.report({
+        accountAttempt: { operationId: "step-1", seat: "seat_a" }
+    });
+    attribution.report({
+        accountAttempt: { operationId: "step-2", seat: "seat_b" }
+    });
+    assert.deepEqual(attribution.snapshot(), {
+        effective_model: "codex/gpt-test",
+        native_model: "gpt-test",
+        provider: "codex",
+        billing_mode: "subscription",
+        account: { seat: "seat_b" },
+        attempts: 2,
+        retries: 0,
+        account_failovers: 0
+    });
+    attribution.report({
+        accountAttempt: { operationId: "step-2", seat: "seat_b" }
+    });
+    attribution.report({
+        accountAttempt: { operationId: "step-2", seat: "seat_c" }
+    });
+    assert.deepEqual(attribution.snapshot()?.retries, 2);
+    assert.deepEqual(attribution.snapshot()?.account_failovers, 1);
+});
+test("rejected bare native aliases retain subscription attribution", () => {
+    const backend = {
+        defaultModel: undefined,
+        resolveModelRoute: () => undefined,
+        chat: async () => new Response("{}"),
+        models: async () => new Response("{}"),
+        embeddings: async () => new Response("{}")
+    };
+    assert.deepEqual(initialAttribution(backend, "missing-codex-model", "codex"), {
+        effective_model: "missing-codex-model",
+        native_model: "missing-codex-model",
+        provider: "codex",
+        billing_mode: "subscription"
+    });
+    assert.deepEqual(initialAttribution(backend, "missing-claude-model", "claude-code"), {
+        effective_model: "missing-claude-model",
+        native_model: "missing-claude-model",
+        provider: "claude-code",
+        billing_mode: "subscription"
+    });
+    assert.deepEqual(initialAttribution(backend, undefined), {});
+});
+test("embeddings receive a call id and sanitized attribution record", async () => {
+    const records = [];
+    const gateway = await startGateway({
+        backend: {
+            defaultModel: "openai/text-embedding-test",
+            resolveModelRoute: () => ({
+                publicId: "openai/text-embedding-test",
+                nativeId: "text-embedding-test",
+                provider: "openai"
+            }),
+            chat: async () => new Response("{}"),
+            models: async () => new Response("{}"),
+            embeddings: async (_body, _signal, options) => {
+                options?.onAttribution?.({
+                    effective_model: "openai/text-embedding-test",
+                    native_model: "text-embedding-test",
+                    provider: "openai",
+                    billing_mode: "api_key"
+                });
+                return Response.json({
+                    data: [{ embedding: [0.1] }],
+                    usage: { prompt_tokens: 3, total_tokens: 3 }
+                });
+            }
+        },
+        provenance: { onModelCall: (record) => records.push(record) }
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/embeddings`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "openai/text-embedding-test",
+                input: "hello"
+            })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(response.headers.get(MODEL_CALL_ID_HEADER), records[0]?.call_id);
+        assert.equal(records[0]?.metadata?.dialect, "openai-embeddings");
+        assert.equal(records[0]?.usage?.total_tokens, 3);
+        assert.deepEqual(records[0]?.metadata?.attribution, {
+            effective_model: "openai/text-embedding-test",
+            native_model: "text-embedding-test",
+            provider: "openai",
+            billing_mode: "api_key",
+            attempts: 1,
+            retries: 0,
+            account_failovers: 0
+        });
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("records failed upstream responses as failed model-call records", async () => {
+    const mock = await startMock();
+    const records = [];
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1` }),
+        provenance: { onModelCall: (record) => records.push(record) }
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: "fail-model", messages: [{ role: "user", content: "fail" }] })
+        });
+        assert.equal(response.status, 500);
+        assert.equal(records.length, 1);
+        assert.equal(records[0]?.status, "failed");
+        assert.equal(records[0]?.error?.kind, "provider_error");
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("redacts thrown backend failures from stderr and the wire response", async () => {
+    const secret = "sk-live-secret-from-upstream";
+    const records = [];
+    const gateway = await startGateway({
+        backend: {
+            defaultModel: "throw-model",
+            chat: async () => {
+                throw new Error(`backend exploded with ${secret}`);
+            },
+            models: async () => new Response("{}", { status: 200 }),
+            embeddings: async () => new Response("{}", { status: 200 })
+        },
+        provenance: { onModelCall: (record) => records.push(record) }
+    });
+    try {
+        const { result: response, stderr } = await captureStderr(async () => {
+            return await fetch(`${gateway.url()}/v1/chat/completions`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ messages: [{ role: "user", content: "fail" }] })
+            });
+        });
+        assert.equal(response.status, 502);
+        assert.deepEqual(await response.json(), {
+            error: { message: "upstream request failed", type: "upstream_error" }
+        });
+        assert.match(stderr, /routekit gateway upstream error: type=Error/);
+        assert.equal(stderr.includes(secret), false);
+        assert.equal(stderr.includes("backend exploded"), false);
+        assert.equal(response.headers.get(MODEL_CALL_ID_HEADER), records[0]?.call_id);
+        assert.equal(records.length, 1);
+        assert.equal(records[0]?.status, "failed");
+        assert.equal(records[0]?.error?.kind, "provider_error");
+        assert.equal(records[0]?.metadata?.unknown_usage, true);
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("preserves an explicitly requested model", async () => {
+    const mock = await startMock();
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "mlx-default" })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: "explicit-model", messages: [{ role: "user", content: "hi" }] })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(mock.lastChatBody()?.model, "explicit-model");
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("forceModel overrides the requested model on every upstream call", async () => {
+    const mock = await startMock();
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "advertised", forceModel: "routed-endpoint" })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: "whatever-the-cli-picked", messages: [{ role: "user", content: "hi" }] })
+        });
+        assert.equal(response.status, 200);
+        // The driving client's model is ignored; the dedicated capture gateway routes
+        // every call to its candidate's routed model id.
+        assert.equal(mock.lastChatBody()?.model, "routed-endpoint");
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("lists models from the backend", async () => {
+    const mock = await startMock();
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1` })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/models`);
+        assert.equal(response.status, 200);
+        const json = (await response.json());
+        assert.equal(json.data.length, 1);
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("streams server-sent events straight through", async () => {
+    const mock = await startMock();
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "mlx-default" })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ stream: true, messages: [{ role: "user", content: "hi" }] })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(response.headers.get("content-type"), "text/event-stream");
+        const text = await response.text();
+        assert.ok(text.includes("data: [DONE]"));
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("returns 404 for an unknown route", async () => {
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: "http://127.0.0.1:1/v1" })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/unknown`, { method: "POST", body: "{}" });
+        assert.equal(response.status, 404);
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("rejects malformed JSON with 400", async () => {
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: "http://127.0.0.1:1/v1" })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: "{not json"
+        });
+        assert.equal(response.status, 400);
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("enforces the auth token when configured", async () => {
+    const mock = await startMock();
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "mlx-default" }),
+        authToken: "secret"
+    });
+    try {
+        const unauthorized = await fetch(`${gateway.url()}/v1/models`);
+        assert.equal(unauthorized.status, 401);
+        const authorized = await fetch(`${gateway.url()}/v1/models`, {
+            headers: { authorization: "Bearer secret" }
+        });
+        assert.equal(authorized.status, 200);
+        const health = await fetch(`${gateway.url()}/health`);
+        assert.equal(health.status, 200);
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});

package/dist/test/cost.test.d.ts

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

package/dist/test/cost.test.js

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { estimateCost, lookupPricing, meterCall, parseUsage, parseUsageFromSse } from "../cost.js";
+test("single-call metering normalizes provider usage and registry pricing", () => {
+    assert.deepEqual(parseUsage({ input_tokens: 80, output_tokens: 20 }), {
+        promptTokens: 80,
+        completionTokens: 20,
+        totalTokens: 100
+    });
+    assert.deepEqual(lookupPricing("gpt-5.5"), {
+        inputPer1mTokens: 1.25,
+        outputPer1mTokens: 10
+    });
+    assert.deepEqual(estimateCost({ promptTokens: 1_000_000, completionTokens: 1_000_000 }, lookupPricing("gpt-5.5")), { costUsd: 11.25, partialUsage: false });
+});
+test("SSE usage extraction retains the last provider usage block", () => {
+    const text = `data: ${JSON.stringify({ choices: [{ delta: { content: "first" } }] })}\n\n` +
+        `data: ${JSON.stringify({
+            choices: [],
+            usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 }
+        })}\n\n` +
+        "data: [DONE]\n\n";
+    assert.deepEqual(parseUsageFromSse(text), {
+        promptTokens: 10,
+        completionTokens: 5,
+        totalTokens: 15
+    });
+});
+test("SSE usage extraction reads nested Responses completion usage", () => {
+    const text = `data: ${JSON.stringify({
+        type: "response.completed",
+        response: {
+            usage: {
+                input_tokens: 30,
+                output_tokens: 12,
+                total_tokens: 42
+            }
+        }
+    })}\n\n` +
+        "data: [DONE]\n\n";
+    assert.deepEqual(parseUsageFromSse(text), {
+        promptTokens: 30,
+        completionTokens: 12,
+        totalTokens: 42
+    });
+});
+test("provider-reported cost is canonical over a registry estimate", () => {
+    const call = meterCall({
+        model: "gpt-5.5",
+        usage: { promptTokens: 1000, completionTokens: 1000 },
+        providerCost: {
+            source: "provider",
+            costUsd: 0.0123,
+            providerName: "provider"
+        }
+    });
+    assert.equal(call.costUsd, 0.0123);
+    assert.equal(call.providerCostUsd, 0.0123);
+    assert.equal(call.unknownCost, false);
+});

package/dist/test/cursor.test.d.ts

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

package/dist/test/cursor.test.js

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { isCursorChatBody, translateCursorRequest } from "../adapters/cursor.js";
+import { startGateway } from "../server.js";
+const cursorBody = {
+    model: "route-primary",
+    input: [
+        { type: "message", role: "developer", content: "You are a coding agent." },
+        { type: "message", role: "user", content: [{ type: "input_text", text: "fix the bug" }] },
+        {
+            type: "function_call",
+            call_id: "call_1",
+            name: "read_file",
+            arguments: "{\"path\":\"a.ts\"}"
+        },
+        { type: "function_call_output", call_id: "call_1", output: "source" }
+    ],
+    stream: true,
+    tools: [
+        {
+            type: "function",
+            name: "read_file",
+            parameters: { type: "object" }
+        }
+    ]
+};
+test("Cursor hybrid requests translate to chat messages and tools", () => {
+    assert.equal(isCursorChatBody(cursorBody), true);
+    const translated = translateCursorRequest(cursorBody);
+    assert.equal(translated.model, "route-primary");
+    assert.equal(translated.stream, true);
+    assert.deepEqual(translated.messages, [
+        { role: "system", content: "You are a coding agent." },
+        { role: "user", content: "fix the bug" },
+        {
+            role: "assistant",
+            content: "",
+            tool_calls: [
+                {
+                    id: "call_1",
+                    type: "function",
+                    function: { name: "read_file", arguments: "{\"path\":\"a.ts\"}" }
+                }
+            ]
+        },
+        { role: "tool", tool_call_id: "call_1", content: "source" }
+    ]);
+    assert.equal(translated.tools[0]?.function.name, "read_file");
+});
+test("Cursor hybrid detection rejects unrelated bodies", () => {
+    assert.equal(isCursorChatBody({ input: "hello" }), true);
+    assert.equal(isCursorChatBody({ messages: [] }), true);
+    assert.equal(isCursorChatBody({ model: "route-primary" }), false);
+    assert.equal(isCursorChatBody(null), false);
+});
+test("RouteKit serves the Cursor hybrid through its neutral HTTP boundary", async () => {
+    let received;
+    const backend = {
+        defaultModel: "route-primary",
+        chat(body) {
+            received = body;
+            return Promise.resolve(Response.json({
+                id: "chatcmpl_1",
+                object: "chat.completion",
+                model: "route-primary",
+                choices: [
+                    {
+                        index: 0,
+                        message: { role: "assistant", content: "done" },
+                        finish_reason: "stop"
+                    }
+                ]
+            }));
+        },
+        models: () => Promise.resolve(Response.json({
+            object: "list",
+            data: [{ id: "route-primary", object: "model" }]
+        })),
+        embeddings: () => Promise.resolve(new Response(null, { status: 501 }))
+    };
+    const gateway = await startGateway({ backend });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/cursor/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ ...cursorBody, stream: false })
+        });
+        assert.equal(response.status, 200);
+        assert.deepEqual(received, {
+            ...translateCursorRequest({ ...cursorBody, stream: false }),
+            model: "route-primary"
+        });
+        const models = await fetch(`${gateway.url()}/v1/cursor/models`);
+        assert.equal(models.status, 200);
+        assert.deepEqual((await models.json()).data.map((model) => model.id), ["route-primary"]);
+    }
+    finally {
+        await gateway.close();
+    }
+});

package/dist/test/drain.test.d.ts

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