@fusionkit/model-gateway 0.1.0

package/dist/acp-agent.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ACP-compatible front door for the unified runner.
+ *
+ * Implements the minimal Agent Client Protocol (ACP) local-agent lifecycle over
+ * newline-delimited JSON-RPC on stdio: `initialize`, `authenticate`,
+ * `session/new`, and `session/prompt`. A `session/prompt` runs the unified
+ * harness ensemble through an injected runner and streams the synthesized final
+ * answer back as `session/update` notifications before returning the prompt
+ * turn's stop reason.
+ *
+ * The runner is injected so this package stays free of a dependency on
+ * `@fusionkit/ensemble` (which depends on this package). The input/output streams
+ * are injectable for deterministic testing.
+ */
+import type { Readable, Writable } from "node:stream";
+export declare const ACP_PROTOCOL_VERSION = 1;
+export type AcpRunnerInput = {
+    prompt: string;
+    sessionId: string;
+    requestId: string;
+};
+export type AcpRunnerResult = {
+    finalOutput: string;
+    runId: string;
+    status: "succeeded" | "failed" | "skipped";
+    evidence: string[];
+};
+export type AcpRunner = (input: AcpRunnerInput) => Promise<AcpRunnerResult>;
+export type AcpAgentOptions = {
+    runner: AcpRunner;
+    input?: Readable;
+    output?: Writable;
+    protocolVersion?: number;
+};
+/**
+ * Run the ACP agent loop until the input stream ends. Resolves when input
+ * closes. Each line is one JSON-RPC message.
+ */
+export declare function runAcpAgent(options: AcpAgentOptions): Promise<void>;

package/dist/acp-agent.js

