@botbotgo/agent-harness 0.0.308 → 0.0.310

package/README.md

@@ -128,6 +128,20 @@ This file is both a quickstart and a long reference—you do not need to read it
 | **Operations / governance** | [Runtime capabilities at a glance](#readme-en-runtime-glance) → [Primary use cases](#readme-en-use-cases) | [Runtime operations](./docs/development/runtime-operations.html) and [`docs/tool-execution-policy.md`](./docs/tool-execution-policy.md). |
 | **API lookup** | Skip to [API Summary](#readme-en-api-summary) | Use it as a bookmarked index; the [API reference](./docs/development/api-reference.html) has fuller detail. |
 
+## Repository Source Layout
+
+When you work on the open-source package itself, treat `src/` as a layered tree instead of one flat folder:
+
+- top-level `src/*.ts` files should stay as stable public entrypoints or compatibility shims
+- public API implementation belongs under `src/public/`
+- protocol servers and transports belong under `src/protocol/**`
+- terminal, projection, and rendering helpers belong under `src/surface/` or `src/cli/`
+- scaffolding and bootstrap generation belong under `src/scaffold/`
+- extension and tool-definition machinery belong under `src/tooling/`
+- runtime internals stay under `src/runtime/`, persistence under `src/persistence/`, and workspace assembly under `src/workspace/`
+
+For new code, prefer the domain folder first. Only add a new top-level `src/*.ts` file when it is intentionally part of the package entry surface.
+
 ## License & Commercial Support
 
 This project is licensed under **Apache License 2.0**.
@@ -1178,6 +1192,7 @@ ACP transport notes:
 - ACP transport validation now covers the reference-client core flow: capability discovery, request submit, session lookup, request lookup, invalid-JSON handling, notification calls without response ids, stdio JSON-RPC, and HTTP plus SSE runtime notifications.
 - Cross-protocol conformance now has an explicit regression gate as well: ACP submission, A2A task lookup and continuation, and runtime MCP inspection must all project the same persisted `sessionId` / `requestId` runtime records instead of drifting into surface-specific identifiers or side stores.
 - For the thinnest editor or CLI starter, begin with `agent-harness acp serve --workspace . --transport stdio` and mirror the `examples/03_protocol-surfaces/app/acp-stdio/main.mjs` wire shape. Applications that want an in-process reference client can use `createAcpStdioClient(...)` to issue JSON-RPC requests and route runtime notifications without hand-rolling line parsing.
+- When a local ACP HTTP endpoint should stay up beyond one foreground shell, use `botbotgo acp start --workspace . --host 127.0.0.1 --port 8787` and later `botbotgo acp stop --workspace .`. The CLI records the managed process under `.botbotgo/services/` so local operators can start and stop it without a second process manager.
 - `botbotgo` is the shortest local terminal entrypoint for a published install. It defaults the workspace to the current directory, so teams can `cd` into their own runtime workspace and run `botbotgo` or `botbotgo "..."` directly. `agent-harness` keeps the same implicit-chat behavior, and `-w/--workspace` still lets one shell point at another workspace when needed.
 - `agent-harness chat --workspace .` still acts as a local terminal shell over the shared `HarnessClient` contract when you want the explicit subcommand form: the default `stdio` path runs directly in-process against the workspace runtime, while `--transport http --host <host> --port <port>` can still target an already-running ACP HTTP endpoint. One-shot use can pass `--message`, while interactive mode supports `/context`, `/new`, `/agent <agentId>`, `/sessions`, `/requests`, `/resume <sessionId>`, `/approvals`, `/approve`, `/reject`, `/cancel`, `/events`, `/trace`, `/health`, `/overview`, `/session`, `/request [requestId]`, and `/exit`. `/resume` now validates the target session, restores its latest request id, and rehydrates the active agent context; `/request <requestId>` can switch the active request context to a persisted request; `/new` clears the current session/request context without leaving the shell. Terminal chat now keeps one operator-facing flow: it streams tool and progress events as they happen and still prints the full final answer, instead of switching to a separate request-tree-only mode.
 - Local repo usage differs from the published binary on purpose. After cloning the repo, use `npm run chat -- --workspace ./config` or `npm run agent-harness -- chat --workspace ./config`. The extra `--` matters: without it, npm treats `--workspace` as npm's own workspace flag. The standalone `agent-harness ...` command only works after the package has been installed or linked so the `bin` entry is on your `PATH`.
@@ -1186,8 +1201,9 @@ ACP transport notes:
 - Chat startup now also performs a lightweight workspace-model preflight for the local Ollama path. If the configured endpoint is unreachable or responds with `404 page not found`, the shell prints that warning before the first prompt so endpoint mismatches show up immediately instead of only after the first failed message.
 - The interactive prompt now carries the live `agent`, `session`, and short `request` identifier together, so after each reply and during shell-history navigation the user stays anchored to the current runtime turn instead of dropping back to a bare input prompt.
 - `serveA2aHttp(runtime)` exposes an A2A-compatible HTTP JSON-RPC bridge plus agent card discovery, mapping both existing methods such as `message/send` and A2A v1.0 PascalCase methods such as `SendMessage`, `SendStreamingMessage`, `GetTask`, `ListTasks`, `CancelTask`, `SubscribeToTask`, `GetAgentCard`, `GetExtendedAgentCard`, and task push-notification config methods onto the existing session/request runtime surface. The bridge now advertises both `1.0` and `0.3` JSON-RPC interfaces, answers `HEAD` / `OPTIONS` discovery on the agent-card path, sets supported-version discovery headers, can optionally expose registry URLs plus detached signed-card metadata for surrounding discovery systems, validates `A2A-Version`, records `A2A-Extensions` into runtime invocation metadata, publishes `TASK_STATE_*` statuses plus the `{ task }` `SendMessage` wrapper, streams an initial `{ task }` snapshot plus later `{ statusUpdate }` payloads over SSE for v1 streaming methods, and can send best-effort webhook task snapshots for configured push notification receivers.
+- For a managed local bridge, use `botbotgo a2a start --workspace . --host 127.0.0.1 --port 8080` and later `botbotgo a2a stop --workspace .`. This uses the same `.botbotgo/services/` state directory as ACP so both local protocol bridges follow one terminal-first workflow.
 - `serveAgUiHttp(runtime)` exposes an AG-UI-compatible HTTP SSE bridge that projects runtime lifecycle, safe progress commentary, text output, upstream thinking, step progress, and tool calls onto `RUN_*`, `STATUS_UPDATE`, `TEXT_MESSAGE_*`, `THINKING_TEXT_MESSAGE_*`, `STEP_*`, and `TOOL_CALL_*` events for UI clients.
-- `createRuntimeMcpServer(runtime)` and `serveRuntimeMcpOverStdio(runtime)` expose the persisted runtime control surface itself as MCP tools, including sessions, requests, approvals, artifacts, events, and package export helpers.
+- `createRuntimeMcpServer(runtime)`, `serveRuntimeMcpOverStdio(runtime)`, and `serveRuntimeMcpOverStreamableHttp(runtime)` expose the persisted runtime control surface itself as MCP tools, including sessions, requests, approvals, artifacts, events, and package export helpers. `botbotgo mcp serve --transport streamable-http --host 127.0.0.1 --port 8090` serves the same tool surface over Streamable HTTP, and `botbotgo mcp start|stop` manages that background endpoint for one workspace.
 - `listRequestEvents(...)`, `listRequestTraceItems(...)`, and `exportRequestPackage(...)` are the request-first inspection helpers.
 - `exportRequestPackage(...)` and `exportSessionPackage(...)` package stable runtime records, transcript, approvals, events, artifacts, and governance evidence for operator tooling without reaching into persistence internals.
 - `runtime/default.governance.remoteMcp` can now deny or allow specific MCP servers, raise approval requirements by transport, and stamp transport-based risk tiers into runtime governance bundles. MCP server catalogs can also declare trust tier, access mode, tenant scope, approval policy, prompt-injection risk, and OAuth scope metadata so governance bundles capture why one remote tool is treated as high-risk. Tool policy overrides can also set `decisionMode: manual | auto-approve | auto-reject | deny-and-continue` so operator evidence and execution behavior stay aligned.

package/README.zh.md

@@ -126,6 +126,20 @@ durable memory 的写入现在也会在模型做 mutation reconciliation 之前
 | **运维 / 治理** | [运行时能力速览](#readme-zh-runtime-glance) → [典型应用场景](#readme-zh-use-cases) | [运行时运维](./docs/development/zh/runtime-operations.html) 与 [`docs/tool-execution-policy.md`](./docs/tool-execution-policy.md)。 |
 | **查 API** | 跳转到文末 [API 摘要](#readme-zh-api-summary) | 日常以[API 参考](./docs/development/zh/api-reference.html)为准。 |
 
+## 仓库源码分层
+
+如果你维护的是这个开源包本身，请把 `src/` 当成分层目录，而不是平铺文件夹：
+
+- `src/*.ts` 顶层文件尽量只保留稳定公共入口或兼容 shim
+- 公共 API 实现放进 `src/public/`
+- 协议服务与传输实现放进 `src/protocol/**`
+- 终端、事件投影与渲染辅助放进 `src/surface/` 或 `src/cli/`
+- 脚手架与项目初始化逻辑放进 `src/scaffold/`
+- 扩展注册、工具定义与模块装载放进 `src/tooling/`
+- runtime 内部继续放在 `src/runtime/`，持久化放在 `src/persistence/`，workspace 装配放在 `src/workspace/`
+
+新增实现代码时，优先进入对应 domain 子目录。只有当一个文件本来就属于包的公开入口面时，才新增顶层 `src/*.ts`。
+
 ## 许可证与商业支持
 
 本项目采用 **Apache License 2.0** 开源许可。[查看 LICENSE](./LICENSE)
@@ -1144,6 +1158,7 @@ ACP transport 说明：
 - ACP transport 现已覆盖核心参考客户端流程验证：capability discovery、request submit、session lookup、request lookup、invalid JSON 处理、无 id notification 不返回响应，以及 stdio JSON-RPC 与 HTTP + SSE runtime notifications。
 - 现在还额外有一条跨协议一致性回归门：ACP 发起的 request、A2A 读取或继续的 task，以及 runtime MCP 暴露的检查结果，必须始终指向同一组持久化 `sessionId` / `requestId` 运行时记录，不能漂移成各协议各自维护的标识体系。
 - 如果要从最薄的一层 editor / CLI starter 开始，优先用 `agent-harness acp serve --workspace . --transport stdio`，并直接参考 `examples/03_protocol-surfaces/app/acp-stdio/main.mjs` 的 wire shape。需要在应用内使用 reference client 时，可直接用 `createAcpStdioClient(...)` 发起 JSON-RPC 请求并分流 runtime notifications，避免每个 sidecar 自己重写 line parsing。
+- 如果本地 ACP HTTP endpoint 需要在前台 shell 之外持续运行，可使用 `botbotgo acp start --workspace . --host 127.0.0.1 --port 8787`，之后再用 `botbotgo acp stop --workspace .` 停止。CLI 会把受管进程记录到 `.botbotgo/services/` 下，因此本地运维不必再额外引入第二套进程管理器。
 - 对发布后的安装包来说，`botbotgo` 是最短的本地终端入口。它会默认把当前目录当作 workspace，所以团队只需要 `cd` 到自己的 runtime workspace，然后直接运行 `botbotgo` 或 `botbotgo "..."`。`agent-harness` 也保留同样的隐式 chat 行为；如果要从同一个 shell 指向别的 workspace，继续用 `-w/--workspace` 即可。
 - `agent-harness chat --workspace .` 则继续保留为显式子命令形式的本地终端壳：默认 `stdio` 路径会直接在当前进程里连接 workspace runtime，而 `--transport http --host <host> --port <port>` 仍然可以直连已运行的 ACP HTTP endpoint。一次性调用可用 `--message`，交互模式则支持 `/context`、`/new`、`/agent <agentId>`、`/sessions`、`/requests`、`/resume <sessionId>`、`/approvals`、`/approve`、`/reject`、`/cancel`、`/events`、`/trace`、`/health`、`/overview`、`/session`、`/request [requestId]` 与 `/exit`。`/resume` 现在会先校验目标 session，恢复它的 latest request id，并同步 active agent context；`/request <requestId>` 可以把当前上下文切到某个已持久化 request；`/new` 则会在不退出 shell 的情况下清空当前 session/request context。终端 chat 现在统一走一条面向 operator 的输出路径：tool 和进度事件会实时打印，最终完整答复也会继续输出，而不再切到单独的 request-tree-only 模式。
 - 如果是在仓库源码目录里直接运行，请使用 `npm run chat -- --workspace ./config`，或者 `npm run agent-harness -- chat --workspace ./config`。这里额外的 `--` 不能省略，否则 npm 会把 `--workspace` 当成它自己的 workspace 参数。只有在包已经被安装或 `npm link` 到系统环境后，`agent-harness ...` 这个独立命令才会出现在 `PATH` 里。
@@ -1152,8 +1167,9 @@ ACP transport 说明：
 - chat 启动时现在还会对本地 Ollama 路径做一次轻量 preflight。如果当前 endpoint 不可达，或者直接返回 `404 page not found`，shell 会在第一条 prompt 之前先打印这条告警，这样 endpoint 配错的问题会在启动时立即暴露，而不必等第一条消息失败后才知道。
 - 交互式 prompt 现在会同时显示当前 `agent`、`session` 和短 `request` 标识，因此每轮回复之后以及使用 shell 历史记录时，用户都还能清楚地看到自己正处在哪个 runtime turn 上，而不会掉回一个没有上下文的裸输入提示。
 - `serveA2aHttp(runtime)` 提供 A2A HTTP JSON-RPC bridge 与 agent card discovery，同时兼容 `message/send` 这类旧方法，以及 `SendMessage`、`SendStreamingMessage`、`GetTask`、`ListTasks`、`CancelTask`、`SubscribeToTask`、`GetAgentCard`、`GetExtendedAgentCard` 与 task push-notification config 这类 A2A v1.0 方法，并统一映射到现有 session/request 运行记录。bridge 现在会同时声明 `1.0` 与 `0.3` 两个 JSON-RPC interface、在 agent card 路径上响应 `HEAD` / `OPTIONS` discovery、写出支持版本的 discovery headers、可选暴露 registry URL 与 detached signed-card metadata 供外围发现系统使用、校验 `A2A-Version`、把 `A2A-Extensions` 记录进 runtime invocation metadata、发布 `TASK_STATE_*` 状态与 `SendMessage` 的 `{ task }` wrapper、在 v1 streaming 方法上先通过 SSE 输出 `{ task }` 初始快照，再输出 `{ statusUpdate }` 增量状态，并可向已配置的 webhook receiver 发送 best-effort task push notifications。
+- 如果要把本地 A2A bridge 作为受管后台服务运行，可使用 `botbotgo a2a start --workspace . --host 127.0.0.1 --port 8080`，之后再用 `botbotgo a2a stop --workspace .` 停止。它与 ACP 共用 `.botbotgo/services/` 状态目录，因此两个本地协议桥都可以沿用同一套终端优先运维流程。
 - `serveAgUiHttp(runtime)` 提供 AG-UI HTTP SSE bridge，把 runtime 生命周期、安全进度播报、文本输出、upstream thinking、step 进度与 tool call 投影成 `RUN_*`、`STATUS_UPDATE`、`TEXT_MESSAGE_*`、`THINKING_TEXT_MESSAGE_*`、`STEP_*` 与 `TOOL_CALL_*` 事件，便于 UI 客户端直接接入。
-- `createRuntimeMcpServer(runtime)` 与 `serveRuntimeMcpOverStdio(runtime)` 会把持久化 runtime 控制面本身暴露成 MCP tools，包括 sessions、requests、approvals、artifacts、events 与 package export helpers。
+- `createRuntimeMcpServer(runtime)`、`serveRuntimeMcpOverStdio(runtime)` 与 `serveRuntimeMcpOverStreamableHttp(runtime)` 会把持久化 runtime 控制面本身暴露成 MCP tools，包括 sessions、requests、approvals、artifacts、events 与 package export helpers。`botbotgo mcp serve --transport streamable-http --host 127.0.0.1 --port 8090` 会把同一套控制面作为 Streamable HTTP 暴露出去，而 `botbotgo mcp start|stop` 可直接托管该后台 endpoint。
 - `listRequestEvents(...)`、`listRequestTraceItems(...)` 与 `exportRequestPackage(...)` 是 request-first 的检查 helper。
 - `exportRequestPackage(...)` 与 `exportSessionPackage(...)` 可把稳定 runtime 记录、transcript、approvals、events、artifacts 与 governance evidence 一起打包给管理工具，而不必直接访问 persistence 内部实现。
 - `runtime/default.governance.remoteMcp` 现在可以按 MCP server 或 transport 做 allow/deny、审批升级，并把 transport 风险等级写进 runtime governance bundles。MCP server catalog 也可以声明 trust tier、access mode、tenant scope、approval policy、prompt-injection risk 与 OAuth scope 元数据，让治理快照能解释为什么某个远端工具被视为高风险。tool policy override 也可以声明 `decisionMode: manual | auto-approve | auto-reject | deny-and-continue`，让治理快照与实际执行路径保持一致。

package/dist/acp.d.ts

@@ -1,116 +1 @@
-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 "./protocol/acp/client.js";
-export { createAcpHttpClient } from "./protocol/acp/client.js";
-export type { AcpHttpClient, AcpHttpClientOptions, AcpStdioClient, AcpStdioClientOptions } from "./protocol/acp/client.js";
+export * from "./protocol/acp/server.js";

package/dist/acp.js

@@ -1,310 +1 @@
-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 "./protocol/acp/client.js";
-export { createAcpHttpClient } from "./protocol/acp/client.js";
+export * from "./protocol/acp/server.js";

package/dist/api.d.ts

@@ -2,12 +2,13 @@ import type { ArtifactListing, CancelOptions, InvocationEnvelope, ListMemoriesIn
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import type { InventoryAgentRecord, InventorySkillRecord } from "./runtime/harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./runtime/harness/system/skill-requirements.js";
-import type { RuntimeMcpServerOptions, ToolMcpServerOptions } from "./mcp.js";
+import type { RuntimeMcpServerOptions, RuntimeMcpStreamableHttpServerOptions, ToolMcpServerOptions } from "./mcp.js";
 export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export { createAcpStdioClient } from "./protocol/acp/client.js";
+export type { RuntimeMcpStreamableHttpServer, RuntimeMcpStreamableHttpServerOptions } from "./mcp.js";
 export type { AcpApproval, AcpArtifact, AcpEventNotification, AcpNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRequestParams, AcpServerCapabilities, AcpSessionRecord, AcpStreamNotification, } from "./acp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
-export { createUpstreamTimelineReducer } from "./upstream-events.js";
+export { createUpstreamTimelineReducer } from "./projections/upstream-events.js";
 export type { ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RequestPlanState, SessionListSummary, RuntimeSessionPackageInput, RuntimeSessionPackage, UpdateMemoryInput, } from "./contracts/types.js";
 export type { AcpHttpServer, AcpHttpServerOptions } from "./protocol/acp/http.js";
 export type { AcpStdioClient, AcpStdioClientOptions } from "./protocol/acp/client.js";
@@ -208,3 +209,4 @@ export declare function createToolMcpServer(runtime: AgentHarnessRuntime, option
 export declare function serveToolsOverStdio(runtime: AgentHarnessRuntime, options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
 export declare function createRuntimeMcpServer(runtime: AgentHarnessRuntime, options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
 export declare function serveRuntimeMcpOverStdio(runtime: AgentHarnessRuntime, options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
+export declare function serveRuntimeMcpOverStreamableHttp(runtime: AgentHarnessRuntime, options?: RuntimeMcpStreamableHttpServerOptions): Promise<import("./mcp.js").RuntimeMcpStreamableHttpServer>;

package/dist/api.js

@@ -10,7 +10,7 @@ import { traceStartupStage } from "./runtime/startup-tracing.js";
 export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export { createAcpStdioClient } from "./protocol/acp/client.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
-export { createUpstreamTimelineReducer } from "./upstream-events.js";
+export { createUpstreamTimelineReducer } from "./projections/upstream-events.js";
 function toApprovalRecord(record) {
     return {
         approvalId: record.approvalId,
@@ -387,6 +387,9 @@ export async function createRuntimeMcpServer(runtime, options) {
 export async function serveRuntimeMcpOverStdio(runtime, options) {
     return runtime.serveRuntimeMcpOverStdio(options);
 }
+export async function serveRuntimeMcpOverStreamableHttp(runtime, options) {
+    return runtime.serveRuntimeMcpOverStreamableHttp(options);
+}
 function normalizeUserChatMessage(message) {
     if (message.role !== "user") {
         throw new Error("normalizeUserChatInput only accepts user-role chat messages.");

package/dist/cli/chat-interactive.d.ts

@@ -0,0 +1,24 @@
+import type { Interface as ReadlineInterface } from "node:readline";
+import type { Writable as WritableStream } from "node:stream";
+import type { HarnessClient } from "../client.js";
+import { type ChatWorkspaceModelInfo } from "./chat-workspace.js";
+export declare function runInteractiveChatLoop(input: {
+    client: HarnessClient;
+    lineReader: ReadlineInterface;
+    stdout: (message: string) => void;
+    stderr: (message: string) => void;
+    stdoutStream?: WritableStream;
+    stderrStream?: WritableStream;
+    workspacePath: string;
+    workspaceModelInfo?: ChatWorkspaceModelInfo;
+    requestEvents: boolean;
+    chatIsTty: boolean;
+    useColor: boolean;
+    agentFilter?: string;
+    activeAgentId?: string;
+    activeSessionId?: string;
+}): Promise<{
+    activeAgentId?: string;
+    activeSessionId?: string;
+    latestRequestId?: string;
+}>;