@automatalabs/acp-server 0.0.0 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// Keep stdout reserved for ACP before importing modules that may log during evaluation.
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    const manifest = await import("../package.json", { with: { type: "json" } }).then((module) => module.default);
+    process.stdout.write(`${manifest.version}\n`);
+    process.exit(0);
+}
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    process.stdout.write(`Usage:
+  agentprism-acp-server
+  agentprism-acp-server --http [--host <host>] [--port <port>] [--path <path>]
+
+With no transport flag, the server speaks ACP over stdio. --http starts both
+Streamable HTTP and WebSocket transports on one endpoint (default:
+http://127.0.0.1:7331/acp and ws://127.0.0.1:7331/acp).
+`);
+    process.exit(0);
+}
+console.log = console.error;
+console.info = console.error;
+console.warn = console.error;
+console.debug = console.error;
+process.on("unhandledRejection", (reason) => {
+    console.error("unhandledRejection:", reason);
+});
+const abortController = new AbortController();
+process.once("SIGTERM", () => abortController.abort(new Error("SIGTERM")));
+process.once("SIGINT", () => abortController.abort(new Error("SIGINT")));
+try {
+    const options = parseCliOptions(process.argv.slice(2));
+    if (options.mode === "stdio") {
+        const { serveAcpServer } = await import("./server.js");
+        await serveAcpServer({ signal: abortController.signal });
+    }
+    else {
+        const { listenAcpHttpServer } = await import("./http-server.js");
+        const server = await listenAcpHttpServer({
+            host: options.host,
+            port: options.port,
+            path: options.path,
+            signal: abortController.signal,
+        });
+        console.error(`ACP Streamable HTTP endpoint listening at ${server.url}`);
+        console.error(`ACP WebSocket endpoint listening at ${server.webSocketUrl}`);
+        await server.closed;
+    }
+}
+catch (error) {
+    if (!abortController.signal.aborted) {
+        console.error("ACP server failed:", error);
+        process.exitCode = 1;
+    }
+}
+function parseCliOptions(args) {
+    let http = false;
+    let host = "127.0.0.1";
+    let port = 7331;
+    let path = "/acp";
+    let networkOption = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--http") {
+            http = true;
+            continue;
+        }
+        if (argument === "--host" || argument === "--port" || argument === "--path") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                throw new Error(`${argument} requires a value`);
+            }
+            networkOption = true;
+            index += 1;
+            if (argument === "--host")
+                host = value;
+            if (argument === "--path")
+                path = value;
+            if (argument === "--port")
+                port = parsePort(value);
+            continue;
+        }
+        if (argument.startsWith("--host=")) {
+            host = argument.slice("--host=".length);
+            networkOption = true;
+            continue;
+        }
+        if (argument.startsWith("--port=")) {
+            port = parsePort(argument.slice("--port=".length));
+            networkOption = true;
+            continue;
+        }
+        if (argument.startsWith("--path=")) {
+            path = argument.slice("--path=".length);
+            networkOption = true;
+            continue;
+        }
+        throw new Error(`unknown argument ${JSON.stringify(argument)}; run with --help for usage`);
+    }
+    if (!http) {
+        if (networkOption)
+            throw new Error("--host, --port, and --path require --http");
+        return { mode: "stdio" };
+    }
+    return { mode: "http", host, port, path };
+}
+function parsePort(value) {
+    if (!/^\d+$/.test(value))
+        throw new Error("--port must be an integer from 0 through 65535");
+    const port = Number(value);
+    if (!Number.isSafeInteger(port) || port < 0 || port > 65_535) {
+        throw new Error("--port must be an integer from 0 through 65535");
+    }
+    return port;
+}
+export {};

package/dist/http-server.d.ts