@@ -0,0 +1,143 @@
+/**
+ * ACP-compatible front door for the unified runner.
+ *
+ * Implements the minimal Agent Client Protocol (ACP) local-agent lifecycle over
+ * newline-delimited JSON-RPC on stdio: `initialize`, `authenticate`,
+ * `session/new`, and `session/prompt`. A `session/prompt` runs the unified
+ * harness ensemble through an injected runner and streams the synthesized final
+ * answer back as `session/update` notifications before returning the prompt
+ * turn's stop reason.
+ *
+ * The runner is injected so this package stays free of a dependency on
+ * `@fusionkit/ensemble` (which depends on this package). The input/output streams
+ * are injectable for deterministic testing.
+ */
+import { createInterface } from "node:readline";
+export const ACP_PROTOCOL_VERSION = 1;
+function textFromPromptParam(params) {
+    if (typeof params !== "object" || params === null)
+        return "";
+    const prompt = params.prompt;
+    if (typeof prompt === "string")
+        return prompt;
+    if (Array.isArray(prompt)) {
+        return prompt
+            .map((block) => {
+            const candidate = block;
+            return typeof candidate.text === "string" ? candidate.text : "";
+        })
+            .join("");
+    }
+    return "";
+}
+function sessionIdFromParams(params, fallback) {
+    if (typeof params === "object" && params !== null) {
+        const sessionId = params.sessionId;
+        if (typeof sessionId === "string" && sessionId.length > 0)
+            return sessionId;
+    }
+    return fallback;
+}
+/**
+ * Run the ACP agent loop until the input stream ends. Resolves when input
+ * closes. Each line is one JSON-RPC message.
+ */
+export async function runAcpAgent(options) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const protocolVersion = options.protocolVersion ?? ACP_PROTOCOL_VERSION;
+    let sessionCounter = 0;
+    let requestCounter = 0;
+    const send = (message) => {
+        output.write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}\n`);
+    };
+    const respond = (id, result) => {
+        send({ id, result });
+    };
+    const respondError = (id, code, message) => {
+        send({ id, error: { code, message } });
+    };
+    const handlePrompt = async (id, params) => {
+        const sessionId = sessionIdFromParams(params, `sess_${sessionCounter}`);
+        const prompt = textFromPromptParam(params);
+        requestCounter += 1;
+        const result = await options.runner({
+            prompt,
+            sessionId,
+            requestId: `acp_${requestCounter}`
+        });
+        send({
+            method: "session/update",
+            params: {
+                sessionId,
+                update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: { type: "text", text: result.finalOutput }
+                }
+            }
+        });
+        respond(id, {
+            stopReason: result.status === "succeeded" ? "end_turn" : "refusal",
+            _meta: { runId: result.runId, status: result.status, evidence: result.evidence }
+        });
+    };
+    const dispatch = async (message) => {
+        const { id, method } = message;
+        if (method === undefined || id === undefined)
+            return;
+        switch (method) {
+            case "initialize":
+                respond(id, {
+                    protocolVersion,
+                    agentCapabilities: {
+                        loadSession: false,
+                        promptCapabilities: { image: false, audio: false, embeddedContext: true }
+                    },
+                    authMethods: []
+                });
+                return;
+            case "authenticate":
+                respond(id, {});
+                return;
+            case "session/new":
+                sessionCounter += 1;
+                respond(id, { sessionId: `sess_${sessionCounter}` });
+                return;
+            case "session/load":
+                respond(id, {});
+                return;
+            case "session/cancel":
+                respond(id, {});
+                return;
+            case "session/prompt":
+                await handlePrompt(id, message.params);
+                return;
+            default:
+                respondError(id, -32601, `method not found: ${method}`);
+                return;
+        }
+    };
+    const rl = createInterface({ input });
+    const pending = [];
+    rl.on("line", (line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            return;
+        let message;
+        try {
+            message = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        pending.push(dispatch(message).catch((error) => {
+            if (message.id !== undefined) {
+                respondError(message.id, -32603, error instanceof Error ? error.message : String(error));
+            }
+        }));
+    });
+    await new Promise((resolve) => {
+        rl.on("close", () => resolve());
+    });
+    await Promise.all(pending);
+}

package/dist/acp-registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ACP Registry integration. Resolves curated ACP-compatible agents (for
+ * example the registry-backed `Codex CLI` and `Claude Agent` adapters) from the
+ * ACP Registry so they can drive the generic ACP front door. The fetcher and
+ * install directory are injectable for deterministic testing.
+ *
+ * Registry source: https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json
+ */
+export declare const ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+export type AcpRegistryAgent = {
+    id: string;
+    name?: string;
+    version?: string;
+    description?: string;
+    distribution?: Record<string, unknown>;
+};
+export type AcpRegistry = {
+    agents: AcpRegistryAgent[];
+};
+export type AcpRegistryFetcher = (url: string) => Promise<unknown>;
+export type InstalledAcpAdapter = {
+    id: string;
+    name: string;
+    version: string;
+    distribution: Record<string, unknown>;
+    installedAt: string;
+    metadataPath: string;
+};
+export declare function fetchAcpRegistry(fetcher?: AcpRegistryFetcher, url?: string): Promise<AcpRegistry>;
+export type InstallAcpAdaptersOptions = {
+    agentIds: string[];
+    installDir: string;
+    fetcher?: AcpRegistryFetcher;
+    url?: string;
+};
+export declare function installAcpAdapters(options: InstallAcpAdaptersOptions): Promise<InstalledAcpAdapter[]>;

package/dist/acp-registry.js

@@ -0,0 +1,85 @@
+/**
+ * ACP Registry integration. Resolves curated ACP-compatible agents (for
+ * example the registry-backed `Codex CLI` and `Claude Agent` adapters) from the
+ * ACP Registry so they can drive the generic ACP front door. The fetcher and
+ * install directory are injectable for deterministic testing.
+ *
+ * Registry source: https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+function normalizeRegistry(raw) {
+    if (typeof raw !== "object" || raw === null) {
+        throw new Error("ACP registry payload must be an object");
+    }
+    const agentsValue = raw.agents;
+    if (!Array.isArray(agentsValue)) {
+        throw new Error("ACP registry payload is missing an agents array");
+    }
+    const agents = [];
+    for (const entry of agentsValue) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const id = entry.id;
+        if (typeof id !== "string" || id.length === 0)
+            continue;
+        const agent = { id };
+        const name = entry.name;
+        if (typeof name === "string")
+            agent.name = name;
+        const version = entry.version;
+        if (typeof version === "string")
+            agent.version = version;
+        const description = entry.description;
+        if (typeof description === "string")
+            agent.description = description;
+        const distribution = entry.distribution;
+        if (typeof distribution === "object" && distribution !== null) {
+            agent.distribution = distribution;
+        }
+        agents.push(agent);
+    }
+    return { agents };
+}
+const defaultFetcher = async (url) => {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`ACP registry fetch failed: ${response.status}`);
+    }
+    return (await response.json());
+};
+export async function fetchAcpRegistry(fetcher = defaultFetcher, url = ACP_REGISTRY_URL) {
+    return normalizeRegistry(await fetcher(url));
+}
+export async function installAcpAdapters(options) {
+    if (options.agentIds.length === 0) {
+        throw new Error("at least one ACP agent id is required");
+    }
+    const registry = await fetchAcpRegistry(options.fetcher ?? defaultFetcher, options.url ?? ACP_REGISTRY_URL);
+    const byId = new Map(registry.agents.map((agent) => [agent.id, agent]));
+    const dir = resolve(options.installDir);
+    mkdirSync(dir, { recursive: true });
+    const installed = [];
+    for (const agentId of options.agentIds) {
+        const agent = byId.get(agentId);
+        if (agent === undefined) {
+            throw new Error(`ACP registry has no agent with id "${agentId}"`);
+        }
+        if (agent.distribution === undefined) {
+            throw new Error(`ACP agent "${agentId}" has no distribution metadata`);
+        }
+        const metadataPath = join(dir, `${agentId}.json`);
+        const record = {
+            id: agent.id,
+            name: agent.name ?? agent.id,
+            version: agent.version ?? "unknown",
+            distribution: agent.distribution,
+            installedAt: new Date().toISOString(),
+            metadataPath
+        };
+        writeFileSync(metadataPath, JSON.stringify(record, null, 2) + "\n");
+        installed.push(record);
+    }
+    return installed;
+}

package/dist/adapters/anthropic.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Anthropic Messages adapter. Claude Code speaks the Anthropic Messages API to
+ * whatever `ANTHROPIC_BASE_URL` points at, so to back it with a local model we
+ * translate `/v1/messages` (and `/v1/messages/count_tokens`, and the
+ * `/v1/models` discovery probe) to and from the gateway's OpenAI Chat
+ * Completions core. The pure translation functions are exported for testing;
+ * the request handler wires them to a `Backend` and returns a `Response` the
+ * server pipes straight to the client (JSON or SSE).
+ */
+import type { Backend } from "../backend.js";
+type AnthropicTextBlock = {
+    type: "text";
+    text: string;
+};
+type AnthropicImageBlock = {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+};
+type AnthropicToolUseBlock = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+};
+type AnthropicToolResultBlock = {
+    type: "tool_result";
+    tool_use_id: string;
+    content?: string | AnthropicContentBlock[];
+    is_error?: boolean;
+};
+type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicToolUseBlock | AnthropicToolResultBlock | {
+    type: string;
+    [key: string]: unknown;
+};
+type AnthropicMessage = {
+    role: "user" | "assistant";
+    content: string | AnthropicContentBlock[];
+};
+export type AnthropicRequest = {
+    model?: string;
+    system?: string | AnthropicTextBlock[];
+    messages: AnthropicMessage[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    tools?: Array<{
+        name: string;
+        description?: string;
+        input_schema?: unknown;
+    }>;
+    tool_choice?: {
+        type: "auto" | "any" | "tool";
+        name?: string;
+    };
+};
+type OpenAiToolCall = {
+    id?: string;
+    index?: number;
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+};
+type OpenAiDelta = {
+    content?: string | null;
+    tool_calls?: OpenAiToolCall[];
+};
+type OpenAiChoice = {
+    delta?: OpenAiDelta;
+    message?: {
+        content?: string | null;
+        tool_calls?: OpenAiToolCall[];
+    };
+    finish_reason?: string | null;
+};
+type OpenAiUsage = {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+};
+type OpenAiResponse = {
+    id?: string;
+    choices?: OpenAiChoice[];
+    usage?: OpenAiUsage;
+};
+/**
+ * Translate an Anthropic Messages request to an OpenAI Chat Completions body.
+ * The upstream model is always the backend's own model (Claude Code sends a
+ * `claude-*` id the local server would not recognise); the requested id is
+ * only echoed back in the response.
+ */
+export declare function anthropicToChat(body: AnthropicRequest, backendModel: string | undefined): Record<string, unknown>;
+export declare function mapStopReason(finishReason: string | null | undefined): string;
+export declare function chatToAnthropicMessage(openai: OpenAiResponse, model: string): Record<string, unknown>;
+export declare function openAiSseToAnthropic(upstream: ReadableStream<Uint8Array>, model: string): ReadableStream<Uint8Array>;
+export declare function countTokensEstimate(body: AnthropicRequest): number;
+export declare function handleAnthropicMessages(backend: Backend, body: AnthropicRequest, modelCallId?: string, signal?: AbortSignal): Promise<Response>;
+export declare function handleCountTokens(body: AnthropicRequest): Response;
+/**
+ * Anthropic-shaped `/v1/models` discovery response. Claude Code only adds
+ * models whose id begins with `claude` or `anthropic`, so the local model is
+ * surfaced under a `claude`-prefixed id with the real model id as its
+ * display name.
+ */
+export declare function anthropicModelsResponse(backendModel: string | undefined): Response;
+export {};