@fusionkit/model-gateway 0.1.0

package/dist/adapters/responses.js

@@ -0,0 +1,438 @@
+/**
+ * OpenAI Responses adapter. Codex speaks the Responses API exclusively
+ * (`wire_api="responses"`; Chat Completions support was removed), so to back it
+ * with a local model we translate `/v1/responses` to and from the gateway's
+ * OpenAI Chat Completions core. The pure translation functions are exported for
+ * testing; the handler returns a `Response` the server pipes (JSON or SSE).
+ *
+ * This is the highest-fidelity adapter: it maps Responses `input` items
+ * (messages, function calls, function-call outputs) into chat messages, and
+ * emits the Responses streaming event sequence (`response.created`,
+ * `response.output_item.added`, `response.output_text.delta`,
+ * `response.function_call_arguments.delta`, `response.completed`, …) from chat
+ * completion chunks.
+ */
+const ENCODER = new TextEncoder();
+function randomId() {
+    return Math.random().toString(36).slice(2, 12);
+}
+function partText(part) {
+    if (typeof part.text === "string" && (part.type === "input_text" || part.type === "output_text" || part.type === "text")) {
+        return part.text;
+    }
+    return "";
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    return content.map(partText).join("");
+}
+function contentToParts(content) {
+    if (typeof content === "string")
+        return content;
+    const parts = [];
+    for (const part of content) {
+        if (part.type === "input_image" && typeof part.image_url === "string") {
+            parts.push({ type: "image_url", image_url: { url: part.image_url } });
+        }
+        else {
+            const text = partText(part);
+            if (text.length > 0)
+                parts.push({ type: "text", text });
+        }
+    }
+    if (parts.length === 1 && parts[0]?.type === "text") {
+        return String(parts[0].text);
+    }
+    return parts;
+}
+function mapToolChoice(choice) {
+    if (typeof choice === "string")
+        return choice;
+    return { type: "function", function: { name: choice.name } };
+}
+/** Translate a Responses request to an OpenAI Chat Completions body. */
+export function responsesToChat(body, backendModel) {
+    const messages = [];
+    if (typeof body.instructions === "string" && body.instructions.length > 0) {
+        messages.push({ role: "system", content: body.instructions });
+    }
+    const input = body.input;
+    if (typeof input === "string") {
+        messages.push({ role: "user", content: input });
+    }
+    else if (Array.isArray(input)) {
+        // Coalesce consecutive function_call items into ONE assistant message.
+        // Codex emits parallel tool calls as separate function_call items; the chat
+        // API requires an assistant message's tool_calls to be answered by the
+        // following tool messages before the next assistant message, so each call
+        // must not become its own assistant turn.
+        let pendingToolCalls = [];
+        const flushToolCalls = () => {
+            if (pendingToolCalls.length === 0)
+                return;
+            messages.push({ role: "assistant", content: null, tool_calls: pendingToolCalls });
+            pendingToolCalls = [];
+        };
+        for (const item of input) {
+            if (item.type === "function_call") {
+                const call = item;
+                pendingToolCalls.push({
+                    id: call.call_id ?? call.id ?? `call_${randomId()}`,
+                    type: "function",
+                    function: { name: call.name, arguments: call.arguments }
+                });
+                continue;
+            }
+            flushToolCalls();
+            if (item.type === "function_call_output") {
+                const out = item;
+                const content = typeof out.output === "string" ? out.output : JSON.stringify(out.output);
+                messages.push({ role: "tool", tool_call_id: out.call_id, content });
+                continue;
+            }
+            // message item (explicit type "message" or a bare {role, content})
+            const message = item;
+            if (message.content === undefined)
+                continue;
+            const role = message.role === "developer" ? "system" : message.role ?? "user";
+            messages.push({ role, content: contentToParts(message.content) });
+        }
+        flushToolCalls();
+    }
+    const chat = {
+        model: backendModel ?? body.model ?? "",
+        messages,
+        stream: body.stream === true
+    };
+    if (typeof body.max_output_tokens === "number")
+        chat.max_tokens = body.max_output_tokens;
+    if (typeof body.temperature === "number")
+        chat.temperature = body.temperature;
+    if (typeof body.top_p === "number")
+        chat.top_p = body.top_p;
+    if (Array.isArray(body.tools) && body.tools.length > 0) {
+        // Only forward function tools with a usable name. Codex advertises some
+        // tools (e.g. custom/freeform shapes) that translate to an empty function
+        // name, which OpenAI Chat Completions rejects outright.
+        const named = body.tools.filter((tool) => typeof tool.name === "string" && tool.name.length > 0);
+        if (named.length > 0) {
+            chat.tools = named.map((tool) => ({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    ...(tool.description !== undefined ? { description: tool.description } : {}),
+                    parameters: tool.parameters ?? { type: "object", properties: {} }
+                }
+            }));
+        }
+    }
+    if (body.tool_choice !== undefined)
+        chat.tool_choice = mapToolChoice(body.tool_choice);
+    if (body.stream === true)
+        chat.stream_options = { include_usage: true };
+    return chat;
+}
+// ---- non-streaming response translation ----
+function buildOutput(message) {
+    const output = [];
+    const text = typeof message?.content === "string" ? message.content : "";
+    if (text.length > 0) {
+        output.push({
+            type: "message",
+            id: `msg_${randomId()}`,
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text, annotations: [] }]
+        });
+    }
+    if (Array.isArray(message?.tool_calls)) {
+        for (const call of message.tool_calls) {
+            output.push({
+                type: "function_call",
+                id: `fc_${randomId()}`,
+                call_id: call.id ?? `call_${randomId()}`,
+                name: call.function?.name ?? "",
+                arguments: call.function?.arguments ?? "",
+                status: "completed"
+            });
+        }
+    }
+    return output;
+}
+export function chatToResponses(openai, model) {
+    const message = openai.choices?.[0]?.message;
+    const output = buildOutput(message);
+    const inputTokens = openai.usage?.prompt_tokens ?? 0;
+    const outputTokens = openai.usage?.completion_tokens ?? 0;
+    return {
+        id: `resp_${openai.id ?? randomId()}`,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status: "completed",
+        model,
+        output,
+        usage: { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: inputTokens + outputTokens }
+    };
+}
+// ---- streaming translation (OpenAI chat SSE -> Responses SSE) ----
+function sse(type, data) {
+    return ENCODER.encode(`event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`);
+}
+export function openAiSseToResponses(upstream, model) {
+    const reader = upstream.getReader();
+    const decoder = new TextDecoder();
+    const responseId = `resp_${randomId()}`;
+    const messageItemId = `msg_${randomId()}`;
+    const tools = new Map();
+    let buffer = "";
+    let created = false;
+    let keepaliveTimer;
+    let textOpen = false;
+    let textValue = "";
+    let nextOutputIndex = 0;
+    let messageOutputIndex = -1;
+    let finished = false;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const baseResponse = (status, output) => ({
+        id: responseId,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status,
+        model,
+        output,
+        usage: status === "completed"
+            ? { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: inputTokens + outputTokens }
+            : null
+    });
+    const ensureCreated = (controller) => {
+        if (created)
+            return;
+        created = true;
+        controller.enqueue(sse("response.created", { response: baseResponse("in_progress", []) }));
+    };
+    const ensureText = (controller) => {
+        ensureCreated(controller);
+        if (textOpen)
+            return;
+        textOpen = true;
+        messageOutputIndex = nextOutputIndex++;
+        controller.enqueue(sse("response.output_item.added", {
+            output_index: messageOutputIndex,
+            item: { type: "message", id: messageItemId, status: "in_progress", role: "assistant", content: [] }
+        }));
+        controller.enqueue(sse("response.content_part.added", {
+            item_id: messageItemId,
+            output_index: messageOutputIndex,
+            content_index: 0,
+            part: { type: "output_text", text: "", annotations: [] }
+        }));
+    };
+    const assembleOutput = () => {
+        const output = [];
+        if (textOpen) {
+            output.push({
+                type: "message",
+                id: messageItemId,
+                status: "completed",
+                role: "assistant",
+                content: [{ type: "output_text", text: textValue, annotations: [] }]
+            });
+        }
+        for (const tool of tools.values()) {
+            output.push({
+                type: "function_call",
+                id: tool.itemId,
+                call_id: tool.callId,
+                name: tool.name,
+                arguments: tool.args,
+                status: "completed"
+            });
+        }
+        return output;
+    };
+    const finalize = (controller) => {
+        if (finished)
+            return;
+        finished = true;
+        if (keepaliveTimer !== undefined)
+            clearInterval(keepaliveTimer);
+        if (textOpen) {
+            controller.enqueue(sse("response.output_text.done", {
+                item_id: messageItemId,
+                output_index: messageOutputIndex,
+                content_index: 0,
+                text: textValue
+            }));
+            controller.enqueue(sse("response.content_part.done", {
+                item_id: messageItemId,
+                output_index: messageOutputIndex,
+                content_index: 0,
+                part: { type: "output_text", text: textValue, annotations: [] }
+            }));
+            controller.enqueue(sse("response.output_item.done", {
+                output_index: messageOutputIndex,
+                item: {
+                    type: "message",
+                    id: messageItemId,
+                    status: "completed",
+                    role: "assistant",
+                    content: [{ type: "output_text", text: textValue, annotations: [] }]
+                }
+            }));
+        }
+        for (const tool of tools.values()) {
+            controller.enqueue(sse("response.function_call_arguments.done", {
+                item_id: tool.itemId,
+                output_index: tool.outputIndex,
+                arguments: tool.args
+            }));
+            controller.enqueue(sse("response.output_item.done", {
+                output_index: tool.outputIndex,
+                item: {
+                    type: "function_call",
+                    id: tool.itemId,
+                    call_id: tool.callId,
+                    name: tool.name,
+                    arguments: tool.args,
+                    status: "completed"
+                }
+            }));
+        }
+        controller.enqueue(sse("response.completed", { response: baseResponse("completed", assembleOutput()) }));
+    };
+    const process = (controller, chunk) => {
+        if (chunk.usage !== undefined) {
+            inputTokens = chunk.usage.prompt_tokens ?? inputTokens;
+            outputTokens = chunk.usage.completion_tokens ?? outputTokens;
+        }
+        const choice = chunk.choices?.[0];
+        if (choice === undefined)
+            return;
+        const delta = choice.delta ?? {};
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+            ensureText(controller);
+            textValue += delta.content;
+            controller.enqueue(sse("response.output_text.delta", {
+                item_id: messageItemId,
+                output_index: messageOutputIndex,
+                content_index: 0,
+                delta: delta.content
+            }));
+        }
+        if (Array.isArray(delta.tool_calls)) {
+            for (const call of delta.tool_calls) {
+                const openAiIndex = typeof call.index === "number" ? call.index : 0;
+                let tool = tools.get(openAiIndex);
+                if (tool === undefined) {
+                    ensureCreated(controller);
+                    tool = {
+                        outputIndex: nextOutputIndex++,
+                        itemId: `fc_${randomId()}`,
+                        callId: call.id ?? `call_${randomId()}`,
+                        name: call.function?.name ?? "",
+                        args: ""
+                    };
+                    tools.set(openAiIndex, tool);
+                    controller.enqueue(sse("response.output_item.added", {
+                        output_index: tool.outputIndex,
+                        item: { type: "function_call", id: tool.itemId, call_id: tool.callId, name: tool.name, arguments: "" }
+                    }));
+                }
+                if (call.function?.name !== undefined && tool.name.length === 0)
+                    tool.name = call.function.name;
+                const args = call.function?.arguments;
+                if (typeof args === "string" && args.length > 0) {
+                    tool.args += args;
+                    controller.enqueue(sse("response.function_call_arguments.delta", {
+                        item_id: tool.itemId,
+                        output_index: tool.outputIndex,
+                        delta: args
+                    }));
+                }
+            }
+        }
+        if (choice.finish_reason !== null && choice.finish_reason !== undefined) {
+            finalize(controller);
+        }
+    };
+    return new ReadableStream({
+        start(controller) {
+            // Emit `response.created` immediately and keep the connection alive with
+            // SSE comments while the upstream is still producing its first event. Real
+            // CLIs (codex) reconnect if they see nothing for a while — which happens
+            // during the fusion panel phase before the judge's first token.
+            ensureCreated(controller);
+            keepaliveTimer = setInterval(() => {
+                if (finished)
+                    return;
+                try {
+                    controller.enqueue(ENCODER.encode(": keepalive\n\n"));
+                }
+                catch {
+                    // controller closed
+                }
+            }, 3000);
+        },
+        async pull(controller) {
+            const { done, value } = await reader.read();
+            if (done) {
+                if (!finished)
+                    finalize(controller);
+                controller.close();
+                return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf("\n");
+                if (!line.startsWith("data:"))
+                    continue;
+                const payload = line.slice(5).trim();
+                if (payload === "[DONE]") {
+                    if (!finished)
+                        finalize(controller);
+                    continue;
+                }
+                try {
+                    process(controller, JSON.parse(payload));
+                }
+                catch {
+                    // ignore malformed lines
+                }
+            }
+        },
+        cancel(reason) {
+            if (keepaliveTimer !== undefined)
+                clearInterval(keepaliveTimer);
+            return reader.cancel(reason);
+        }
+    });
+}
+// ---- handler ----
+function jsonResponse(status, value) {
+    return new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } });
+}
+export async function handleResponses(backend, body, modelCallId, signal) {
+    const requestedModel = body.model ?? backend.defaultModel ?? "";
+    const chat = responsesToChat(body, backend.defaultModel);
+    const upstream = await backend.chat(chat, signal, { modelCallId });
+    if (!upstream.ok) {
+        const detail = await upstream.text();
+        return jsonResponse(upstream.status, { error: { type: "api_error", message: detail.slice(0, 2000) } });
+    }
+    if (body.stream === true) {
+        const source = upstream.body;
+        if (source === null)
+            return jsonResponse(502, { error: { type: "api_error", message: "no upstream stream" } });
+        return new Response(openAiSseToResponses(source, requestedModel), {
+            status: 200,
+            headers: { "content-type": "text/event-stream", "cache-control": "no-cache" }
+        });
+    }
+    const openai = (await upstream.json());
+    return jsonResponse(200, chatToResponses(openai, requestedModel));
+}