@@ -0,0 +1,41 @@
+import type { CustomBackendConfig } from "@automatalabs/acp-agents";
+import { type BackendTarget } from "./backends.js";
+export declare const DEFAULT_ACP_HTTP_HOST: "127.0.0.1";
+export declare const DEFAULT_ACP_HTTP_PORT: 7331;
+export declare const DEFAULT_ACP_HTTP_PATH: "/acp";
+export interface ListenAcpHttpServerOptions {
+    /** Interface to bind. Defaults to loopback. */
+    host?: string;
+    /** TCP port to bind. Pass zero to allocate an ephemeral port. */
+    port?: number;
+    /** Exact HTTP and WebSocket endpoint path. Defaults to /acp. */
+    path?: string;
+    /** Maximum JSON request body accepted by the Streamable HTTP adapter. */
+    maxRequestBodyBytes?: number;
+    /** Programmatic custom backends merged over AGENTPRISM_BACKENDS. */
+    backends?: Record<string, CustomBackendConfig>;
+    /** Exact backend targets, primarily for embedding and deterministic tests. */
+    targets?: readonly BackendTarget[];
+    /** Package version advertised on discovery connections. */
+    version?: string;
+    /** Stops the listener and every active transport connection when aborted. */
+    signal?: AbortSignal;
+}
+export interface AcpHttpServerHandle {
+    readonly host: string;
+    readonly port: number;
+    readonly path: string;
+    readonly url: string;
+    readonly webSocketUrl: string;
+    readonly closed: Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Listen for ACP V1 Streamable HTTP and WebSocket connections on one endpoint.
+ *
+ * Each accepted transport connection receives an independent connection-pinned router. The
+ * experimental SDK surface used here is the official ACP HTTP/WebSocket transport implementation;
+ * the router protocol carried over it remains ACP V1.
+ */
+export declare function listenAcpHttpServer(options?: ListenAcpHttpServerOptions): Promise<AcpHttpServerHandle>;
+//# sourceMappingURL=http-server.d.ts.map

package/dist/http-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-server.d.ts","sourceRoot":"","sources":["../src/http-server.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAG1E,eAAO,MAAM,qBAAqB,EAAG,WAAoB,CAAC;AAC1D,eAAO,MAAM,qBAAqB,EAAG,IAAa,CAAC;AACnD,eAAO,MAAM,qBAAqB,EAAG,MAAe,CAAC;AAErD,MAAM,WAAW,0BAA0B;IACzC,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC/C,8EAA8E;IAC9E,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACnC,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,mBAAmB,CAAC,CA8H9B"}

package/dist/http-server.js

@@ -0,0 +1,200 @@
+import { createServer } from "node:http";
+import { AcpServer } from "@agentclientprotocol/sdk/experimental/server";
+import { createNodeHttpHandler, createNodeWebSocketUpgradeHandler, } from "@agentclientprotocol/sdk/experimental/node";
+import { WebSocketServer } from "ws";
+import { resolveBackendTargets } from "./backends.js";
+import { serveAcpServer } from "./server.js";
+export const DEFAULT_ACP_HTTP_HOST = "127.0.0.1";
+export const DEFAULT_ACP_HTTP_PORT = 7331;
+export const DEFAULT_ACP_HTTP_PATH = "/acp";
+/**
+ * Listen for ACP V1 Streamable HTTP and WebSocket connections on one endpoint.
+ *
+ * Each accepted transport connection receives an independent connection-pinned router. The
+ * experimental SDK surface used here is the official ACP HTTP/WebSocket transport implementation;
+ * the router protocol carried over it remains ACP V1.
+ */
+export async function listenAcpHttpServer(options = {}) {
+    options.signal?.throwIfAborted();
+    const host = requireHost(options.host ?? DEFAULT_ACP_HTTP_HOST);
+    const port = requirePort(options.port ?? DEFAULT_ACP_HTTP_PORT);
+    const path = requirePath(options.path ?? DEFAULT_ACP_HTTP_PATH);
+    const targets = options.targets
+        ? [...options.targets]
+        : resolveBackendTargets({ backends: options.backends });
+    requireUniqueTargets(targets);
+    const transportServer = new AcpServer({
+        createAgent: () => ({
+            connect(stream) {
+                // AcpServer exposes a batch-capable transport stream so it can also host draft ACP V2.
+                // This router rejects non-V1 initialize requests, after which the SDK guarantees that V1
+                // connections contain individual messages only.
+                const closed = serveAcpServer({
+                    stream: stream,
+                    targets,
+                    ...(options.version === undefined ? {} : { version: options.version }),
+                    ...(options.signal === undefined ? {} : { signal: options.signal }),
+                }).catch((error) => {
+                    // One failed client connection must not become a process-level unhandled rejection or
+                    // stop the shared listener. AcpServer observes this lifecycle promise to tear down only
+                    // the affected transport connection.
+                    console.error("ACP network connection failed:", error);
+                });
+                return { closed };
+            },
+        }),
+    });
+    const httpHandler = createNodeHttpHandler(transportServer, {
+        ...(options.maxRequestBodyBytes === undefined
+            ? {}
+            : { maxRequestBodyBytes: options.maxRequestBodyBytes }),
+    });
+    const webSocketServer = new WebSocketServer({ noServer: true });
+    const upgradeHandler = createNodeWebSocketUpgradeHandler(transportServer, webSocketServer);
+    const httpServer = createServer((request, response) => {
+        if (!isAcpPath(request, path)) {
+            notFound(response);
+            return;
+        }
+        httpHandler(request, response);
+    });
+    httpServer.on("upgrade", (request, socket, head) => {
+        if (!isAcpPath(request, path)) {
+            socket.destroy();
+            return;
+        }
+        upgradeHandler(request, socket, head);
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            httpServer.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            httpServer.off("error", onError);
+            resolve();
+        };
+        httpServer.once("error", onError);
+        httpServer.once("listening", onListening);
+        httpServer.listen(port, host);
+    });
+    const address = httpServer.address();
+    if (!isAddressInfo(address)) {
+        await closeNodeServer(httpServer).catch(() => undefined);
+        await transportServer.close();
+        throw new Error("ACP HTTP server did not bind to a TCP address");
+    }
+    let resolveClosed;
+    let rejectClosed;
+    const closed = new Promise((resolve, reject) => {
+        resolveClosed = resolve;
+        rejectClosed = reject;
+    });
+    closed.catch(() => { });
+    let closePromise;
+    let runtimeError;
+    const close = () => {
+        closePromise ??= (async () => {
+            options.signal?.removeEventListener("abort", onAbort);
+            const stopListening = closeNodeServer(httpServer);
+            const results = await Promise.allSettled([
+                transportServer.close(),
+                stopListening,
+            ]);
+            for (const client of webSocketServer.clients)
+                client.terminate();
+            await closeWebSocketServer(webSocketServer).catch((error) => {
+                results.push({ status: "rejected", reason: error });
+            });
+            const errors = results
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (runtimeError !== undefined)
+                errors.unshift(runtimeError);
+            if (errors.length > 0)
+                throw new AggregateError(errors, "Failed to close ACP HTTP server");
+        })();
+        closePromise.then(resolveClosed, rejectClosed);
+        return closePromise;
+    };
+    const onAbort = () => {
+        void close();
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    httpServer.on("error", (error) => {
+        runtimeError = error;
+        void close();
+    });
+    if (options.signal?.aborted)
+        void close();
+    const endpointHost = formatUrlHost(host);
+    return {
+        host,
+        port: address.port,
+        path,
+        url: `http://${endpointHost}:${address.port}${path}`,
+        webSocketUrl: `ws://${endpointHost}:${address.port}${path}`,
+        closed,
+        close,
+    };
+}
+function requireHost(value) {
+    const host = value.trim();
+    if (host.length === 0)
+        throw new TypeError("ACP HTTP host must not be empty");
+    return host;
+}
+function requirePort(value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 65_535) {
+        throw new RangeError("ACP HTTP port must be an integer from 0 through 65535");
+    }
+    return value;
+}
+function requirePath(value) {
+    if (!value.startsWith("/") || value.includes("?") || value.includes("#")) {
+        throw new TypeError("ACP HTTP path must be an absolute path without a query or fragment");
+    }
+    const parsed = new URL(value, "http://localhost");
+    if (parsed.pathname !== value) {
+        throw new TypeError("ACP HTTP path must be a canonical URL path");
+    }
+    return value;
+}
+function requireUniqueTargets(targets) {
+    const ids = new Set(targets.map((target) => target.id));
+    if (ids.size !== targets.length)
+        throw new Error("ACP backend target ids must be unique");
+}
+function isAcpPath(request, path) {
+    return new URL(request.url ?? "/", "http://localhost").pathname === path;
+}
+function notFound(response) {
+    response.writeHead(404, { "Content-Type": "text/plain" });
+    response.end("Not Found");
+}
+function isAddressInfo(value) {
+    return value !== null && typeof value === "object";
+}
+function formatUrlHost(host) {
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function closeNodeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+function closeWebSocketServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { serveAcpServer } from "./server.js";
+export type { ServeAcpServerOptions } from "./server.js";
+export { DEFAULT_ACP_HTTP_HOST, DEFAULT_ACP_HTTP_PATH, DEFAULT_ACP_HTTP_PORT, listenAcpHttpServer, } from "./http-server.js";
+export type { AcpHttpServerHandle, ListenAcpHttpServerOptions } from "./http-server.js";
+export { resolveBackendTargets } from "./backends.js";
+export type { BackendTarget, ResolveBackendTargetsOptions } from "./backends.js";
+export { ACP_BACKENDS_PROBE_METHOD, ACP_ROUTER_META_NAMESPACE, ACP_ROUTER_VERSION, assertSessionBackend, discoveryInitializeResponse, mergeBackendInitializeResponse, parseProbeBackendsParams, parseRouterInitialize, } from "./protocol.js";
+export type { BackendProbe, ParsedRouterInitialize, ProbeBackendsParams, ProbeBackendsResult, RouterSelection, } from "./protocol.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAExF,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAEjF,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,EAClB,oBAAoB,EACpB,2BAA2B,EAC3B,8BAA8B,EAC9B,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,YAAY,EACZ,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,GAChB,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { serveAcpServer } from "./server.js";
+export { DEFAULT_ACP_HTTP_HOST, DEFAULT_ACP_HTTP_PATH, DEFAULT_ACP_HTTP_PORT, listenAcpHttpServer, } from "./http-server.js";
+export { resolveBackendTargets } from "./backends.js";
+export { ACP_BACKENDS_PROBE_METHOD, ACP_ROUTER_META_NAMESPACE, ACP_ROUTER_VERSION, assertSessionBackend, discoveryInitializeResponse, mergeBackendInitializeResponse, parseProbeBackendsParams, parseRouterInitialize, } from "./protocol.js";

package/dist/protocol.d.ts

@@ -0,0 +1,54 @@
+import { type AgentCapabilities, type Implementation, type InitializeRequest, type InitializeResponse, type McpServer, type SessionConfigOption, type SessionModeState } from "@agentclientprotocol/sdk";
+export declare const ACP_ROUTER_META_NAMESPACE: "@automatalabs/agentprism";
+export declare const ACP_ROUTER_VERSION: 1;
+export declare const ACP_BACKENDS_PROBE_METHOD: "_automatalabs/agentprism/backends/probe";
+export type RouterSelection = {
+    readonly version: 1;
+    readonly mode: "discovery";
+} | {
+    readonly version: 1;
+    readonly mode: "backend";
+    readonly backend: string;
+};
+export interface ParsedRouterInitialize {
+    readonly request: InitializeRequest;
+    readonly selection: RouterSelection;
+}
+export interface ProbeBackendsParams {
+    cwd: string;
+    additionalDirectories?: string[];
+    mcpServers: McpServer[];
+    _meta?: Record<string, unknown> | null;
+}
+export type BackendProbe = {
+    id: string;
+    name: string;
+    available: true;
+    agentInfo?: Implementation | null;
+    agentCapabilities?: AgentCapabilities;
+    modes?: SessionModeState | null;
+    configOptions?: SessionConfigOption[] | null;
+    initializeMeta?: Record<string, unknown> | null;
+    sessionMeta?: Record<string, unknown> | null;
+} | {
+    id: string;
+    name: string;
+    available: false;
+    stage: "initialize" | "session/new";
+    error: string;
+};
+export interface ProbeBackendsResult {
+    backends: BackendProbe[];
+}
+/** Validate the ACP and AgentPrism portions of the connection's first initialize request. */
+export declare function parseRouterInitialize(params: unknown): ParsedRouterInitialize;
+/** Validate the redundant backend assertion required on every session/new request. */
+export declare function assertSessionBackend(params: unknown, selectedBackend: string): void;
+/** Validate and copy the temporary session inputs accepted by the discovery probe. */
+export declare function parseProbeBackendsParams(params: unknown): ProbeBackendsParams;
+/** Router-owned initialize response for a discovery connection. */
+export declare function discoveryInitializeResponse(version: string): InitializeResponse;
+/** Add the proxy's negotiated capability without changing the selected backend's response fields. */
+export declare function mergeBackendInitializeResponse(response: InitializeResponse, backend: string): InitializeResponse;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACtB,MAAM,0BAA0B,CAAC;AAElC,eAAO,MAAM,yBAAyB,EAAG,0BAAmC,CAAC;AAC7E,eAAO,MAAM,kBAAkB,EAAG,CAAU,CAAC;AAC7C,eAAO,MAAM,yBAAyB,EAAG,yCAAkD,CAAC;AAI5F,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;CACrC;AAED,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACxC;AAED,MAAM,MAAM,YAAY,GACpB;IACE,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IAClC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,KAAK,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChC,aAAa,CAAC,EAAE,mBAAmB,EAAE,GAAG,IAAI,CAAC;IAC7C,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9C,GACD;IACE,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,YAAY,GAAG,aAAa,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED,6FAA6F;AAC7F,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,GAAG,sBAAsB,CA+C7E;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAanF;AAED,sFAAsF;AACtF,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,mBAAmB,CA0B7E;AAED,mEAAmE;AACnE,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAoB/E;AAED,qGAAqG;AACrG,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,MAAM,GACd,kBAAkB,CAsBpB;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}

