@fusionkit/model-gateway 0.1.0

package/dist/front-door-acceptance.js

@@ -0,0 +1,219 @@
+/**
+ * Unified front-door acceptance suite — the definition of "correct and done".
+ *
+ * Runs the same prompt/sentinel through every configured front door and
+ * produces one stable report with explicit `passed` / `failed` /
+ * `skipped_with_reason` / `blocked` outcomes. The HTTP front doors (Codex
+ * Responses, Claude Messages, OpenAI Chat for Cursorkit) are probed against a
+ * running Fusion Harness Gateway. The generic ACP front door is exercised
+ * in-process through an injected ACP runner. Cursor ACP and the registry-backed
+ * Codex/Claude ACP adapters are supplied as injected outcome producers so the
+ * CLI can wire real adapters while tests inject deterministic fakes.
+ */
+import { PassThrough } from "node:stream";
+import { runAcpAgent } from "./acp-agent.js";
+import { FUSION_EVIDENCE_HEADER, FUSION_RUN_ID_HEADER } from "./fusion-gateway.js";
+function normalizeGatewayUrl(value) {
+    return value.replace(/\/+$/, "");
+}
+function v1Url(gatewayUrl, path) {
+    const normalized = normalizeGatewayUrl(gatewayUrl);
+    const base = normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+    return `${base}${path}`;
+}
+function parseEvidenceHeader(value) {
+    if (value === null)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed))
+            return parsed.filter((item) => typeof item === "string");
+    }
+    catch {
+        return [];
+    }
+    return [];
+}
+function textFromResponses(body) {
+    const output = body.output;
+    if (!Array.isArray(output))
+        return "";
+    return output
+        .flatMap((item) => item.content ?? [])
+        .map((part) => (typeof part.text === "string" ? part.text : ""))
+        .join("");
+}
+function textFromAnthropic(body) {
+    const content = body.content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((part) => (typeof part.text === "string" ? part.text : "")).join("");
+}
+function textFromChat(body) {
+    const choices = body.choices;
+    const content = choices?.[0]?.message?.content;
+    return typeof content === "string" ? content : "";
+}
+async function probeHttpFrontDoor(input) {
+    let response;
+    try {
+        response = await fetch(input.url, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...(input.headers ?? {}) },
+            body: JSON.stringify(input.body)
+        });
+    }
+    catch (error) {
+        return {
+            id: input.id,
+            status: "blocked",
+            request_path: input.requestPath,
+            reason: error instanceof Error ? error.message : String(error),
+            evidence: []
+        };
+    }
+    if (!response.ok) {
+        return {
+            id: input.id,
+            status: "failed",
+            request_path: input.requestPath,
+            reason: `gateway returned ${response.status}`,
+            evidence: []
+        };
+    }
+    const runId = response.headers.get(FUSION_RUN_ID_HEADER) ?? undefined;
+    const evidence = parseEvidenceHeader(response.headers.get(FUSION_EVIDENCE_HEADER));
+    const text = input.extractText((await response.json()));
+    const matched = text.includes(input.sentinel);
+    return {
+        id: input.id,
+        status: matched ? "passed" : "failed",
+        request_path: input.requestPath,
+        ...(runId !== undefined ? { gateway_run_id: runId } : {}),
+        ...(matched ? {} : { reason: "sentinel not found in final output" }),
+        evidence: matched ? ["sentinel", ...evidence] : evidence
+    };
+}
+async function probeGenericAcp(acpRunner, sentinel) {
+    const input = new PassThrough();
+    const output = new PassThrough();
+    let raw = "";
+    output.on("data", (chunk) => {
+        raw += chunk.toString("utf8");
+    });
+    const done = runAcpAgent({ runner: acpRunner, input, output });
+    const write = (message) => {
+        input.write(`${JSON.stringify(message)}\n`);
+    };
+    write({ jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: 1 } });
+    write({ jsonrpc: "2.0", id: 2, method: "session/new", params: { cwd: process.cwd(), mcpServers: [] } });
+    write({
+        jsonrpc: "2.0",
+        id: 3,
+        method: "session/prompt",
+        params: { sessionId: "sess_1", prompt: [{ type: "text", text: "front-door acceptance" }] }
+    });
+    input.end();
+    await done;
+    const updates = raw
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+    const updateText = updates
+        .filter((message) => message.method === "session/update")
+        .map((message) => {
+        const params = message.params;
+        return params?.update?.content?.text ?? "";
+    })
+        .join("");
+    const promptResult = updates.find((message) => message.result !== undefined && typeof message.result === "object")?.result;
+    const matched = updateText.includes(sentinel);
+    const evidence = promptResult?._meta?.evidence ?? [];
+    return {
+        id: "generic-acp",
+        status: matched ? "passed" : "failed",
+        request_path: "session/prompt",
+        ...(promptResult?._meta?.runId !== undefined ? { gateway_run_id: promptResult._meta.runId } : {}),
+        ...(matched ? {} : { reason: "sentinel not found in session/update" }),
+        evidence: matched ? ["sentinel", ...evidence] : evidence
+    };
+}
+export async function runFrontDoorAcceptance(options) {
+    const frontDoors = [];
+    frontDoors.push(await probeHttpFrontDoor({
+        id: "codex-responses",
+        url: v1Url(options.gatewayUrl, "/responses"),
+        requestPath: "/v1/responses",
+        body: {
+            model: "fusion-panel",
+            input: [{ role: "user", content: [{ type: "input_text", text: "front-door acceptance" }] }]
+        },
+        extractText: textFromResponses,
+        sentinel: options.sentinel
+    }));
+    frontDoors.push(await probeHttpFrontDoor({
+        id: "claude-messages",
+        url: v1Url(options.gatewayUrl, "/messages"),
+        requestPath: "/v1/messages",
+        headers: { "anthropic-version": "2023-06-01" },
+        body: {
+            model: "fusion-panel",
+            max_tokens: 512,
+            messages: [{ role: "user", content: "front-door acceptance" }]
+        },
+        extractText: textFromAnthropic,
+        sentinel: options.sentinel
+    }));
+    frontDoors.push(await probeHttpFrontDoor({
+        id: "openai-chat",
+        url: v1Url(options.gatewayUrl, "/chat/completions"),
+        requestPath: "/v1/chat/completions",
+        body: {
+            model: "fusion-panel",
+            messages: [{ role: "user", content: "front-door acceptance" }]
+        },
+        extractText: textFromChat,
+        sentinel: options.sentinel
+    }));
+    if (options.acpRunner !== undefined) {
+        frontDoors.push(await probeGenericAcp(options.acpRunner, options.sentinel));
+    }
+    else {
+        frontDoors.push({
+            id: "generic-acp",
+            status: "blocked",
+            request_path: "session/prompt",
+            reason: "acp_runner_not_configured",
+            evidence: []
+        });
+    }
+    frontDoors.push(options.codexAcp !== undefined
+        ? await options.codexAcp()
+        : {
+            id: "codex-acp",
+            status: "blocked",
+            reason: "codex_acp_adapter_not_installed",
+            evidence: []
+        });
+    frontDoors.push(options.claudeAcp !== undefined
+        ? await options.claudeAcp()
+        : {
+            id: "claude-acp",
+            status: "blocked",
+            reason: "claude_acp_adapter_not_installed",
+            evidence: []
+        });
+    frontDoors.push(options.cursorAcp !== undefined
+        ? await options.cursorAcp()
+        : {
+            id: "cursor-acp",
+            status: "blocked",
+            reason: "cursorkit_backend_not_running",
+            evidence: []
+        });
+    return {
+        sentinel: options.sentinel,
+        generated_at: new Date().toISOString(),
+        front_doors: frontDoors
+    };
+}