package/dist/backend.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The gateway's model backend: an OpenAI-compatible Chat Completions server
+ * that the gateway translates every harness dialect down to. In practice this
+ * is the owned `velum-labs/mlx-lm` fork (`mlx_lm.server`), but it is equally
+ * any OpenAI-compatible local server (Ollama, vLLM, LM Studio) or a process
+ * fronted by `mlxServer`/`routedModel`. The backend is intentionally a thin
+ * `fetch` wrapper that returns the upstream `Response` unchanged, so the chat
+ * surface can stream straight through and the dialect adapters can consume the
+ * same core without a second abstraction.
+ */
+export type Backend = {
+    /** Model id sent to the backend when a request omits one. */
+    readonly defaultModel: string | undefined;
+    /** POST <base>/chat/completions — supports streaming (SSE) upstream. */
+    chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    /** GET <base>/models. */
+    models(signal?: AbortSignal): Promise<Response>;
+    /** POST <base>/embeddings. */
+    embeddings(body: unknown, signal?: AbortSignal): Promise<Response>;
+    /** Release any owned resources (e.g. a managed model process). Optional. */
+    close?(): Promise<void> | void;
+};
+export type BackendRequestOptions = {
+    modelCallId?: string;
+};
+export type OpenAiBackendOptions = {
+    /**
+     * Base URL including the OpenAI API prefix, e.g.
+     * `http://127.0.0.1:8080/v1`. Route paths (`/chat/completions`, `/models`,
+     * `/embeddings`) are appended to this value.
+     */
+    baseUrl: string;
+    /**
+     * Bearer credential forwarded to the backend. Local servers ignore it; the
+     * default mirrors the `not-needed` placeholder the AI SDK uses for local
+     * OpenAI-compatible servers.
+     */
+    apiKey?: string;
+    /** Model id used when a request omits `model`. */
+    defaultModel?: string;
+};
+/** Join a base URL (which may end in `/`) with a route path. */
+export declare function joinPath(baseUrl: string, path: string): string;
+/** An OpenAI Chat Completions backend reached over HTTP. */
+export declare class OpenAiBackend implements Backend {
+    #private;
+    readonly defaultModel: string | undefined;
+    constructor(options: OpenAiBackendOptions);
+    chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    models(signal?: AbortSignal): Promise<Response>;
+    embeddings(body: unknown, signal?: AbortSignal): Promise<Response>;
+}

