@fusionkit/model-gateway 0.1.0

package/dist/test/fusion-backend-trace.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { FusionBackend } from "../fusion-backend.js";
+// node:test isolates each file in its own process, so enabling the trace emitter
+// here (before its lazy singleton is created) does not affect other suites.
+const traceDir = mkdtempSync(join(tmpdir(), "fusion-judge-trace-"));
+process.env.FUSION_TRACE_DIR = traceDir;
+delete process.env.FUSION_TRACE_URL;
+function candidate(id) {
+    return { trajectory_id: id, model_id: id, status: "succeeded", final_output: "ok", steps: [] };
+}
+function readEvents() {
+    const events = [];
+    for (const file of readdirSync(traceDir)) {
+        if (!file.endsWith(".jsonl"))
+            continue;
+        for (const line of readFileSync(join(traceDir, file), "utf8").split("\n")) {
+            if (line.trim().length === 0)
+                continue;
+            events.push(JSON.parse(line));
+        }
+    }
+    return events;
+}
+async function startStepServer(handler) {
+    const server = createServer(handler);
+    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}/v1/fusion/trajectory:step`,
+        close: () => new Promise((resolve) => server.close(() => resolve()))
+    };
+}
+test("FusionBackend emits the full judge prompt and final output", async () => {
+    const step = await startStepServer((_req, res) => {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({
+            choices: [{ message: { role: "assistant", content: "FUSED ANSWER" } }],
+            usage: { total_tokens: 12 }
+        }));
+    });
+    try {
+        const backend = new FusionBackend({
+            stepUrl: step.url,
+            judgeModel: "judge-x",
+            runPanels: async () => [candidate("c1"), candidate("c2")]
+        });
+        const res = await backend.chat({ messages: [{ role: "user", content: "the task" }], stream: false });
+        await res.text();
+        // judge.final is captured from a cloned response asynchronously.
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const events = readEvents();
+        const request = events.find((event) => event.event_type === "judge.request");
+        assert.ok(request, "expected a judge.request event");
+        assert.equal(request.component, "judge");
+        assert.equal(request.payload?.judge_model, "judge-x");
+        assert.equal(request.payload?.turn, 1, "first user message is turn 1");
+        assert.deepEqual(request.payload?.trajectory_ids, ["c1", "c2"]);
+        assert.ok(Array.isArray(request.payload?.messages), "judge prompt carries the conversation");
+        assert.ok(Array.isArray(request.payload?.trajectories), "judge prompt carries candidate trajectories");
+        assert.ok(typeof request.parent_span_id === "string", "judge span nests under the session span");
+        const final = events.find((event) => event.event_type === "judge.final");
+        assert.ok(final, "expected a judge.final event");
+        assert.equal(final.payload?.final_output, "FUSED ANSWER");
+        assert.equal(final.span_id, request.span_id, "request and final share the judge span");
+    }
+    finally {
+        await step.close();
+    }
+});
+test("an intermediate tool-call turn emits judge.thinking, not judge.final", async () => {
+    const step = await startStepServer((_req, res) => {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({
+            choices: [
+                {
+                    message: {
+                        role: "assistant",
+                        content: null,
+                        tool_calls: [{ id: "t1", type: "function", function: { name: "run", arguments: "{}" } }]
+                    },
+                    finish_reason: "tool_calls"
+                }
+            ]
+        }));
+    });
+    try {
+        const since = Date.now();
+        const backend = new FusionBackend({ stepUrl: step.url, runPanels: async () => [candidate("c1")] });
+        const res = await backend.chat({ messages: [{ role: "user", content: "intermediate task" }], stream: false });
+        await res.text();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const events = readEvents().filter((event) => event.ts >= since);
+        assert.equal(events.some((event) => event.event_type === "judge.final"), false, "an intermediate tool-call turn must not be reported as judge.final");
+        const thinking = events.find((event) => event.event_type === "judge.thinking");
+        assert.ok(thinking, "expected a judge.thinking event for the intermediate step");
+        assert.ok(thinking.payload?.tool_calls, "judge.thinking carries the intermediate tool calls");
+    }
+    finally {
+        await step.close();
+    }
+});

package/dist/test/fusion-backend.test.d.ts

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

package/dist/test/fusion-backend.test.js

@@ -0,0 +1,193 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { test } from "node:test";
+import { FusionBackend } from "../fusion-backend.js";
+function candidate(modelId, status = "succeeded") {
+    return { trajectory_id: `t_${modelId}`, model_id: modelId, status, final_output: "ok" };
+}
+const UNREACHABLE_STEP = "http://127.0.0.1:1/v1/fusion/trajectory:step";
+async function startStepServer(handler) {
+    let calls = 0;
+    const server = createServer((req, res) => {
+        calls += 1;
+        handler(req, res);
+    });
+    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}/v1/fusion/trajectory:step`,
+        calls: () => calls,
+        close: () => new Promise((resolve) => server.close(() => resolve()))
+    };
+}
+const userTurn = { messages: [{ role: "user", content: "do the task" }] };
+test("non-streaming panel failure returns an error and does not cache the session", async () => {
+    let panelCalls = 0;
+    const backend = new FusionBackend({
+        stepUrl: UNREACHABLE_STEP,
+        runPanels: async () => {
+            panelCalls += 1;
+            throw new Error("panel boom");
+        }
+    });
+    const first = await backend.chat({ ...userTurn, stream: false });
+    assert.equal(first.status, 502);
+    const body = (await first.json());
+    assert.match(body.error?.message ?? "", /panel boom/);
+    // The failed session is evicted, so the next turn re-runs the panel.
+    const second = await backend.chat({ ...userTurn, stream: false });
+    assert.equal(second.status, 502);
+    assert.equal(panelCalls, 2);
+});
+test("non-streaming empty candidates is an error, not a blank success", async () => {
+    const backend = new FusionBackend({ stepUrl: UNREACHABLE_STEP, runPanels: async () => [] });
+    const res = await backend.chat({ ...userTurn, stream: false });
+    assert.equal(res.status, 502);
+});
+test("non-streaming all-failed candidates is an error", async () => {
+    const backend = new FusionBackend({
+        stepUrl: UNREACHABLE_STEP,
+        runPanels: async () => [candidate("a", "failed"), candidate("b", "failed")]
+    });
+    const res = await backend.chat({ ...userTurn, stream: false });
+    assert.equal(res.status, 502);
+});
+test("non-streaming success forwards the trajectory:step response and runs panels once", async () => {
+    const step = await startStepServer((_req, res) => {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ choices: [{ message: { role: "assistant", content: "fused" } }] }));
+    });
+    try {
+        let panelCalls = 0;
+        const backend = new FusionBackend({
+            stepUrl: step.url,
+            runPanels: async () => {
+                panelCalls += 1;
+                return [candidate("a")];
+            }
+        });
+        const res = await backend.chat({ ...userTurn, stream: false });
+        assert.equal(res.status, 200);
+        const body = (await res.json());
+        assert.equal(body.choices[0]?.message.content, "fused");
+        // A second turn with the same prefix reuses the cached panel run.
+        await (await backend.chat({ ...userTurn, stream: false })).json();
+        assert.equal(panelCalls, 1);
+        assert.equal(step.calls(), 2);
+    }
+    finally {
+        await step.close();
+    }
+});
+test("non-streaming surfaces a trajectory:step error status", async () => {
+    const step = await startStepServer((_req, res) => {
+        res.writeHead(500);
+        res.end("boom");
+    });
+    try {
+        const backend = new FusionBackend({ stepUrl: step.url, runPanels: async () => [candidate("a")] });
+        const res = await backend.chat({ ...userTurn, stream: false });
+        assert.equal(res.status, 500);
+    }
+    finally {
+        await step.close();
+    }
+});
+test("streaming panel failure emits a terminal error event and evicts the session", async () => {
+    let panelCalls = 0;
+    const backend = new FusionBackend({
+        stepUrl: UNREACHABLE_STEP,
+        runPanels: async () => {
+            panelCalls += 1;
+            throw new Error("panel boom");
+        }
+    });
+    const res = await backend.chat({ ...userTurn, stream: true });
+    assert.equal(res.status, 200);
+    const text = await res.text();
+    assert.match(text, /fusion error/);
+    assert.match(text, /"finish_reason":"error"/);
+    assert.match(text, /\[DONE\]/);
+    await (await backend.chat({ ...userTurn, stream: true })).text();
+    assert.equal(panelCalls, 2);
+});
+test("an already-aborted signal aborts the trajectory:step fetch", async () => {
+    const backend = new FusionBackend({ stepUrl: UNREACHABLE_STEP, runPanels: async () => [candidate("a")] });
+    await assert.rejects(() => backend.chat({ ...userTurn, stream: false }, AbortSignal.abort()));
+});
+test("expired sessions are evicted so panels re-run after the TTL", async () => {
+    const step = await startStepServer((_req, res) => {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ choices: [{ message: { content: "ok" } }] }));
+    });
+    try {
+        let panelCalls = 0;
+        const backend = new FusionBackend({
+            stepUrl: step.url,
+            sessionTtlMs: 50,
+            runPanels: async () => {
+                panelCalls += 1;
+                return [candidate("a")];
+            }
+        });
+        await (await backend.chat({ ...userTurn, stream: false })).json();
+        await (await backend.chat({ ...userTurn, stream: false })).json();
+        assert.equal(panelCalls, 1, "within the TTL the panel run is cached");
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        await (await backend.chat({ ...userTurn, stream: false })).json();
+        assert.equal(panelCalls, 2, "after the TTL the session is evicted and panels re-run");
+    }
+    finally {
+        await step.close();
+    }
+});
+test("the panel re-runs per user turn but is reused within a turn's tool loop", async () => {
+    const step = await startStepServer((_req, res) => {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ choices: [{ message: { content: "ok" } }] }));
+    });
+    try {
+        let panelCalls = 0;
+        const turnsSeen = [];
+        const backend = new FusionBackend({
+            stepUrl: step.url,
+            runPanels: async (input) => {
+                panelCalls += 1;
+                turnsSeen.push(input.turn);
+                return [candidate(`c${input.turn}`)];
+            }
+        });
+        const system = { role: "system", content: "S" };
+        const first = { role: "user", content: "task one" };
+        // Turn 1: the first user message runs the panel.
+        await (await backend.chat({ messages: [system, first], stream: false })).json();
+        assert.equal(panelCalls, 1);
+        // Internal tool-loop continuation (same user-message count) reuses turn 1.
+        await (await backend.chat({
+            messages: [
+                system,
+                first,
+                { role: "assistant", content: null, tool_calls: [{ id: "t", type: "function" }] },
+                { role: "tool", tool_call_id: "t", content: "tool result" }
+            ],
+            stream: false
+        })).json();
+        assert.equal(panelCalls, 1, "a tool-loop continuation reuses the turn's candidates");
+        // Follow-up user message: a new turn, so the panel runs again.
+        await (await backend.chat({
+            messages: [
+                system,
+                first,
+                { role: "assistant", content: "answer one" },
+                { role: "user", content: "task two" }
+            ],
+            stream: false
+        })).json();
+        assert.equal(panelCalls, 2, "a follow-up user message re-runs the panel");
+        assert.deepEqual(turnsSeen, [1, 2], "each panel run is stamped with its user turn");
+    }
+    finally {
+        await step.close();
+    }
+});