package/dist/fusion-backend.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The fusion front-door backend.
+ *
+ * This is the clean abstraction behind "the judge streams a trajectory the
+ * user's harness executes". It implements the gateway {@link Backend} contract
+ * (an OpenAI Chat Completions surface) so it slots into the existing
+ * `startGateway` server and reuses every dialect adapter (chat / responses /
+ * anthropic) — including their full tool-call, tool-result, and streaming
+ * support — for free.
+ *
+ * Per front-door turn it:
+ *   1. derives a stable session key from the conversation prefix,
+ *   2. runs the panel **once** per session (injected `runPanels`, so this
+ *      package keeps no dependency on `@fusionkit/ensemble`) to produce the
+ *      candidate trajectories,
+ *   3. forwards the live conversation + the harness tools + the candidate
+ *      trajectories to FusionKit's `trajectory:step`, whose response (an OpenAI
+ *      chat completion, optionally streamed, that may carry `tool_calls`) is
+ *      returned verbatim for the server to translate into the caller's dialect.
+ *
+ * There is no apply/verify/repair here: iteration is the user's harness's job.
+ *
+ * Failures are surfaced, never swallowed: a panel run that throws or yields no
+ * usable candidate, or a `trajectory:step` that errors, produces an explicit
+ * error (a non-2xx response when nothing has streamed yet, or a terminal error
+ * event with `finish_reason: "error"` once the SSE has started) and the failed
+ * session is evicted so the next turn retries instead of replaying the failure.
+ */
+import type { Backend, BackendRequestOptions } from "./backend.js";
+/** A candidate trajectory in the wire shape FusionKit's `trajectory:step` accepts. */
+export type WireTrajectory = {
+    trajectory_id: string;
+    model_id: string;
+    status: string;
+    final_output: string;
+    steps?: Array<Record<string, unknown>>;
+    candidate_id?: string;
+    model?: string;
+    harness_kind?: string;
+    diff?: string;
+    verification?: {
+        status: string;
+        evidence?: string[];
+        exit_code?: number;
+    };
+    metadata?: Record<string, unknown>;
+};
+export type ChatMessageLike = {
+    role: string;
+    content?: unknown;
+    tool_calls?: unknown;
+    tool_call_id?: string;
+    name?: string;
+};
+export type PanelRunInput = {
+    /** The task prompt distilled from the conversation prefix (system + first user). */
+    task: string;
+    /** The full incoming OpenAI-style message list for the first turn. */
+    messages: ChatMessageLike[];
+    /** The trace id minted for this fusion session. */
+    traceId: string;
+    /** The session root span; panel/candidate events parent under it. */
+    sessionSpanId: string;
+    /** Stable per-session key (hash of the conversation prefix). */
+    sessionKey: string;
+    /** 1-based user-turn index this panel run belongs to. */
+    turn: number;
+};
+/** Runs the panel once for a session and returns its candidate trajectories. */
+export type PanelRunner = (input: PanelRunInput) => Promise<WireTrajectory[]>;
+export type FusionBackendOptions = {
+    /** FusionKit `POST /v1/fusion/trajectory:step` URL. */
+    stepUrl: string;
+    /** Produces candidate trajectories for a new session (injected; uses ensemble). */
+    runPanels: PanelRunner;
+    /** Model id echoed to clients and sent to the judge step. */
+    defaultModel?: string;
+    /** Judge model id forwarded to FusionKit (defaults to its configured judge). */
+    judgeModel?: string;
+    /** How long a session's candidate trajectories stay cached. */
+    sessionTtlMs?: number;
+    /** Wall-clock budget for the panel phase before the turn fails. */
+    panelTimeoutMs?: number;
+    /** Wall-clock budget for a single `trajectory:step` call. */
+    stepTimeoutMs?: number;
+    /** Mint a trace id (injectable for tests). */
+    mintTraceId?: () => string;
+};
+export declare class FusionBackend implements Backend {
+    #private;
+    readonly defaultModel: string | undefined;
+    constructor(options: FusionBackendOptions);
+    chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    models(): Promise<Response>;
+    embeddings(): Promise<Response>;
+}