package/dist/backend.js

@@ -0,0 +1,57 @@
+/**
+ * The gateway's model backend: an OpenAI-compatible Chat Completions server
+ * that the gateway translates every harness dialect down to. In practice this
+ * is the owned `velum-labs/mlx-lm` fork (`mlx_lm.server`), but it is equally
+ * any OpenAI-compatible local server (Ollama, vLLM, LM Studio) or a process
+ * fronted by `mlxServer`/`routedModel`. The backend is intentionally a thin
+ * `fetch` wrapper that returns the upstream `Response` unchanged, so the chat
+ * surface can stream straight through and the dialect adapters can consume the
+ * same core without a second abstraction.
+ */
+/** Join a base URL (which may end in `/`) with a route path. */
+export function joinPath(baseUrl, path) {
+    const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const suffix = path.startsWith("/") ? path : `/${path}`;
+    return `${base}${suffix}`;
+}
+/** An OpenAI Chat Completions backend reached over HTTP. */
+export class OpenAiBackend {
+    #baseUrl;
+    #apiKey;
+    defaultModel;
+    constructor(options) {
+        this.#baseUrl = options.baseUrl;
+        this.#apiKey = options.apiKey ?? "not-needed";
+        this.defaultModel = options.defaultModel;
+    }
+    #headers(options = {}) {
+        return {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.#apiKey}`,
+            ...(options.modelCallId ? { "x-velum-model-call-id": options.modelCallId } : {})
+        };
+    }
+    chat(body, signal, options = {}) {
+        return fetch(joinPath(this.#baseUrl, "/chat/completions"), {
+            method: "POST",
+            headers: this.#headers(options),
+            body: JSON.stringify(body),
+            ...(signal ? { signal } : {})
+        });
+    }
+    models(signal) {
+        return fetch(joinPath(this.#baseUrl, "/models"), {
+            method: "GET",
+            headers: this.#headers(),
+            ...(signal ? { signal } : {})
+        });
+    }
+    embeddings(body, signal) {
+        return fetch(joinPath(this.#baseUrl, "/embeddings"), {
+            method: "POST",
+            headers: this.#headers(),
+            body: JSON.stringify(body),
+            ...(signal ? { signal } : {})
+        });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,22 @@
+import type { Backend } from "./backend.js";
+/**
+ * Backend selection for the gateway. The default is the owned mlx fork
+ * (`mlx_lm.server`) — "mlx_lm.server first". An explicit OpenAI-compatible URL
+ * (`FUSIONKIT_LOCAL_MODEL_URL`) overrides it, which covers an already-running mlx
+ * server or a different local server (Ollama, vLLM, LM Studio) on hosts where
+ * the mlx provisioner cannot run. Legacy `WARRANT_*` names are still honored.
+ */
+/** Default mlx model, matching the examples/mlx default. */
+export declare const DEFAULT_MLX_MODEL = "prism-ml/Ternary-Bonsai-4B-mlx-2bit";
+export type BackendConfig = {
+    kind: "mlx";
+    model: string;
+    structured: boolean;
+} | {
+    kind: "openai";
+    baseUrl: string;
+    apiKey?: string;
+    defaultModel?: string;
+};
+export declare function resolveBackendConfig(env?: Record<string, string | undefined>): BackendConfig;
+export declare function createBackend(config: BackendConfig): Backend;

package/dist/config.js

@@ -0,0 +1,47 @@
+import { OpenAiBackend } from "./backend.js";
+import { MlxBackend } from "./mlx-backend.js";
+/**
+ * Backend selection for the gateway. The default is the owned mlx fork
+ * (`mlx_lm.server`) — "mlx_lm.server first". An explicit OpenAI-compatible URL
+ * (`FUSIONKIT_LOCAL_MODEL_URL`) overrides it, which covers an already-running mlx
+ * server or a different local server (Ollama, vLLM, LM Studio) on hosts where
+ * the mlx provisioner cannot run. Legacy `WARRANT_*` names are still honored.
+ */
+/** Default mlx model, matching the examples/mlx default. */
+export const DEFAULT_MLX_MODEL = "prism-ml/Ternary-Bonsai-4B-mlx-2bit";
+export function resolveBackendConfig(env = process.env) {
+    const url = env.FUSIONKIT_LOCAL_MODEL_URL ?? env.WARRANT_LOCAL_MODEL_URL;
+    if (url !== undefined && url.length > 0) {
+        const apiKey = env.FUSIONKIT_LOCAL_MODEL_KEY ?? env.WARRANT_LOCAL_MODEL_KEY;
+        const defaultModel = env.FUSIONKIT_LOCAL_MODEL ?? env.WARRANT_LOCAL_MODEL;
+        return {
+            kind: "openai",
+            baseUrl: url,
+            ...(apiKey !== undefined ? { apiKey } : {}),
+            ...(defaultModel !== undefined ? { defaultModel } : {})
+        };
+    }
+    return {
+        kind: "mlx",
+        model: env.FUSIONKIT_MLX_MODEL ?? env.WARRANT_MLX_MODEL ?? DEFAULT_MLX_MODEL,
+        // Structured decoding (the owned fork's reason for being) is on unless
+        // explicitly disabled.
+        structured: (env.FUSIONKIT_MLX_STRUCTURED ?? env.WARRANT_MLX_STRUCTURED) !== "0"
+    };
+}
+export function createBackend(config) {
+    switch (config.kind) {
+        case "mlx":
+            return new MlxBackend({ model: config.model, structured: config.structured });
+        case "openai":
+            return new OpenAiBackend({
+                baseUrl: config.baseUrl,
+                ...(config.apiKey !== undefined ? { apiKey: config.apiKey } : {}),
+                ...(config.defaultModel !== undefined ? { defaultModel: config.defaultModel } : {})
+            });
+        default: {
+            const unreachable = config;
+            throw new Error(`unknown backend config: ${JSON.stringify(unreachable)}`);
+        }
+    }
+}

package/dist/front-door-acceptance.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 type { AcpRunner } from "./acp-agent.js";
+export type FrontDoorStatus = "passed" | "failed" | "skipped_with_reason" | "blocked";
+export type FrontDoorOutcome = {
+    id: string;
+    status: FrontDoorStatus;
+    request_path?: string;
+    gateway_run_id?: string;
+    reason?: string;
+    evidence: string[];
+};
+export type FrontDoorAcceptanceReport = {
+    sentinel: string;
+    generated_at: string;
+    front_doors: FrontDoorOutcome[];
+};
+export type FrontDoorOutcomeProducer = () => Promise<FrontDoorOutcome>;
+export type FrontDoorAcceptanceOptions = {
+    gatewayUrl: string;
+    sentinel: string;
+    /** In-process ACP runner for the generic ACP front door. */
+    acpRunner?: AcpRunner;
+    /** Cursor ACP outcome via Cursorkit; absent means the dependency is missing. */
+    cursorAcp?: FrontDoorOutcomeProducer;
+    /** Registry-backed Codex ACP adapter outcome. */
+    codexAcp?: FrontDoorOutcomeProducer;
+    /** Registry-backed Claude Agent ACP adapter outcome. */
+    claudeAcp?: FrontDoorOutcomeProducer;
+};
+export declare function runFrontDoorAcceptance(options: FrontDoorAcceptanceOptions): Promise<FrontDoorAcceptanceReport>;