package/dist/protocol.js

@@ -0,0 +1,138 @@
+import { isAbsolute } from "node:path";
+import { PROTOCOL_VERSION, RequestError, } from "@agentclientprotocol/sdk";
+export const ACP_ROUTER_META_NAMESPACE = "@automatalabs/agentprism";
+export const ACP_ROUTER_VERSION = 1;
+export const ACP_BACKENDS_PROBE_METHOD = "_automatalabs/agentprism/backends/probe";
+const BACKEND_ID_PATTERN = /^[a-z][a-z0-9._-]*$/;
+/** Validate the ACP and AgentPrism portions of the connection's first initialize request. */
+export function parseRouterInitialize(params) {
+    const request = requireRecord(params, "initialize params");
+    if (request.protocolVersion !== PROTOCOL_VERSION) {
+        throw invalidParams(`AgentPrism ACP server supports protocol version ${PROTOCOL_VERSION}`);
+    }
+    const clientCapabilities = requireRecord(request.clientCapabilities, "clientCapabilities");
+    const capabilityMeta = requireRecord(clientCapabilities._meta, "clientCapabilities._meta");
+    const capabilityNamespace = requireRecord(capabilityMeta[ACP_ROUTER_META_NAMESPACE], `clientCapabilities._meta[${JSON.stringify(ACP_ROUTER_META_NAMESPACE)}]`);
+    const capability = requireRecord(capabilityNamespace.acpRouter, "acpRouter client capability");
+    if (!Array.isArray(capability.versions) ||
+        !capability.versions.every((value) => Number.isSafeInteger(value)) ||
+        !capability.versions.includes(ACP_ROUTER_VERSION)) {
+        throw invalidParams(`client must advertise AgentPrism ACP router version ${ACP_ROUTER_VERSION}`);
+    }
+    const requestMeta = requireRecord(request._meta, "initialize._meta");
+    const requestNamespace = requireRecord(requestMeta[ACP_ROUTER_META_NAMESPACE], `initialize._meta[${JSON.stringify(ACP_ROUTER_META_NAMESPACE)}]`);
+    const selection = requireRecord(requestNamespace.acpRouter, "initialize acpRouter selection");
+    if (selection.version !== ACP_ROUTER_VERSION) {
+        throw invalidParams(`initialize must select AgentPrism ACP router version ${ACP_ROUTER_VERSION}`);
+    }
+    if (selection.mode === "discovery") {
+        return { request, selection: { version: ACP_ROUTER_VERSION, mode: "discovery" } };
+    }
+    if (selection.mode !== "backend") {
+        throw invalidParams('initialize acpRouter mode must be "discovery" or "backend"');
+    }
+    if (typeof selection.backend !== "string" || !BACKEND_ID_PATTERN.test(selection.backend)) {
+        throw invalidParams(`initialize acpRouter backend must match ${BACKEND_ID_PATTERN}`);
+    }
+    return {
+        request,
+        selection: {
+            version: ACP_ROUTER_VERSION,
+            mode: "backend",
+            backend: selection.backend,
+        },
+    };
+}
+/** Validate the redundant backend assertion required on every session/new request. */
+export function assertSessionBackend(params, selectedBackend) {
+    const request = requireRecord(params, "session/new params");
+    const meta = requireRecord(request._meta, "session/new._meta");
+    const namespace = requireRecord(meta[ACP_ROUTER_META_NAMESPACE], `session/new._meta[${JSON.stringify(ACP_ROUTER_META_NAMESPACE)}]`);
+    const selection = requireRecord(namespace.acpRouter, "session/new acpRouter selection");
+    if (selection.version !== ACP_ROUTER_VERSION || selection.backend !== selectedBackend) {
+        throw invalidParams(`session/new must select router version ${ACP_ROUTER_VERSION} and backend ${JSON.stringify(selectedBackend)}`);
+    }
+}
+/** Validate and copy the temporary session inputs accepted by the discovery probe. */
+export function parseProbeBackendsParams(params) {
+    const value = requireRecord(params, "probe params");
+    if (typeof value.cwd !== "string" || !isAbsolute(value.cwd)) {
+        throw invalidParams("probe cwd must be an absolute path");
+    }
+    if (!Array.isArray(value.mcpServers)) {
+        throw invalidParams("probe mcpServers must be an array");
+    }
+    if (value.additionalDirectories !== undefined &&
+        (!Array.isArray(value.additionalDirectories) ||
+            !value.additionalDirectories.every((directory) => typeof directory === "string" && isAbsolute(directory)))) {
+        throw invalidParams("probe additionalDirectories must contain only absolute paths");
+    }
+    if (value._meta !== undefined && value._meta !== null && !isRecord(value._meta)) {
+        throw invalidParams("probe _meta must be an object or null");
+    }
+    return {
+        cwd: value.cwd,
+        mcpServers: value.mcpServers,
+        ...(value.additionalDirectories === undefined
+            ? {}
+            : { additionalDirectories: [...value.additionalDirectories] }),
+        ...(value._meta === undefined ? {} : { _meta: value._meta }),
+    };
+}
+/** Router-owned initialize response for a discovery connection. */
+export function discoveryInitializeResponse(version) {
+    return {
+        protocolVersion: PROTOCOL_VERSION,
+        agentInfo: {
+            name: "agentprism-acp-server",
+            title: "AgentPrism ACP Server",
+            version,
+        },
+        agentCapabilities: {
+            _meta: {
+                [ACP_ROUTER_META_NAMESPACE]: {
+                    acpRouter: {
+                        version: ACP_ROUTER_VERSION,
+                        mode: "discovery",
+                        methods: { probeBackends: ACP_BACKENDS_PROBE_METHOD },
+                    },
+                },
+            },
+        },
+    };
+}
+/** Add the proxy's negotiated capability without changing the selected backend's response fields. */
+export function mergeBackendInitializeResponse(response, backend) {
+    const capabilities = response.agentCapabilities ?? {};
+    const capabilityMeta = capabilities._meta ?? {};
+    const namespaceValue = capabilityMeta[ACP_ROUTER_META_NAMESPACE];
+    const namespace = isRecord(namespaceValue) ? namespaceValue : {};
+    return {
+        ...response,
+        agentCapabilities: {
+            ...capabilities,
+            _meta: {
+                ...capabilityMeta,
+                [ACP_ROUTER_META_NAMESPACE]: {
+                    ...namespace,
+                    acpRouter: {
+                        version: ACP_ROUTER_VERSION,
+                        mode: "backend",
+                        backend,
+                    },
+                },
+            },
+        },
+    };
+}
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireRecord(value, field) {
+    if (!isRecord(value))
+        throw invalidParams(`${field} must be an object`);
+    return value;
+}
+function invalidParams(message) {
+    return RequestError.invalidParams(undefined, message);
+}

