@fusionkit/model-gateway 0.1.0

package/dist/test/anthropic.test.js

@@ -0,0 +1,251 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { test } from "node:test";
+import { anthropicToChat, chatToAnthropicMessage, mapStopReason, openAiSseToAnthropic } from "../adapters/anthropic.js";
+import { OpenAiBackend } from "../backend.js";
+import { MODEL_CALL_ID_HEADER } from "../provenance.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":"Hel"},"finish_reason":null}]}\n\n');
+                res.write('data: {"choices":[{"delta":{"content":"lo"},"finish_reason":null}]}\n\n');
+                res.write('data: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"completion_tokens":2}}\n\n');
+                res.write("data: [DONE]\n\n");
+                res.end();
+                return;
+            }
+            sendJson(res, 200, {
+                id: "cmpl-1",
+                object: "chat.completion",
+                model: body.model,
+                choices: [
+                    { index: 0, message: { role: "assistant", content: "Hello there" }, finish_reason: "stop" }
+                ],
+                usage: { prompt_tokens: 7, completion_tokens: 3 }
+            });
+        })();
+    });
+    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("anthropicToChat maps system, tools, and tool results", () => {
+    const chat = anthropicToChat({
+        model: "claude-x",
+        system: "be terse",
+        max_tokens: 100,
+        messages: [
+            { role: "user", content: "hi" },
+            {
+                role: "assistant",
+                content: [{ type: "tool_use", id: "tu_1", name: "search", input: { q: "x" } }]
+            },
+            {
+                role: "user",
+                content: [{ type: "tool_result", tool_use_id: "tu_1", content: "result text" }]
+            }
+        ],
+        tools: [{ name: "search", description: "find", input_schema: { 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, "tu_1");
+    const tools = chat.tools;
+    assert.equal(tools[0]?.function.name, "search");
+});
+test("anthropicToChat groups parallel tool_use into one assistant message", () => {
+    // Anthropic batches parallel tool calls as multiple tool_use blocks in a
+    // single assistant message; they must stay one assistant message followed by
+    // the tool results so the chat API's tool_calls pairing stays valid.
+    const chat = anthropicToChat({
+        messages: [
+            { role: "user", content: "do both" },
+            {
+                role: "assistant",
+                content: [
+                    { type: "tool_use", id: "tu_a", name: "read_file", input: { path: "a" } },
+                    { type: "tool_use", id: "tu_b", name: "read_file", input: { path: "b" } }
+                ]
+            },
+            {
+                role: "user",
+                content: [
+                    { type: "tool_result", tool_use_id: "tu_a", content: "A" },
+                    { type: "tool_result", tool_use_id: "tu_b", content: "B" }
+                ]
+            }
+        ]
+    }, "local-model");
+    const messages = chat.messages;
+    const assistant = messages.find((m) => m.role === "assistant");
+    assert.equal(assistant.tool_calls?.length, 2);
+    assert.deepEqual(assistant.tool_calls?.map((call) => call.id), ["tu_a", "tu_b"]);
+    const toolMessages = messages.filter((m) => m.role === "tool");
+    assert.deepEqual(toolMessages.map((m) => m.tool_call_id), ["tu_a", "tu_b"]);
+});
+test("anthropic streaming starts eagerly and pings during the panel phase", async () => {
+    // A never-ending upstream simulates the silent fusion panel phase before the
+    // judge's first token.
+    let upstreamController;
+    const upstream = new ReadableStream({
+        start(controller) {
+            upstreamController = controller;
+        }
+    });
+    const decoder = new TextDecoder();
+    const reader = openAiSseToAnthropic(upstream, "claude-x").getReader();
+    try {
+        // message_start must arrive before any upstream data is produced.
+        const first = await reader.read();
+        assert.ok(first.value !== undefined);
+        assert.ok(decoder.decode(first.value).includes("event: message_start"));
+        // A ping keepalive must arrive while the upstream is still silent.
+        let sawPing = false;
+        const deadline = Date.now() + 4000;
+        while (Date.now() < deadline) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            if (value !== undefined && decoder.decode(value).includes("event: ping")) {
+                sawPing = true;
+                break;
+            }
+        }
+        assert.ok(sawPing, "a ping keepalive must be emitted while the upstream is silent");
+    }
+    finally {
+        await reader.cancel();
+        // cancel() already propagates to the upstream; closing again is a no-op.
+        try {
+            upstreamController.close();
+        }
+        catch {
+            // already closed via cancel
+        }
+    }
+});
+test("chatToAnthropicMessage produces a text content block", () => {
+    const message = chatToAnthropicMessage({
+        id: "cmpl-9",
+        choices: [{ message: { content: "hi" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 4, completion_tokens: 1 }
+    }, "claude-x");
+    assert.equal(message.type, "message");
+    const content = message.content;
+    assert.equal(content[0]?.type, "text");
+    assert.equal(content[0]?.text, "hi");
+    assert.equal(message.stop_reason, "end_turn");
+});
+test("mapStopReason maps tool_calls to tool_use", () => {
+    assert.equal(mapStopReason("tool_calls"), "tool_use");
+    assert.equal(mapStopReason("length"), "max_tokens");
+    assert.equal(mapStopReason("stop"), "end_turn");
+});
+test("serves a non-streaming Anthropic message 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/messages`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "anthropic-version": "2023-06-01" },
+            body: JSON.stringify({ model: "claude-x", max_tokens: 50, messages: [{ role: "user", content: "hi" }] })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(mock.lastModelCallId(), response.headers.get(MODEL_CALL_ID_HEADER));
+        const json = (await response.json());
+        assert.equal(json.type, "message");
+        assert.equal(json.model, "claude-x");
+        assert.equal(json.content[0]?.text, "Hello there");
+        // Upstream got the backend model, not the claude id.
+        assert.equal(mock.lastChatBody()?.model, "local-model");
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("translates a streamed Anthropic message", 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/messages`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "anthropic-version": "2023-06-01" },
+            body: JSON.stringify({ model: "claude-x", max_tokens: 50, 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("event: message_start"));
+        assert.ok(text.includes("event: content_block_start"));
+        assert.ok(text.includes('"type":"text_delta","text":"Hel"'));
+        assert.ok(text.includes("event: message_stop"));
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("estimates tokens and serves Anthropic discovery", async () => {
+    const mock = await startMock();
+    const gateway = await startGateway({
+        backend: new OpenAiBackend({ baseUrl: `${mock.url}/v1`, defaultModel: "local-model" })
+    });
+    try {
+        const count = await fetch(`${gateway.url()}/v1/messages/count_tokens`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "anthropic-version": "2023-06-01" },
+            body: JSON.stringify({ model: "claude-x", messages: [{ role: "user", content: "hello world" }] })
+        });
+        assert.equal(count.status, 200);
+        const counted = (await count.json());
+        assert.ok(counted.input_tokens > 0);
+        const models = await fetch(`${gateway.url()}/v1/models`, {
+            headers: { "anthropic-version": "2023-06-01" }
+        });
+        const list = (await models.json());
+        assert.ok(list.data[0]?.id.startsWith("claude"));
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});

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

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

package/dist/test/chat.test.js

@@ -0,0 +1,270 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { test } from "node:test";
+import { assertModelCallRecordV1 } from "@fusionkit/protocol";
+import { OpenAiBackend } from "../backend.js";
+import { MODEL_CALL_ID_HEADER } from "../provenance.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 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);
+        assertModelCallRecordV1(records[0]);
+        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("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);
+        assertModelCallRecordV1(records[0]);
+        assert.equal(records[0]?.status, "failed");
+        assert.equal(records[0]?.error?.kind, "provider_error");
+    }
+    finally {
+        await gateway.close();
+        await mock.close();
+    }
+});
+test("records thrown backend failures as failed model-call records", async () => {
+    const records = [];
+    const gateway = await startGateway({
+        backend: {
+            defaultModel: "throw-model",
+            chat: async () => {
+                throw new Error("backend exploded");
+            },
+            models: async () => new Response("{}", { status: 200 }),
+            embeddings: async () => new Response("{}", { status: 200 })
+        },
+        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: "fail" }] })
+        });
+        assert.equal(response.status, 502);
+        assert.equal(response.headers.get(MODEL_CALL_ID_HEADER), records[0]?.call_id);
+        assert.equal(records.length, 1);
+        assertModelCallRecordV1(records[0]);
+        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("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/front-door-acceptance.test.d.ts

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

package/dist/test/front-door-acceptance.test.js

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { runFrontDoorAcceptance } from "../front-door-acceptance.js";
+import { startFusionGateway } from "../fusion-gateway.js";
+const SENTINEL = "FUSION_OK";
+function sentinelRunner() {
+    return async (input) => ({
+        finalOutput: `${SENTINEL} handled ${input.dialect}`,
+        runId: `run_${input.requestId}`,
+        status: "succeeded",
+        evidence: ["patch_artifact", "tool_execution", "judge_synthesis"]
+    });
+}
+function sentinelAcpRunner() {
+    return async (input) => ({
+        finalOutput: `${SENTINEL} acp ${input.prompt}`,
+        runId: `run_${input.requestId}`,
+        status: "succeeded",
+        evidence: ["judge_synthesis"]
+    });
+}
+function byId(report, id) {
+    const outcome = report.front_doors.find((door) => door.id === id);
+    assert.ok(outcome, `expected front door ${id}`);
+    return outcome;
+}
+test("acceptance passes HTTP front doors and generic ACP, blocks missing adapters", async () => {
+    const gateway = await startFusionGateway({ runner: sentinelRunner(), defaultModel: "fusion-panel" });
+    try {
+        const report = await runFrontDoorAcceptance({
+            gatewayUrl: gateway.url(),
+            sentinel: SENTINEL,
+            acpRunner: sentinelAcpRunner()
+        });
+        assert.equal(byId(report, "codex-responses").status, "passed");
+        assert.equal(byId(report, "claude-messages").status, "passed");
+        assert.equal(byId(report, "openai-chat").status, "passed");
+        assert.equal(byId(report, "generic-acp").status, "passed");
+        assert.ok(byId(report, "codex-responses").evidence.includes("sentinel"));
+        assert.ok(byId(report, "codex-responses").evidence.includes("judge_synthesis"));
+        assert.equal(byId(report, "codex-acp").status, "blocked");
+        assert.equal(byId(report, "claude-acp").status, "blocked");
+        assert.equal(byId(report, "cursor-acp").status, "blocked");
+        assert.equal(byId(report, "cursor-acp").reason, "cursorkit_backend_not_running");
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("acceptance uses injected adapter outcomes when provided", async () => {
+    const gateway = await startFusionGateway({ runner: sentinelRunner(), defaultModel: "fusion-panel" });
+    try {
+        const report = await runFrontDoorAcceptance({
+            gatewayUrl: gateway.url(),
+            sentinel: SENTINEL,
+            acpRunner: sentinelAcpRunner(),
+            codexAcp: async () => ({ id: "codex-acp", status: "passed", evidence: ["sentinel"] }),
+            claudeAcp: async () => ({
+                id: "claude-acp",
+                status: "skipped_with_reason",
+                reason: "claude_credit_or_credential_blocked",
+                evidence: []
+            }),
+            cursorAcp: async () => ({ id: "cursor-acp", status: "passed", evidence: ["sentinel"] })
+        });
+        assert.equal(byId(report, "codex-acp").status, "passed");
+        assert.equal(byId(report, "claude-acp").status, "skipped_with_reason");
+        assert.equal(byId(report, "claude-acp").reason, "claude_credit_or_credential_blocked");
+        assert.equal(byId(report, "cursor-acp").status, "passed");
+    }
+    finally {
+        await gateway.close();
+    }
+});
+test("acceptance fails a front door when the sentinel is absent", async () => {
+    const gateway = await startFusionGateway({
+        runner: async (input) => ({
+            finalOutput: `no marker for ${input.dialect}`,
+            runId: "run_x",
+            status: "succeeded",
+            evidence: []
+        }),
+        defaultModel: "fusion-panel"
+    });
+    try {
+        const report = await runFrontDoorAcceptance({ gatewayUrl: gateway.url(), sentinel: SENTINEL });
+        assert.equal(byId(report, "codex-responses").status, "failed");
+        assert.equal(byId(report, "generic-acp").status, "blocked");
+        assert.equal(byId(report, "generic-acp").reason, "acp_runner_not_configured");
+    }
+    finally {
+        await gateway.close();
+    }
+});

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

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