@botbotgo/agent-harness 0.0.308 → 0.0.310

package/dist/protocol/acp/server.d.ts

@@ -0,0 +1,116 @@
+import type { ArtifactRecord, HarnessEvent, HarnessStreamItem, RequestRecord, RequestOptions, SessionRecord } from "../../contracts/types.js";
+import type { AgentHarnessRuntime } from "../../runtime/harness.js";
+import { getApproval, type PublicRequestListeners } from "../../api.js";
+type JsonRpcId = string | number | null;
+export type AcpJsonRpcRequest = {
+    jsonrpc?: "2.0";
+    id?: JsonRpcId;
+    method: string;
+    params?: unknown;
+};
+export type AcpJsonRpcError = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+export type AcpJsonRpcSuccess = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: unknown;
+};
+export type AcpJsonRpcResponse = AcpJsonRpcError | AcpJsonRpcSuccess;
+export type AcpSessionRecord = SessionRecord;
+export type AcpRequestRecord = RequestRecord;
+export type AcpApproval = Awaited<ReturnType<typeof getApproval>> extends infer T ? Exclude<T, null> : never;
+export type AcpArtifact = ArtifactRecord & {
+    content?: unknown;
+};
+export type AcpRequestParams = Omit<Extract<RequestOptions, {
+    input: unknown;
+}>, "listeners"> & {
+    sessionId?: string;
+    streamId?: string;
+    listeners?: PublicRequestListeners;
+};
+export type AcpServerCapabilities = {
+    sessions: {
+        list: true;
+        get: true;
+        summaries: true;
+    };
+    requests: {
+        submit: true;
+        list: true;
+        get: true;
+        plan: {
+            get: true;
+        };
+        cancel: true;
+        stream: true;
+        trace: {
+            list: true;
+        };
+    };
+    approvals: {
+        list: true;
+        get: true;
+        resolve: true;
+    };
+    artifacts: {
+        list: true;
+        read: true;
+    };
+    events: {
+        subscribe: true;
+        list: true;
+    };
+    runtime: {
+        health: true;
+        overview: true;
+    };
+};
+export type AcpEventNotification = {
+    jsonrpc: "2.0";
+    method: "events.runtime";
+    params: {
+        event: {
+            eventId: string;
+            eventType: string;
+            timestamp: string;
+            sessionId: string;
+            requestId: string;
+            sequence: number;
+            source: HarnessEvent["source"];
+            payload: Record<string, unknown>;
+        };
+    };
+};
+export type AcpStreamNotification = {
+    jsonrpc: "2.0";
+    method: "requests.stream";
+    params: {
+        streamId: string;
+        item: HarnessStreamItem;
+    };
+};
+export type AcpNotification = AcpEventNotification | AcpStreamNotification;
+export declare class AgentHarnessAcpServer {
+    private readonly runtime;
+    private readonly listeners;
+    constructor(runtime: AgentHarnessRuntime);
+    capabilities(): AcpServerCapabilities;
+    subscribe(listener: (notification: AcpNotification) => void): () => void;
+    handle(request: AcpJsonRpcRequest): Promise<AcpJsonRpcResponse | undefined>;
+    private methodExists;
+    private emitNotification;
+    private dispatch;
+    private submitStreamingRequest;
+}
+export declare function createAcpServer(runtime: AgentHarnessRuntime): AgentHarnessAcpServer;
+export { createAcpStdioClient } from "./client.js";
+export { createAcpHttpClient } from "./client.js";
+export type { AcpHttpClient, AcpHttpClientOptions, AcpStdioClient, AcpStdioClientOptions } from "./client.js";

package/dist/protocol/acp/server.js