package/dist/raw-rpc.d.ts

@@ -0,0 +1,30 @@
+import { type AnyNotification, type AnyRequest, type Result, type Stream } from "@agentclientprotocol/sdk";
+export interface RawRpcHandler {
+    request(message: AnyRequest, signal: AbortSignal): Promise<Result<unknown>> | Result<unknown>;
+    notification(message: AnyNotification): Promise<void> | void;
+}
+/** Minimal bidirectional JSON-RPC peer used only by router-owned discovery connections. */
+export declare class RawRpcPeer {
+    private readonly handler;
+    private readonly reader;
+    private readonly writer;
+    private readonly pending;
+    private readonly incoming;
+    private nextRequestId;
+    private writeQueue;
+    private closeReason;
+    readonly closed: Promise<void>;
+    constructor(stream: Stream, handler: RawRpcHandler);
+    request(method: string, params?: unknown, signal?: AbortSignal): Promise<Result<unknown>>;
+    notify(method: string, params?: unknown): Promise<void>;
+    close(reason?: unknown): Promise<void>;
+    private write;
+    private receive;
+    private dispatchRequest;
+}
+export declare function errorResponse(error: unknown): {
+    code: number;
+    message: string;
+    data?: unknown;
+};
+//# sourceMappingURL=raw-rpc.d.ts.map

package/dist/raw-rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-rpc.d.ts","sourceRoot":"","sources":["../src/raw-rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,UAAU,EAEf,KAAK,MAAM,EACX,KAAK,MAAM,EACZ,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9F,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC9D;AAOD,2FAA2F;AAC3F,qBAAa,UAAU;IAUO,OAAO,CAAC,QAAQ,CAAC,OAAO;IATpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;IACjE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAChE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyC;IAClE,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,WAAW,CAAU;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;gBAEnB,MAAM,EAAE,MAAM,EAAmB,OAAO,EAAE,aAAa;IAanE,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAuBzF,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAQjD,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5C,OAAO,CAAC,KAAK;YAMC,OAAO;IA6BrB,OAAO,CAAC,eAAe;CAUxB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAG/F"}