@botbotgo/agent-harness 0.0.308 → 0.0.309

package/README.md

@@ -1178,6 +1178,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 +1187,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

@@ -1144,6 +1144,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 +1153,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/api.d.ts

@@ -2,9 +2,10 @@ 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";
@@ -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

@@ -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.d.ts

@@ -8,7 +8,7 @@ import { serveA2aOverHttp } from "./protocol/a2a/http.js";
 import { serveAgUiOverHttp } from "./protocol/ag-ui/http.js";
 import { serveAcpOverHttp } from "./protocol/acp/http.js";
 import { serveAcpOverStdio } from "./protocol/acp/stdio.js";
-import { serveRuntimeMcpOverStdio } from "./mcp.js";
+import { serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp } from "./mcp.js";
 type CliIo = {
     cwd?: string;
     stdin?: Readable;
@@ -34,6 +34,17 @@ type CliDeps = {
     serveAcpOverHttp?: typeof serveAcpOverHttp;
     serveAcpOverStdio?: typeof serveAcpOverStdio;
     serveRuntimeMcpOverStdio?: typeof serveRuntimeMcpOverStdio;
+    serveRuntimeMcpOverStreamableHttp?: typeof serveRuntimeMcpOverStreamableHttp;
+    spawnManagedCliProcess?: (input: {
+        args: string[];
+        cwd: string;
+        stdoutPath: string;
+        stderrPath: string;
+    }) => Promise<{
+        pid?: number;
+    }>;
+    isManagedProcessRunning?: (pid: number) => boolean;
+    signalManagedProcess?: (pid: number, signal?: NodeJS.Signals) => void;
 };
 export declare function renderChatPromptLine(input: {
     agentId?: string;

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { existsSync, openSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { createInterface as createReadlineInterface } from "node:readline";
 import { Writable } from "node:stream";
 import path from "node:path";
@@ -14,7 +16,7 @@ import { serveA2aOverHttp } from "./protocol/a2a/http.js";
 import { serveAgUiOverHttp } from "./protocol/ag-ui/http.js";
 import { serveAcpOverHttp } from "./protocol/acp/http.js";
 import { serveAcpOverStdio } from "./protocol/acp/stdio.js";
-import { serveRuntimeMcpOverStdio } from "./mcp.js";
+import { serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp } from "./mcp.js";
 import { interpolateEnvPlaceholders } from "./workspace/yaml-object-reader.js";
 function renderUsage() {
     return `Usage:
@@ -23,7 +25,11 @@ function renderUsage() {
   agent-harness [-w <path>] [prompt]
   botbotgo [-w <path>] [prompt]
   agent-harness acp serve [--workspace <path>] [--transport stdio|http] [--host <hostname>] [--port <port>]
+  agent-harness acp start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness acp stop [--workspace <path>]
   agent-harness a2a serve [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness a2a start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness a2a stop [--workspace <path>]
   agent-harness ag-ui serve [--workspace <path>] [--host <hostname>] [--port <port>]
   agent-harness runtime overview [--workspace <path>] [--limit <n>] [--json]
   agent-harness runtime health [--workspace <path>] [--json]
@@ -34,7 +40,12 @@ function renderUsage() {
   agent-harness runtime scheduled-run --workspace <path> --schedule <scheduleId>
   agent-harness runtime export request --workspace <path> --session <sessionId> --request <requestId> [--artifacts] [--artifact-contents] [--health] [--json]
   agent-harness runtime export session --workspace <path> --session <sessionId> [--artifacts] [--artifact-contents] [--health] [--json]
-  agent-harness runtime-mcp serve [--workspace <path>]
+  agent-harness runtime-mcp serve [--workspace <path>] [--transport stdio|streamable-http] [--host <hostname>] [--port <port>]
+  agent-harness runtime-mcp start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness runtime-mcp stop [--workspace <path>]
+  agent-harness mcp serve [--workspace <path>] [--transport stdio|streamable-http] [--host <hostname>] [--port <port>]
+  agent-harness mcp start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness mcp stop [--workspace <path>]
 
 Run botbotgo or agent-harness from any folder.
 If ./config/ is absent, the runtime falls back to the bundled system defaults and bundled resources.
@@ -80,9 +91,9 @@ function parseInitOptions(args) {
     }
     return { options };
 }
-function parseAcpServeOptions(args) {
+function parseAcpServeOptions(args, defaultTransport = "stdio") {
     let workspaceRoot;
-    let transport = "stdio";
+    let transport = defaultTransport;
     let hostname;
     let port;
     for (let index = 0; index < args.length; index += 1) {
@@ -134,6 +145,23 @@ function parseAcpServeOptions(args) {
     }
     return { workspaceRoot, transport, hostname, port };
 }
+function parseWorkspaceOnlyOptions(args) {
+    let workspaceRoot;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace") {
+            const value = args[index + 1];
+            if (!value) {
+                return { error: "Missing value for --workspace" };
+            }
+            workspaceRoot = value;
+            index += 1;
+            continue;
+        }
+        return { error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot };
+}
 function parseHttpServeOptions(args, serviceLabel = "HTTP") {
     let workspaceRoot;
     let hostname;
@@ -175,6 +203,60 @@ function parseHttpServeOptions(args, serviceLabel = "HTTP") {
     }
     return { workspaceRoot, hostname, port };
 }
+function parseRuntimeMcpServeOptions(args, defaultTransport = "stdio") {
+    let workspaceRoot;
+    let transport = defaultTransport;
+    let hostname;
+    let port;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --workspace" };
+            }
+            workspaceRoot = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--transport") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --transport" };
+            }
+            if (value !== "stdio" && value !== "streamable-http") {
+                return { transport, hostname, port, error: `Unsupported runtime MCP transport: ${value}` };
+            }
+            transport = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--host") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --host" };
+            }
+            hostname = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--port") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --port" };
+            }
+            const parsedPort = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedPort) || parsedPort < 0) {
+                return { transport, hostname, port, error: `Invalid runtime MCP port: ${value}` };
+            }
+            port = parsedPort;
+            index += 1;
+            continue;
+        }
+        return { transport, hostname, port, error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot, transport, hostname, port };
+}
 function parseChatOptions(args) {
     let workspaceRoot;
     let agentId;
@@ -250,9 +332,66 @@ function isTopLevelCliCommand(value) {
         || value === "acp"
         || value === "a2a"
         || value === "ag-ui"
+        || value === "mcp"
         || value === "runtime"
         || value === "runtime-mcp";
 }
+function resolveManagedServiceRoot(workspaceRoot) {
+    return path.join(workspaceRoot, ".botbotgo", "services");
+}
+function managedServiceStatePath(workspaceRoot, service) {
+    return path.join(resolveManagedServiceRoot(workspaceRoot), `${service}.json`);
+}
+function managedServiceLogPath(workspaceRoot, service, stream) {
+    return path.join(resolveManagedServiceRoot(workspaceRoot), `${service}.${stream}.log`);
+}
+async function readManagedServiceState(workspaceRoot, service) {
+    const statePath = managedServiceStatePath(workspaceRoot, service);
+    if (!existsSync(statePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(await readFile(statePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function writeManagedServiceState(state) {
+    const statePath = managedServiceStatePath(state.workspaceRoot, state.service);
+    await mkdir(path.dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+async function clearManagedServiceState(workspaceRoot, service) {
+    await rm(managedServiceStatePath(workspaceRoot, service), { force: true });
+}
+function defaultIsManagedProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultSignalManagedProcess(pid, signal) {
+    process.kill(pid, signal);
+}
+async function defaultSpawnManagedCliProcess(input) {
+    await mkdir(path.dirname(input.stdoutPath), { recursive: true });
+    const stdoutFd = openSync(input.stdoutPath, "a");
+    const stderrFd = openSync(input.stderrPath, "a");
+    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), ...input.args], {
+        cwd: input.cwd,
+        detached: true,
+        stdio: ["ignore", stdoutFd, stderrFd],
+    });
+    child.unref();
+    return { pid: child.pid };
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
 function parseRuntimeInspectOptions(args) {
     let workspaceRoot;
     let json = false;
@@ -821,11 +960,6 @@ function renderHealthSnapshot(snapshot, workspacePath) {
     }
     return `${lines.join("\n")}\n`;
 }
-async function sleep(ms) {
-    await new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
 function renderApprovalList(approvals) {
     if (approvals.length === 0) {
         return "No approvals matched.\n";
@@ -2041,6 +2175,10 @@ export async function runCli(argv, io = {}, deps = {}) {
     const serveAcpHttp = deps.serveAcpOverHttp ?? serveAcpOverHttp;
     const serveAcp = deps.serveAcpOverStdio ?? serveAcpOverStdio;
     const serveRuntimeMcp = deps.serveRuntimeMcpOverStdio ?? serveRuntimeMcpOverStdio;
+    const serveRuntimeMcpStreamableHttp = deps.serveRuntimeMcpOverStreamableHttp ?? serveRuntimeMcpOverStreamableHttp;
+    const spawnManagedCliProcess = deps.spawnManagedCliProcess ?? defaultSpawnManagedCliProcess;
+    const isManagedProcessRunning = deps.isManagedProcessRunning ?? defaultIsManagedProcessRunning;
+    const signalManagedProcess = deps.signalManagedProcess ?? defaultSignalManagedProcess;
     const createChatClient = deps.createChatClient ?? (async (input) => {
         if (input.transport === "http") {
             return createAcpHttpHarnessClient({
@@ -2342,6 +2480,68 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
     };
+    const startManagedHttpService = async (service, workspacePath, args) => {
+        const existing = await readManagedServiceState(workspacePath, service);
+        if (existing && isManagedProcessRunning(existing.pid)) {
+            stderr(`${service.toUpperCase()} service is already running for ${workspacePath} (pid ${existing.pid}).\n`);
+            return 0;
+        }
+        if (existing) {
+            await clearManagedServiceState(workspacePath, service);
+        }
+        const stdoutPath = managedServiceLogPath(workspacePath, service, "stdout");
+        const stderrPath = managedServiceLogPath(workspacePath, service, "stderr");
+        const spawned = await spawnManagedCliProcess({
+            args,
+            cwd: workspacePath,
+            stdoutPath,
+            stderrPath,
+        });
+        if (!spawned.pid || spawned.pid <= 0) {
+            stderr(`Failed to start ${service.toUpperCase()} service for ${workspacePath}.\n`);
+            return 1;
+        }
+        await writeManagedServiceState({
+            pid: spawned.pid,
+            service,
+            workspaceRoot: workspacePath,
+            transport: service === "mcp" ? "streamable-http" : "http",
+            startedAt: new Date().toISOString(),
+            stdoutPath,
+            stderrPath,
+        });
+        await sleep(250);
+        if (!isManagedProcessRunning(spawned.pid)) {
+            await clearManagedServiceState(workspacePath, service);
+            stderr(`Failed to keep ${service.toUpperCase()} service running for ${workspacePath}. Check ${stderrPath}.\n`);
+            return 1;
+        }
+        stderr(`Started ${service.toUpperCase()} service for ${workspacePath} (pid ${spawned.pid}). Logs: ${stdoutPath}, ${stderrPath}\n`);
+        return 0;
+    };
+    const stopManagedHttpService = async (service, workspacePath) => {
+        const existing = await readManagedServiceState(workspacePath, service);
+        if (!existing) {
+            stderr(`No managed ${service.toUpperCase()} service is recorded for ${workspacePath}.\n`);
+            return 0;
+        }
+        if (!isManagedProcessRunning(existing.pid)) {
+            await clearManagedServiceState(workspacePath, service);
+            stderr(`Managed ${service.toUpperCase()} service for ${workspacePath} is already stopped.\n`);
+            return 0;
+        }
+        signalManagedProcess(existing.pid, "SIGTERM");
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            await sleep(100);
+            if (!isManagedProcessRunning(existing.pid)) {
+                await clearManagedServiceState(workspacePath, service);
+                stderr(`Stopped ${service.toUpperCase()} service for ${workspacePath}.\n`);
+                return 0;
+            }
+        }
+        stderr(`Timed out while stopping ${service.toUpperCase()} service for ${workspacePath} (pid ${existing.pid}).\n`);
+        return 1;
+    };
     if (command === "init") {
         if (!projectName?.trim()) {
             stderr(renderUsage());
@@ -2392,28 +2592,58 @@ export async function runCli(argv, io = {}, deps = {}) {
     }
     if (command === "acp") {
         const [subcommand, ...subcommandArgs] = [projectName, ...rest];
-        if (subcommand !== "serve") {
+        if (subcommand !== "serve" && subcommand !== "start" && subcommand !== "stop") {
             stderr(renderUsage());
             return 1;
         }
-        const parsed = parseAcpServeOptions(subcommandArgs);
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
+        const parsedStop = subcommand === "stop" ? parseWorkspaceOnlyOptions(subcommandArgs) : undefined;
+        const parsedServe = subcommand !== "stop"
+            ? parseAcpServeOptions(subcommandArgs, subcommand === "start" ? "http" : "stdio")
+            : undefined;
+        const parseError = parsedStop?.error ?? parsedServe?.error;
+        if (parseError) {
+            stderr(`${parseError}\n`);
             stderr(renderUsage());
             return 1;
         }
         try {
-            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
+            const workspaceRoot = parsedStop?.workspaceRoot ?? parsedServe?.workspaceRoot;
+            const workspacePath = resolveCliWorkspaceRoot(cwd, workspaceRoot);
+            const workspaceError = validateCliWorkspaceRoot(workspacePath, workspaceRoot);
             if (workspaceError) {
                 stderr(`${workspaceError}\n`);
                 return 1;
             }
+            if (subcommand === "start") {
+                if (!parsedServe) {
+                    stderr(renderUsage());
+                    return 1;
+                }
+                if (parsedServe.transport !== "http") {
+                    stderr("ACP start only supports --transport http. Use `acp serve --transport stdio` for stdio clients.\n");
+                    return 1;
+                }
+                const args = ["acp", "serve", "--workspace", workspacePath, "--transport", "http"];
+                if (parsedServe.hostname) {
+                    args.push("--host", parsedServe.hostname);
+                }
+                if (typeof parsedServe.port === "number") {
+                    args.push("--port", String(parsedServe.port));
+                }
+                return startManagedHttpService("acp", workspacePath, args);
+            }
+            if (subcommand === "stop") {
+                return stopManagedHttpService("acp", workspacePath);
+            }
+            if (!parsedServe) {
+                stderr(renderUsage());
+                return 1;
+            }
             const runtime = await createHarness(workspacePath);
-            if (parsed.transport === "http") {
+            if (parsedServe.transport === "http") {
                 const server = await serveAcpHttp(runtime, {
-                    hostname: parsed.hostname,
-                    port: parsed.port,
+                    hostname: parsedServe.hostname,
+                    port: parsedServe.port,
                 });
                 stderr(`Serving ACP over http from ${workspacePath} at ${server.rpcUrl} (events ${server.eventsUrl})\n`);
                 await server.completed;
@@ -2469,27 +2699,47 @@ export async function runCli(argv, io = {}, deps = {}) {
     }
     if (command === "a2a") {
         const [subcommand, ...subcommandArgs] = [projectName, ...rest];
-        if (subcommand !== "serve") {
+        if (subcommand !== "serve" && subcommand !== "start" && subcommand !== "stop") {
             stderr(renderUsage());
             return 1;
         }
-        const parsed = parseHttpServeOptions(subcommandArgs, "A2A");
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
+        const parsedStop = subcommand === "stop" ? parseWorkspaceOnlyOptions(subcommandArgs) : undefined;
+        const parsedServe = subcommand !== "stop" ? parseHttpServeOptions(subcommandArgs, "A2A") : undefined;
+        const parseError = parsedStop?.error ?? parsedServe?.error;
+        if (parseError) {
+            stderr(`${parseError}\n`);
             stderr(renderUsage());
             return 1;
         }
         try {
-            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
+            const workspaceRoot = parsedStop?.workspaceRoot ?? parsedServe?.workspaceRoot;
+            const workspacePath = resolveCliWorkspaceRoot(cwd, workspaceRoot);
+            const workspaceError = validateCliWorkspaceRoot(workspacePath, workspaceRoot);
             if (workspaceError) {
                 stderr(`${workspaceError}\n`);
                 return 1;
             }
+            if (subcommand === "start") {
+                const args = ["a2a", "serve", "--workspace", workspacePath];
+                if (parsedServe?.hostname) {
+                    args.push("--host", parsedServe.hostname);
+                }
+                if (typeof parsedServe?.port === "number") {
+                    args.push("--port", String(parsedServe.port));
+                }
+                return startManagedHttpService("a2a", workspacePath, args);
+            }
+            if (subcommand === "stop") {
+                return stopManagedHttpService("a2a", workspacePath);
+            }
+            if (!parsedServe) {
+                stderr(renderUsage());
+                return 1;
+            }
             const runtime = await createHarness(workspacePath);
             const server = await serveA2a(runtime, {
-                hostname: parsed.hostname,
-                port: parsed.port,
+                hostname: parsedServe.hostname,
+                port: parsedServe.port,
             });
             stderr(`Serving A2A over http from ${workspacePath} at ${server.rpcUrl} (card ${server.agentCardUrl})\n`);
             await server.completed;
@@ -2502,33 +2752,73 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
     }
-    if (command === "runtime-mcp") {
+    if (command === "mcp" || command === "runtime-mcp") {
         const [subcommand, ...subcommandArgs] = [projectName, ...rest];
-        if (subcommand !== "serve") {
+        if (subcommand !== "serve" && subcommand !== "start" && subcommand !== "stop") {
             stderr(renderUsage());
             return 1;
         }
-        const parsed = parseHttpServeOptions(subcommandArgs, "runtime MCP");
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
+        const parsedStop = subcommand === "stop" ? parseWorkspaceOnlyOptions(subcommandArgs) : undefined;
+        const parsedServe = subcommand !== "stop"
+            ? parseRuntimeMcpServeOptions(subcommandArgs, subcommand === "start" ? "streamable-http" : "stdio")
+            : undefined;
+        const parseError = parsedStop?.error ?? parsedServe?.error;
+        if (parseError) {
+            stderr(`${parseError}\n`);
             stderr(renderUsage());
             return 1;
         }
         try {
-            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
+            const workspaceRoot = parsedStop?.workspaceRoot ?? parsedServe?.workspaceRoot;
+            const workspacePath = resolveCliWorkspaceRoot(cwd, workspaceRoot);
+            const workspaceError = validateCliWorkspaceRoot(workspacePath, workspaceRoot);
             if (workspaceError) {
                 stderr(`${workspaceError}\n`);
                 return 1;
             }
+            if (subcommand === "start") {
+                if (!parsedServe) {
+                    stderr(renderUsage());
+                    return 1;
+                }
+                if (parsedServe.transport !== "streamable-http") {
+                    stderr("MCP start only supports --transport streamable-http. Use `mcp serve --transport stdio` for stdio clients.\n");
+                    return 1;
+                }
+                const args = ["mcp", "serve", "--workspace", workspacePath, "--transport", "streamable-http"];
+                if (parsedServe.hostname) {
+                    args.push("--host", parsedServe.hostname);
+                }
+                if (typeof parsedServe.port === "number") {
+                    args.push("--port", String(parsedServe.port));
+                }
+                return startManagedHttpService("mcp", workspacePath, args);
+            }
+            if (subcommand === "stop") {
+                return stopManagedHttpService("mcp", workspacePath);
+            }
+            if (!parsedServe) {
+                stderr(renderUsage());
+                return 1;
+            }
             const runtime = await createHarness(workspacePath);
-            stderr(`Serving runtime MCP over stdio from ${workspacePath}\n`);
-            const server = await serveRuntimeMcp(runtime);
-            await new Promise((resolve, reject) => {
-                process.stdin.on("end", resolve);
-                process.stdin.on("error", reject);
-            });
-            await server.close();
+            if (parsedServe.transport === "streamable-http") {
+                const server = await serveRuntimeMcpStreamableHttp(runtime, {
+                    hostname: parsedServe.hostname,
+                    port: parsedServe.port,
+                });
+                stderr(`Serving runtime MCP over streamable HTTP from ${workspacePath} at ${server.url}\n`);
+                await server.completed;
+            }
+            else {
+                stderr(`Serving runtime MCP over stdio from ${workspacePath}\n`);
+                const server = await serveRuntimeMcp(runtime);
+                await new Promise((resolve, reject) => {
+                    process.stdin.on("end", resolve);
+                    process.stdin.on("error", reject);
+                });
+                await server.close();
+            }
             await runtime.stop();
             return 0;
         }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequestPlanState, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
+export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequestPlanState, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
 export { AcpHarnessClient, InProcessHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient, createAgentHarnessClient, createInProcessHarnessClient, } from "./client.js";
 export { createKnowledgeModule, readKnowledgeRuntimeConfig } from "./knowledge/index.js";
 export { readProceduralMemoryRuntimeConfig } from "./procedural/index.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequestPlanState, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
+export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequestPlanState, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
 export { AcpHarnessClient, InProcessHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient, createAgentHarnessClient, createInProcessHarnessClient, } from "./client.js";
 export { createKnowledgeModule, readKnowledgeRuntimeConfig } from "./knowledge/index.js";
 export { readProceduralMemoryRuntimeConfig } from "./procedural/index.js";

package/dist/mcp.d.ts

@@ -19,6 +19,19 @@ export type RuntimeMcpServerOptions = {
         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;
@@ -59,4 +72,5 @@ export declare function createToolMcpServerFromTools(tools: ToolMcpServerTool[],
 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 {};

package/dist/mcp.js

@@ -1,5 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
 import { pathToFileURL } from "node:url";
 import { z } from "zod";
 import { AGENT_HARNESS_VERSION } from "./package-version.js";
@@ -46,6 +49,33 @@ function renderToolOutput(output) {
     }
     return JSON.stringify(output, null, 2);
 }
+function normalizePath(value, fallback) {
+    const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+    return source.startsWith("/") ? source : `/${source}`;
+}
+function writeJson(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.end(JSON.stringify(payload));
+}
+function readRequestBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on("data", (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        request.on("end", () => {
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        request.on("error", reject);
+    });
+}
+function isInitializeRequest(payload) {
+    return typeof payload === "object"
+        && payload !== null
+        && !Array.isArray(payload)
+        && payload.method === "initialize";
+}
 function jsonSchemaObjectToRawShape(schema) {
     if (!schema || schema.type !== "object") {
         return undefined;
@@ -251,3 +281,148 @@ export async function serveRuntimeMcpOverStdio(runtime, options = {}) {
     await server.connect(new StdioServerTransport());
     return server;
 }
+export async function serveRuntimeMcpOverStreamableHttp(runtime, options = {}) {
+    const hostname = options.hostname?.trim() || "127.0.0.1";
+    const port = typeof options.port === "number" && Number.isFinite(options.port) ? options.port : 0;
+    const mcpPath = normalizePath(options.path, "/mcp");
+    const sessions = new Map();
+    const closeSession = async (sessionId) => {
+        const session = sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        sessions.delete(sessionId);
+        await Promise.allSettled([
+            session.transport.close(),
+            session.server.close(),
+        ]);
+    };
+    const httpServer = createServer(async (request, response) => {
+        try {
+            const requestUrl = new URL(request.url ?? "/", `http://${hostname}`);
+            if (requestUrl.pathname !== mcpPath) {
+                writeJson(response, 404, {
+                    error: "Not Found",
+                    path: mcpPath,
+                });
+                return;
+            }
+            const headerValue = request.headers["mcp-session-id"];
+            const sessionId = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+            if (request.method === "POST") {
+                const body = await readRequestBody(request);
+                let payload;
+                try {
+                    payload = JSON.parse(body);
+                }
+                catch {
+                    writeJson(response, 400, {
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32700,
+                            message: "Invalid JSON payload.",
+                        },
+                    });
+                    return;
+                }
+                const existingSession = sessionId ? sessions.get(sessionId) : undefined;
+                if (existingSession) {
+                    await existingSession.transport.handleRequest(request, response, payload);
+                    return;
+                }
+                if (sessionId || !isInitializeRequest(payload)) {
+                    writeJson(response, 400, {
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32000,
+                            message: "Bad Request: No valid MCP session was provided.",
+                        },
+                    });
+                    return;
+                }
+                let createdTransport;
+                const server = await createRuntimeMcpServer(runtime, options);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (initializedSessionId) => {
+                        sessions.set(initializedSessionId, { transport, server });
+                    },
+                });
+                createdTransport = transport;
+                transport.onclose = () => {
+                    const activeSessionId = createdTransport?.sessionId;
+                    if (activeSessionId) {
+                        const active = sessions.get(activeSessionId);
+                        if (active?.transport === createdTransport) {
+                            sessions.delete(activeSessionId);
+                        }
+                    }
+                };
+                await server.connect(transport);
+                await transport.handleRequest(request, response, payload);
+                return;
+            }
+            if (request.method === "GET" || request.method === "DELETE") {
+                if (!sessionId || !sessions.has(sessionId)) {
+                    writeJson(response, 400, {
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32000,
+                            message: "Bad Request: No valid MCP session was provided.",
+                        },
+                    });
+                    return;
+                }
+                const session = sessions.get(sessionId);
+                await session.transport.handleRequest(request, response);
+                if (request.method === "DELETE") {
+                    await closeSession(sessionId);
+                }
+                return;
+            }
+            response.statusCode = 405;
+            response.setHeader("allow", "GET, POST, DELETE");
+            response.end();
+        }
+        catch (error) {
+            writeJson(response, 500, {
+                error: error instanceof Error ? error.message : "Runtime MCP Streamable HTTP transport failed.",
+            });
+        }
+    });
+    const completed = new Promise((resolve, reject) => {
+        httpServer.once("close", resolve);
+        httpServer.once("error", reject);
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.listen(port, hostname, () => resolve());
+        httpServer.once("error", reject);
+    });
+    const address = httpServer.address();
+    const resolvedPort = typeof address === "object" && address ? address.port : port;
+    return {
+        hostname,
+        port: resolvedPort,
+        path: mcpPath,
+        url: `http://${hostname}:${resolvedPort}${mcpPath}`,
+        completed,
+        close: async () => {
+            const sessionIds = Array.from(sessions.keys());
+            for (const sessionId of sessionIds) {
+                await closeSession(sessionId);
+            }
+            await new Promise((resolve, reject) => {
+                httpServer.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        },
+    };
+}

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.307";
+export declare const AGENT_HARNESS_VERSION = "0.0.308";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.307";
+export const AGENT_HARNESS_VERSION = "0.0.308";

package/dist/runtime/harness.d.ts

@@ -125,6 +125,7 @@ export declare class AgentHarnessRuntime {
     serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     createRuntimeMcpServer(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     serveRuntimeMcpOverStdio(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
+    serveRuntimeMcpOverStreamableHttp(options?: import("../mcp.js").RuntimeMcpStreamableHttpServerOptions): Promise<import("../mcp.js").RuntimeMcpStreamableHttpServer>;
     routeAgent(input: MessageContent, options?: {
         sessionId?: string;
     }): Promise<string>;

package/dist/runtime/harness.js

@@ -1049,6 +1049,10 @@ export class AgentHarnessRuntime {
     async serveRuntimeMcpOverStdio(options = {}) {
         return serveRuntimeMcpOverStdio(this, options);
     }
+    async serveRuntimeMcpOverStreamableHttp(options = {}) {
+        const { serveRuntimeMcpOverStreamableHttp } = await import("../mcp.js");
+        return serveRuntimeMcpOverStreamableHttp(this, options);
+    }
     async routeAgent(input, options = {}) {
         return routeAgentId({
             workspace: this.workspace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.308",
+  "version": "0.0.309",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",