@botbotgo/agent-harness 0.0.307 → 0.0.309

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/config/runtime/workspace.yaml

@@ -29,6 +29,22 @@ spec:
   # agent-harness feature: stable runtime profile identifier for this data folder.
   profile: default
 
+  # agent-harness feature: explicit tool and skill discovery sources.
+  # The default local workspace contract stays:
+  # - tools from ./resources/tools
+  # - skills from ./resources/skills
+  #
+  # Supported source forms today:
+  # - tools: file://<folder>, npm://<package-or-spec>
+  # - skills: file://<folder-or-SKILL.md>, http(s)://.../SKILL.md
+  #
+  # Discovery never traverses node_modules directories.
+  sources:
+    tools:
+      - file://./resources/tools
+    skills:
+      - file://./resources/skills
+
   # agent-harness feature: runtime-level task queue and maximum number of concurrent requests.
   # Additional requests wait in the harness queue until a slot becomes available.
   concurrency:

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 {};