@@ -0,0 +1,310 @@
+import { cancelRequest, getApproval, getArtifact, getHealth, getOperatorOverview, getRequestPlanState, getRequest, getSession, listApprovals, listRequestEvents, listRequestArtifacts, listRequestTraceItems, listRequests, listSessionSummaries, listSessions, request, resolveApproval, } from "../../api.js";
+const CAPABILITIES = {
+    sessions: { list: true, get: true, summaries: true },
+    requests: { submit: true, list: true, get: true, plan: { get: true }, cancel: true, stream: true, trace: { list: true } },
+    approvals: { list: true, get: true, resolve: true },
+    artifacts: { list: true, read: true },
+    events: { subscribe: true, list: true },
+    runtime: { health: true, overview: true },
+};
+function asObject(value, method) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${method} requires an object params payload.`);
+    }
+    return value;
+}
+function readOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function readRequiredString(value, field, method) {
+    const normalized = readOptionalString(value);
+    if (!normalized) {
+        throw new Error(`${method} requires ${field}.`);
+    }
+    return normalized;
+}
+function toNotification(event) {
+    return {
+        jsonrpc: "2.0",
+        method: "events.runtime",
+        params: {
+            event: {
+                eventId: event.eventId,
+                eventType: event.eventType,
+                timestamp: event.timestamp,
+                sessionId: event.sessionId,
+                requestId: event.requestId,
+                sequence: event.sequence,
+                source: event.source,
+                payload: event.payload,
+            },
+        },
+    };
+}
+function toStreamNotification(streamId, item) {
+    return {
+        jsonrpc: "2.0",
+        method: "requests.stream",
+        params: {
+            streamId,
+            item,
+        },
+    };
+}
+async function readArtifactContent(runtime, params) {
+    const method = "artifacts.read";
+    const sessionId = readRequiredString(params.sessionId, "sessionId", method);
+    const requestId = readRequiredString(params.requestId, "requestId", method);
+    const artifactPath = readRequiredString(params.artifactPath, "artifactPath", method);
+    const listing = await listRequestArtifacts(runtime, { sessionId, requestId });
+    const artifact = listing.items.find((item) => item.path === artifactPath);
+    if (!artifact) {
+        throw new Error(`Artifact not found for ${requestId}: ${artifactPath}`);
+    }
+    return {
+        ...artifact,
+        content: await getArtifact(runtime, { sessionId, requestId, artifactPath }),
+    };
+}
+export class AgentHarnessAcpServer {
+    runtime;
+    listeners = new Set();
+    constructor(runtime) {
+        this.runtime = runtime;
+        this.runtime.subscribe((event) => {
+            this.emitNotification(toNotification(event));
+        });
+    }
+    capabilities() {
+        return CAPABILITIES;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    async handle(request) {
+        const id = request.id ?? null;
+        if (!request || typeof request !== "object" || typeof request.method !== "string" || request.method.trim().length === 0) {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32600,
+                    message: "Invalid JSON-RPC request.",
+                },
+            };
+        }
+        if (request.jsonrpc !== undefined && request.jsonrpc !== "2.0") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32600,
+                    message: "Only JSON-RPC 2.0 requests are supported.",
+                },
+            };
+        }
+        try {
+            const result = await this.dispatch(request.method, request.params);
+            if (request.id === undefined) {
+                return undefined;
+            }
+            return {
+                jsonrpc: "2.0",
+                id,
+                result,
+            };
+        }
+        catch (error) {
+            if (request.id === undefined) {
+                return undefined;
+            }
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: this.methodExists(request.method) ? -32602 : -32601,
+                    message: error instanceof Error ? error.message : "ACP request failed.",
+                },
+            };
+        }
+    }
+    methodExists(method) {
+        return new Set([
+            "capabilities.get",
+            "sessions.list",
+            "sessions.get",
+            "sessions.summaries",
+            "requests.submit",
+            "requests.list",
+            "requests.get",
+            "requests.plan.get",
+            "requests.cancel",
+            "requests.stream",
+            "requests.trace.list",
+            "approvals.list",
+            "approvals.get",
+            "approvals.resolve",
+            "artifacts.list",
+            "artifacts.read",
+            "events.list",
+            "runtime.health",
+            "runtime.overview",
+        ]).has(method);
+    }
+    emitNotification(notification) {
+        for (const listener of Array.from(this.listeners)) {
+            try {
+                listener(notification);
+            }
+            catch {
+                // Ignore subscriber failures so one ACP consumer cannot tear down the server.
+            }
+        }
+    }
+    async dispatch(method, params) {
+        switch (method) {
+            case "capabilities.get":
+                return this.capabilities();
+            case "sessions.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listSessions(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                });
+            }
+            case "sessions.get": {
+                const payload = asObject(params, method);
+                return getSession(this.runtime, readRequiredString(payload.sessionId, "sessionId", method));
+            }
+            case "sessions.summaries": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listSessionSummaries(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                });
+            }
+            case "requests.submit": {
+                const payload = asObject(params, method);
+                if (readOptionalString(payload.streamId)) {
+                    return this.submitStreamingRequest(payload, method);
+                }
+                return request(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                    input: payload.input,
+                    invocation: payload.invocation,
+                    listeners: payload.listeners,
+                    priority: typeof payload.priority === "number" ? payload.priority : undefined,
+                    sessionId: readOptionalString(payload.sessionId),
+                });
+            }
+            case "requests.cancel": {
+                const payload = asObject(params, method);
+                return cancelRequest(this.runtime, {
+                    requestId: readRequiredString(payload.requestId, "requestId", method),
+                    reason: readOptionalString(payload.reason),
+                });
+            }
+            case "requests.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listRequests(this.runtime, {
+                    agentId: readOptionalString(payload.agentId),
+                    sessionId: readOptionalString(payload.sessionId),
+                    state: payload.state,
+                });
+            }
+            case "requests.get": {
+                const payload = asObject(params, method);
+                return getRequest(this.runtime, readRequiredString(payload.requestId, "requestId", method));
+            }
+            case "requests.plan.get": {
+                const payload = asObject(params, method);
+                return getRequestPlanState(this.runtime, {
+                    sessionId: readRequiredString(payload.sessionId, "sessionId", method),
+                    requestId: readRequiredString(payload.requestId, "requestId", method),
+                });
+            }
+            case "requests.trace.list": {
+                const payload = asObject(params, method);
+                return listRequestTraceItems(this.runtime, {
+                    sessionId: readRequiredString(payload.sessionId, "sessionId", method),
+                    requestId: readRequiredString(payload.requestId, "requestId", method),
+                });
+            }
+            case "approvals.list": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return listApprovals(this.runtime, {
+                    status: payload.status,
+                    sessionId: readOptionalString(payload.sessionId),
+                    requestId: readOptionalString(payload.requestId),
+                });
+            }
+            case "approvals.get": {
+                const payload = asObject(params, method);
+                return getApproval(this.runtime, readRequiredString(payload.approvalId, "approvalId", method));
+            }
+            case "approvals.resolve": {
+                const payload = asObject(params, method);
+                return resolveApproval(this.runtime, {
+                    approvalId: readRequiredString(payload.approvalId, "approvalId", method),
+                    decision: payload.decision,
+                    editedInput: payload.editedInput,
+                    requestId: readOptionalString(payload.requestId),
+                    sessionId: readOptionalString(payload.sessionId),
+                });
+            }
+            case "artifacts.list": {
+                const payload = asObject(params, method);
+                return listRequestArtifacts(this.runtime, {
+                    sessionId: readRequiredString(payload.sessionId, "sessionId", method),
+                    requestId: readRequiredString(payload.requestId, "requestId", method),
+                });
+            }
+            case "artifacts.read":
+                return readArtifactContent(this.runtime, asObject(params, method));
+            case "events.list": {
+                const payload = asObject(params, method);
+                return listRequestEvents(this.runtime, {
+                    sessionId: readRequiredString(payload.sessionId, "sessionId", method),
+                    requestId: readRequiredString(payload.requestId, "requestId", method),
+                });
+            }
+            case "runtime.health":
+                return getHealth(this.runtime);
+            case "runtime.overview": {
+                const payload = params === undefined ? {} : asObject(params, method);
+                return getOperatorOverview(this.runtime, {
+                    limit: typeof payload.limit === "number" ? payload.limit : undefined,
+                });
+            }
+            default:
+                throw new Error(`Unknown ACP method: ${method}`);
+        }
+    }
+    async submitStreamingRequest(payload, method) {
+        const streamId = readRequiredString(payload.streamId, "streamId", method);
+        let finalResult;
+        for await (const item of this.runtime.streamEvents({
+            agentId: readOptionalString(payload.agentId),
+            input: payload.input,
+            invocation: payload.invocation,
+            listeners: payload.listeners,
+            priority: typeof payload.priority === "number" ? payload.priority : undefined,
+            sessionId: readOptionalString(payload.sessionId),
+        })) {
+            this.emitNotification(toStreamNotification(streamId, item));
+            if (item.type === "result") {
+                finalResult = item.result;
+            }
+        }
+        if (finalResult) {
+            return finalResult;
+        }
+        throw new Error("ACP streaming request completed without a terminal result.");
+    }
+}
+export function createAcpServer(runtime) {
+    return new AgentHarnessAcpServer(runtime);
+}
+export { createAcpStdioClient } from "./client.js";
+export { createAcpHttpClient } from "./client.js";

package/dist/protocol/ag-ui/http.js

@@ -1,6 +1,6 @@
 import { createServer } from "node:http";
 import { createPersistentId } from "../../utils/id.js";
-import { createUpstreamTimelineReducer } from "../../upstream-events.js";
+import { createUpstreamTimelineReducer } from "../../projections/upstream-events.js";
 function normalizePath(value, fallback) {
     const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
     return source.startsWith("/") ? source : `/${source}`;

package/dist/protocol/mcp/server.d.ts

@@ -0,0 +1,76 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApprovalRecord, ArtifactListing, CompiledTool, HarnessEvent, ParsedToolObject, RequestRecord, RequestResult, RequestState, RequestSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, SessionRecord, SessionSummary } from "../../contracts/types.js";
+export type ToolMcpServerOptions = {
+    agentId: string;
+    serverInfo?: {
+        name?: string;
+        version?: string;
+    };
+    includeToolNames?: string[];
+};
+export type ToolMcpServerTool = {
+    compiledTool: CompiledTool;
+    resolvedTool: unknown;
+    sourceTool?: ParsedToolObject;
+};
+export type RuntimeMcpServerOptions = {
+    serverInfo?: {
+        name?: string;
+        version?: string;
+    };
+};
+export type RuntimeMcpStreamableHttpServerOptions = RuntimeMcpServerOptions & {
+    hostname?: string;
+    port?: number;
+    path?: string;
+};
+export type RuntimeMcpStreamableHttpServer = {
+    hostname: string;
+    port: number;
+    path: string;
+    url: string;
+    completed: Promise<void>;
+    close: () => Promise<void>;
+};
+type RuntimeMcpRuntime = {
+    listSessions: (filter?: {
+        agentId?: string;
+    }) => Promise<SessionSummary[]>;
+    getSessionRecord: (sessionId: string) => Promise<SessionRecord | null>;
+    listRequests: (filter?: {
+        agentId?: string;
+        sessionId?: string;
+        state?: RequestState;
+    }) => Promise<RequestSummary[]>;
+    getRequest: (requestId: string) => Promise<RequestRecord | null>;
+    listApprovals: (filter?: {
+        status?: ApprovalRecord["status"];
+        sessionId?: string;
+        requestId?: string;
+    }) => Promise<ApprovalRecord[]>;
+    getApproval: (approvalId: string) => Promise<ApprovalRecord | null>;
+    resume: (options: {
+        approvalId?: string;
+        sessionId?: string;
+        requestId?: string;
+        decision?: "approve" | "edit" | "reject";
+        editedInput?: Record<string, unknown>;
+    }) => Promise<RequestResult>;
+    listRequestArtifacts: (sessionId: string, requestId: string) => Promise<ArtifactListing>;
+    readRequestArtifact: (sessionId: string, requestId: string, artifactPath: string) => Promise<unknown>;
+    listRequestEvents: (sessionId: string, requestId: string) => Promise<HarnessEvent[]>;
+    exportRequestPackage: (input: {
+        sessionId: string;
+        requestId: string;
+        includeArtifacts?: boolean;
+        includeArtifactContents?: boolean;
+        includeRuntimeHealth?: boolean;
+    }) => Promise<unknown>;
+    exportSessionPackage: (input: RuntimeSessionPackageInput) => Promise<RuntimeSessionPackage>;
+};
+export declare function createToolMcpServerFromTools(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
+export declare function serveToolsOverStdioFromHarness(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
+export declare function createRuntimeMcpServer(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
+export declare function serveRuntimeMcpOverStdio(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
+export declare function serveRuntimeMcpOverStreamableHttp(runtime: RuntimeMcpRuntime, options?: RuntimeMcpStreamableHttpServerOptions): Promise<RuntimeMcpStreamableHttpServer>;
+export {};