package/dist/test/fusion-gateway.test.d.ts

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

package/dist/test/fusion-gateway.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { FUSION_EVIDENCE_HEADER, FUSION_RUN_ID_HEADER, FUSION_STATUS_HEADER, promptFromAnthropic, promptFromChat, promptFromResponses, startFusionGateway } from "../fusion-gateway.js";
+function recordingRunner() {
+    const calls = [];
+    const runner = async (input) => {
+        calls.push(input);
+        return {
+            finalOutput: `FUSION_OK:${input.dialect}:${input.prompt}`,
+            runId: `run_${calls.length}`,
+            status: "succeeded",
+            evidence: ["patch_artifact", "tool_execution", "judge_synthesis"]
+        };
+    };
+    return { runner, calls };
+}
+test("prompt extractors pull user text from each dialect", () => {
+    assert.equal(promptFromResponses({
+        instructions: "sys",
+        input: [{ role: "user", content: [{ type: "input_text", text: "hello" }] }]
+    }), "sys\n\nhello");
+    assert.equal(promptFromAnthropic({
+        system: "sys",
+        messages: [{ role: "user", content: "hi there" }]
+    }), "sys\n\nhi there");
+    assert.equal(promptFromChat({ messages: [{ role: "user", content: "do the thing" }] }), "do the thing");
+});
+test("gateway translates Responses, Anthropic, and Chat front doors", async () => {
+    const { runner, calls } = recordingRunner();
+    const gateway = await startFusionGateway({ runner, defaultModel: "fusion-panel" });
+    try {
+        const health = await fetch(`${gateway.url()}/health`);
+        assert.equal(health.status, 200);
+        const responses = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "fusion-panel",
+                input: [{ role: "user", content: [{ type: "input_text", text: "codex prompt" }] }]
+            })
+        });
+        assert.equal(responses.status, 200);
+        assert.equal(responses.headers.get(FUSION_STATUS_HEADER), "succeeded");
+        assert.equal(responses.headers.get(FUSION_RUN_ID_HEADER), "run_1");
+        assert.deepEqual(JSON.parse(responses.headers.get(FUSION_EVIDENCE_HEADER) ?? "[]"), [
+            "patch_artifact",
+            "tool_execution",
+            "judge_synthesis"
+        ]);
+        const responsesBody = (await responses.json());
+        assert.equal(responsesBody.object, "response");
+        assert.match(responsesBody.output[0]?.content[0]?.text ?? "", /FUSION_OK:openai-responses:codex prompt/);
+        const messages = await fetch(`${gateway.url()}/v1/messages`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "anthropic-version": "2023-06-01" },
+            body: JSON.stringify({
+                model: "fusion-panel",
+                max_tokens: 256,
+                messages: [{ role: "user", content: "claude prompt" }]
+            })
+        });
+        const messagesBody = (await messages.json());
+        assert.equal(messagesBody.type, "message");
+        assert.match(messagesBody.content[0]?.text ?? "", /FUSION_OK:anthropic-messages:claude prompt/);
+        const chat = await fetch(`${gateway.url()}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "fusion-panel",
+                messages: [{ role: "user", content: "cursor prompt" }]
+            })
+        });
+        const chatBody = (await chat.json());
+        assert.equal(chatBody.object, "chat.completion");
+        assert.match(chatBody.choices[0]?.message.content ?? "", /FUSION_OK:openai-chat:cursor prompt/);
+        assert.deepEqual(calls.map((call) => call.dialect), ["openai-responses", "anthropic-messages", "openai-chat"]);
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("gateway serves OpenAI and Anthropic model lists and enforces auth", async () => {
+    const { runner } = recordingRunner();
+    const gateway = await startFusionGateway({
+        runner,
+        defaultModel: "fusion-panel",
+        authToken: "secret"
+    });
+    try {
+        const unauthorized = await fetch(`${gateway.url()}/v1/models`);
+        assert.equal(unauthorized.status, 401);
+        const openai = await fetch(`${gateway.url()}/v1/models`, {
+            headers: { authorization: "Bearer secret" }
+        });
+        const openaiBody = (await openai.json());
+        assert.equal(openaiBody.data[0]?.id, "fusion-panel");
+        const anthropic = await fetch(`${gateway.url()}/v1/models`, {
+            headers: { authorization: "Bearer secret", "anthropic-version": "2023-06-01" }
+        });
+        const anthropicBody = (await anthropic.json());
+        assert.equal(anthropicBody.data[0]?.type, "model");
+        assert.equal(anthropicBody.data[0]?.id, "fusion-panel");
+    }
+    finally {
+        await gateway.close();
+    }
+});

package/dist/test/responses.test.d.ts

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

package/dist/test/responses.test.js

@@ -0,0 +1,157 @@
+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 { responsesToChat } from "../adapters/responses.js";
+import { 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 startMock() {
+    let lastChatBody;
+    let lastModelCallId;
+    const server = createServer((req, res) => {
+        void (async () => {
+            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.stream === true) {
+                res.statusCode = 200;
+                res.setHeader("content-type", "text/event-stream");
+                res.write('data: {"choices":[{"delta":{"content":"Hi"},"finish_reason":null}]}\n\n');
+                res.write('data: {"choices":[{"delta":{"content":" there"},"finish_reason":null}]}\n\n');
+                res.write('data: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":5,"completion_tokens":2}}\n\n');
+                res.write("data: [DONE]\n\n");
+                res.end();
+                return;
+            }
+            sendJson(res, 200, {
+                id: "cmpl-2",
+                object: "chat.completion",
+                model: body.model,
+                choices: [{ index: 0, message: { role: "assistant", content: "Final answer" }, finish_reason: "stop" }],
+                usage: { prompt_tokens: 6, completion_tokens: 2 }
+            });
+        })();
+    });
+    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("responsesToChat maps instructions, input items, and function output", () => {
+    const chat = responsesToChat({
+        model: "gpt-x",
+        instructions: "be terse",
+        input: [
+            { type: "message", role: "user", content: "search please" },
+            { type: "function_call", call_id: "call_1", name: "search", arguments: '{"q":"x"}' },
+            { type: "function_call_output", call_id: "call_1", output: "found" }
+        ],
+        tools: [{ type: "function", name: "search", description: "find", parameters: { type: "object" } }]
+    }, "local-model");
+    const messages = chat.messages;
+    assert.equal(chat.model, "local-model");
+    assert.equal(messages[0]?.role, "system");
+    assert.equal(messages[1]?.role, "user");
+    assert.equal(messages[2]?.role, "assistant");
+    assert.ok(Array.isArray(messages[2].tool_calls));
+    assert.equal(messages[3]?.role, "tool");
+    assert.equal(messages[3].tool_call_id, "call_1");
+    const tools = chat.tools;
+    assert.equal(tools[0]?.function.name, "search");
+});
+test("responsesToChat coalesces parallel function calls into one assistant message", () => {
+    // Codex emits parallel tool calls as separate function_call items; they must
+    // become a single assistant message so the following tool messages answer it
+    // (the chat API rejects an assistant tool_calls message that is not directly
+    // followed by tool responses for each tool_call_id).
+    const chat = responsesToChat({
+        input: [
+            { type: "message", role: "user", content: "fix it" },
+            { type: "function_call", call_id: "call_a", name: "read_file", arguments: '{"path":"a.js"}' },
+            { type: "function_call", call_id: "call_b", name: "read_file", arguments: '{"path":"b.js"}' },
+            { type: "function_call_output", call_id: "call_a", output: "A" },
+            { type: "function_call_output", call_id: "call_b", output: "B" }
+        ]
+    }, "local-model");
+    const messages = chat.messages;
+    // user, assistant(tool_calls:[a,b]), tool(a), tool(b)
+    assert.equal(messages.length, 4);
+    assert.equal(messages[1]?.role, "assistant");
+    const toolCalls = messages[1].tool_calls ?? [];
+    assert.equal(toolCalls.length, 2);
+    assert.deepEqual(toolCalls.map((call) => call.id), ["call_a", "call_b"]);
+    assert.equal(messages[2]?.role, "tool");
+    assert.equal(messages[2].tool_call_id, "call_a");
+    assert.equal(messages[3]?.role, "tool");
+    assert.equal(messages[3].tool_call_id, "call_b");
+});
+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" })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: "gpt-x", input: "hello" })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(mock.lastModelCallId(), response.headers.get(MODEL_CALL_ID_HEADER));
+        const json = (await response.json());
+        assert.equal(json.object, "response");
+        assert.equal(json.status, "completed");
+        assert.equal(json.output[0]?.type, "message");
+        assert.equal(json.output[0]?.content?.[0]?.text, "Final answer");
+        assert.equal(json.usage.output_tokens, 2);
+        assert.equal(mock.lastChatBody()?.model, "local-model");
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+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" })
+    });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: "gpt-x", stream: true, input: "hello" })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(response.headers.get("content-type"), "text/event-stream");
+        const text = await response.text();
+        assert.ok(text.includes("event: response.created"));
+        assert.ok(text.includes("event: response.output_item.added"));
+        assert.ok(text.includes('event: response.output_text.delta'));
+        assert.ok(text.includes('"delta":"Hi"'));
+        assert.ok(text.includes("event: response.completed"));
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@fusionkit/model-gateway",
+  "private": false,
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/velum-labs/handoffkit.git",
+    "directory": "packages/model-gateway"
+  },
+  "description": "Native local-model gateway: fronts an OpenAI-compatible local model and exposes the wire dialects each agent harness needs (OpenAI chat, Anthropic Messages, OpenAI Responses) so a local model can transparently back Claude Code, Codex, opencode, and Cursor.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@fusionkit/adapter-ai-sdk": "0.1.0",
+    "@fusionkit/protocol": "0.1.0"
+  }
+}