@botbotgo/agent-harness 0.0.166 → 0.0.168

package/README.md

@@ -903,6 +903,8 @@ Primary exports:
 - `serveAcpHttp`
 - `serveAcpStdio`
 - `serveAgUiHttp`
+- `createRuntimeMcpServer`
+- `serveRuntimeMcpOverStdio`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`
@@ -925,5 +927,6 @@ ACP transport notes:
 - `serveAcpStdio(runtime)` exposes newline-delimited JSON-RPC over stdio for local IDE, CLI, or subprocess clients.
 - `serveAcpHttp(runtime)` exposes JSON-RPC over HTTP plus SSE runtime events so remote operator surfaces can connect without importing the runtime in-process.
 - `serveAgUiHttp(runtime)` exposes a minimal AG-UI-compatible HTTP SSE bridge that projects `run + output.delta + final result` onto `RUN_STARTED`, `TEXT_MESSAGE_*`, and `RUN_FINISHED` 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.
 - `exportRunPackage(...)` and `exportSessionPackage(...)` package stable runtime records, transcript, approvals, events, and artifacts 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.

package/README.zh.md

@@ -862,6 +862,8 @@ spec:
 - `serveAcpHttp`
 - `serveAcpStdio`
 - `serveAgUiHttp`
+- `createRuntimeMcpServer`
+- `serveRuntimeMcpOverStdio`
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`
@@ -884,5 +886,6 @@ ACP transport 说明：
 - `serveAcpStdio(runtime)` 提供基于 stdio 的 newline-delimited JSON-RPC，适合本地 IDE、CLI 或子进程客户端。
 - `serveAcpHttp(runtime)` 提供基于 HTTP 的 JSON-RPC 与 SSE runtime events，适合远程 operator surface 或独立控制面接入。
 - `serveAgUiHttp(runtime)` 提供最小可用的 AG-UI HTTP SSE bridge，把现有 `run + output.delta + final result` 投影成 `RUN_STARTED`、`TEXT_MESSAGE_*` 与 `RUN_FINISHED` 事件，便于 UI 客户端直接接入。
+- `createRuntimeMcpServer(runtime)` 与 `serveRuntimeMcpOverStdio(runtime)` 会把持久化 runtime 控制面本身暴露成 MCP tools，包括 sessions、requests、approvals、artifacts、events 与 package export helpers。
 - `exportRunPackage(...)` 与 `exportSessionPackage(...)` 可把稳定 runtime 记录、transcript、approvals、events 和 artifacts 打包给 operator tooling，而不必直接访问 persistence 内部实现。
 - `runtime/default.governance.remoteMcp` 现在可以按 MCP server 或 transport 做 allow/deny、审批升级，并把 transport 风险等级写进 runtime governance bundles。

package/dist/api.d.ts

@@ -2,7 +2,7 @@ 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 { ToolMcpServerOptions } from "./mcp.js";
+import type { RuntimeMcpServerOptions, ToolMcpServerOptions } from "./mcp.js";
 export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export type { AcpApproval, AcpArtifact, AcpEventNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRunRequestParams, AcpServerCapabilities, AcpSessionRecord, } from "./acp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
@@ -115,3 +115,5 @@ export declare function cancelRun(runtime: AgentHarnessRuntime, options: CancelO
 export declare function stop(runtime: AgentHarnessRuntime): Promise<void>;
 export declare function createToolMcpServer(runtime: AgentHarnessRuntime, options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
 export declare function serveToolsOverStdio(runtime: AgentHarnessRuntime, options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
+export declare function createRuntimeMcpServer(runtime: AgentHarnessRuntime, options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
+export declare function serveRuntimeMcpOverStdio(runtime: AgentHarnessRuntime, options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;

package/dist/api.js

@@ -243,6 +243,12 @@ export async function createToolMcpServer(runtime, options) {
 export async function serveToolsOverStdio(runtime, options) {
     return runtime.serveToolsOverStdio(options);
 }
+export async function createRuntimeMcpServer(runtime, options) {
+    return runtime.createRuntimeMcpServer(options);
+}
+export async function serveRuntimeMcpOverStdio(runtime, options) {
+    return runtime.serveRuntimeMcpOverStdio(options);
+}
 function normalizeUserChatMessage(message) {
     if (message.role !== "user") {
         throw new Error("normalizeUserChatInput only accepts user-role chat messages.");

package/dist/cli.d.ts

@@ -3,6 +3,7 @@ import { createAgentHarness } from "./api.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";
 type CliIo = {
     cwd?: string;
     stdout?: (message: string) => void;
@@ -13,6 +14,7 @@ type CliDeps = {
     serveAgUiOverHttp?: typeof serveAgUiOverHttp;
     serveAcpOverHttp?: typeof serveAcpOverHttp;
     serveAcpOverStdio?: typeof serveAcpOverStdio;
+    serveRuntimeMcpOverStdio?: typeof serveRuntimeMcpOverStdio;
 };
 export declare function runCli(argv: string[], io?: CliIo, deps?: CliDeps): Promise<number>;
 export {};

package/dist/cli.js

@@ -6,11 +6,13 @@ import { initProject } from "./init-project.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";
 function renderUsage() {
     return `Usage:
   agent-harness init <project-name> [--template deep-research|single-agent] [--provider <provider>] [--model <model>] [--with-web-search|--no-web-search]
   agent-harness acp serve [--workspace <path>] [--transport stdio|http] [--host <hostname>] [--port <port>]
   agent-harness ag-ui serve [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness runtime-mcp serve [--workspace <path>]
 `;
 }
 function isTemplate(value) {
@@ -156,6 +158,7 @@ export async function runCli(argv, io = {}, deps = {}) {
     const serveAgUi = deps.serveAgUiOverHttp ?? serveAgUiOverHttp;
     const serveAcpHttp = deps.serveAcpOverHttp ?? serveAcpOverHttp;
     const serveAcp = deps.serveAcpOverStdio ?? serveAcpOverStdio;
+    const serveRuntimeMcp = deps.serveRuntimeMcpOverStdio ?? serveRuntimeMcpOverStdio;
     if (command === "init") {
         if (!projectName?.trim()) {
             stderr(renderUsage());
@@ -253,6 +256,37 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
     }
+    if (command === "runtime-mcp") {
+        const [subcommand, ...subcommandArgs] = [projectName, ...rest];
+        if (subcommand !== "serve") {
+            stderr(renderUsage());
+            return 1;
+        }
+        const parsed = parseHttpServeOptions(subcommandArgs);
+        if (parsed.error) {
+            stderr(`${parsed.error}\n`);
+            stderr(renderUsage());
+            return 1;
+        }
+        try {
+            const runtime = await createHarness(path.resolve(cwd, parsed.workspaceRoot ?? "."));
+            const workspacePath = path.resolve(cwd, parsed.workspaceRoot ?? ".");
+            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;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            stderr(`${message}\n`);
+            return 1;
+        }
+    }
     stderr(renderUsage());
     return 1;
 }

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { AgentHarnessAcpServer, AgentHarnessRuntime, buildFlowGraph, cancelRun, createAgentHarness, createAcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportRunPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getRequest, getHealth, listMemories, listRunEvents, getSession, listAgentSkills, listArtifacts, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveToolsOverStdio, subscribe, stop, updateMemory, exportFlowGraphToMermaid, exportFlowGraphToSequenceMermaid, } from "./api.js";
+export { AgentHarnessAcpServer, AgentHarnessRuntime, buildFlowGraph, cancelRun, createAgentHarness, createAcpServer, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportRunPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getRequest, getHealth, listMemories, listRunEvents, getSession, listAgentSkills, listArtifacts, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveToolsOverStdio, subscribe, stop, updateMemory, exportFlowGraphToMermaid, exportFlowGraphToSequenceMermaid, } from "./api.js";
 export type { AcpApproval, AcpArtifact, AcpEventNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRunRequestParams, AcpServerCapabilities, AcpSessionRecord, } from "./acp.js";
 export type { ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRunPackage, RuntimeRunPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, UpdateMemoryInput, UserChatInput, UserChatMessage, } from "./api.js";
 export type { BuildFlowGraphInput, FlowEdge, FlowEdgeKind, FlowGraph, FlowGraphMermaidOptions, FlowGraphSequenceMermaidOptions, FlowGroup, FlowGroupKind, FlowNode, FlowNodeKind, FlowNodeLayer, FlowNodeStatus, } from "./flow/index.js";
 export type { AcpHttpServer, AcpHttpServerOptions, AcpStdioServer, AcpStdioServerOptions, AgUiEvent, AgUiHttpServer, AgUiHttpServerOptions, AgUiRunAgentInput, } from "./api.js";
-export type { ToolMcpServerOptions } from "./mcp.js";
+export type { RuntimeMcpServerOptions, ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";
 export type { UpstreamTimelineProjection, UpstreamTimelineReducer } from "./upstream-events.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessAcpServer, AgentHarnessRuntime, buildFlowGraph, cancelRun, createAgentHarness, createAcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportRunPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getRequest, getHealth, listMemories, listRunEvents, getSession, listAgentSkills, listArtifacts, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveToolsOverStdio, subscribe, stop, updateMemory, exportFlowGraphToMermaid, exportFlowGraphToSequenceMermaid, } from "./api.js";
+export { AgentHarnessAcpServer, AgentHarnessRuntime, buildFlowGraph, cancelRun, createAgentHarness, createAcpServer, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportRunPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getRequest, getHealth, listMemories, listRunEvents, getSession, listAgentSkills, listArtifacts, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, removeMemory, resolveApproval, run, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveToolsOverStdio, subscribe, stop, updateMemory, exportFlowGraphToMermaid, exportFlowGraphToSequenceMermaid, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { CompiledTool, ParsedToolObject } from "./contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CompiledTool, HarnessEvent, ParsedToolObject, RunResult, RunState, RunSummary, RuntimeRunPackage, RuntimeRunPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ThreadRecord, ThreadSummary } from "./contracts/types.js";
 export type ToolMcpServerOptions = {
     agentId: string;
     serverInfo?: {
@@ -13,5 +13,44 @@ export type ToolMcpServerTool = {
     resolvedTool: unknown;
     sourceTool?: ParsedToolObject;
 };
+export type RuntimeMcpServerOptions = {
+    serverInfo?: {
+        name?: string;
+        version?: string;
+    };
+};
+type RuntimeMcpRuntime = {
+    listThreads: (filter?: {
+        agentId?: string;
+    }) => Promise<ThreadSummary[]>;
+    getThread: (threadId: string) => Promise<ThreadRecord | null>;
+    listRuns: (filter?: {
+        agentId?: string;
+        threadId?: string;
+        state?: RunState;
+    }) => Promise<RunSummary[]>;
+    getRun: (runId: string) => Promise<RunSummary | null>;
+    listApprovals: (filter?: {
+        status?: ApprovalRecord["status"];
+        threadId?: string;
+        runId?: string;
+    }) => Promise<ApprovalRecord[]>;
+    getApproval: (approvalId: string) => Promise<ApprovalRecord | null>;
+    resume: (options: {
+        approvalId?: string;
+        threadId?: string;
+        runId?: string;
+        decision?: "approve" | "edit" | "reject";
+        editedInput?: Record<string, unknown>;
+    }) => Promise<RunResult>;
+    listArtifacts: (threadId: string, runId: string) => Promise<ArtifactListing>;
+    readArtifact: (threadId: string, runId: string, artifactPath: string) => Promise<unknown>;
+    listRunEvents: (threadId: string, runId: string) => Promise<HarnessEvent[]>;
+    exportRunPackage: (input: RuntimeRunPackageInput) => Promise<RuntimeRunPackage>;
+    exportSessionPackage: (input: RuntimeSessionPackageInput) => Promise<RuntimeSessionPackage>;
+};
 export declare function createToolMcpServerFromTools(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
 export declare function serveToolsOverStdioFromHarness(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
+export declare function createRuntimeMcpServer(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
+export declare function serveRuntimeMcpOverStdio(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
+export {};

package/dist/mcp.js

@@ -110,3 +110,144 @@ export async function serveToolsOverStdioFromHarness(tools, options) {
     await server.connect(new StdioServerTransport());
     return server;
 }
+export async function createRuntimeMcpServer(runtime, options = {}) {
+    const server = new McpServer({
+        name: options.serverInfo?.name ?? "agent-harness-runtime",
+        version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
+    });
+    server.tool("list_sessions", "List persisted runtime sessions.", {
+        agentId: z.string().optional(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.listThreads(input.agentId ? { agentId: input.agentId } : undefined)),
+            }],
+    }));
+    server.tool("get_session", "Get one persisted runtime session by id.", {
+        sessionId: z.string(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.getThread(input.sessionId)),
+            }],
+    }));
+    server.tool("list_requests", "List persisted runtime requests.", {
+        agentId: z.string().optional(),
+        sessionId: z.string().optional(),
+        state: z.enum(["queued", "running", "waiting_for_approval", "completed", "failed", "cancelled"]).optional(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.listRuns({
+                    ...(input.agentId ? { agentId: input.agentId } : {}),
+                    ...(input.sessionId ? { threadId: input.sessionId } : {}),
+                    ...(input.state ? { state: input.state } : {}),
+                })),
+            }],
+    }));
+    server.tool("get_request", "Get one persisted runtime request by id.", {
+        requestId: z.string(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.getRun(input.requestId)),
+            }],
+    }));
+    server.tool("list_approvals", "List runtime approvals.", {
+        status: z.enum(["pending", "approved", "edited", "rejected", "expired"]).optional(),
+        sessionId: z.string().optional(),
+        requestId: z.string().optional(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.listApprovals({
+                    ...(input.status ? { status: input.status } : {}),
+                    ...(input.sessionId ? { threadId: input.sessionId } : {}),
+                    ...(input.requestId ? { runId: input.requestId } : {}),
+                })),
+            }],
+    }));
+    server.tool("get_approval", "Get one runtime approval by id.", {
+        approvalId: z.string(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.getApproval(input.approvalId)),
+            }],
+    }));
+    server.tool("resolve_approval", "Resolve one runtime approval.", {
+        approvalId: z.string(),
+        decision: z.enum(["approve", "edit", "reject"]),
+        sessionId: z.string().optional(),
+        requestId: z.string().optional(),
+        editedInput: z.record(z.string(), z.any()).optional(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.resume({
+                    approvalId: input.approvalId,
+                    decision: input.decision,
+                    ...(input.sessionId ? { threadId: input.sessionId } : {}),
+                    ...(input.requestId ? { runId: input.requestId } : {}),
+                    ...(input.editedInput ? { editedInput: input.editedInput } : {}),
+                })),
+            }],
+    }));
+    server.tool("list_artifacts", "List artifacts for one runtime request.", {
+        sessionId: z.string(),
+        requestId: z.string(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.listArtifacts(input.sessionId, input.requestId)),
+            }],
+    }));
+    server.tool("read_artifact", "Read one runtime artifact.", {
+        sessionId: z.string(),
+        requestId: z.string(),
+        artifactPath: z.string(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.readArtifact(input.sessionId, input.requestId, input.artifactPath)),
+            }],
+    }));
+    server.tool("list_run_events", "List persisted runtime events for one request.", {
+        sessionId: z.string(),
+        requestId: z.string(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.listRunEvents(input.sessionId, input.requestId)),
+            }],
+    }));
+    server.tool("export_run_package", "Export a stable runtime run package for one request.", {
+        sessionId: z.string(),
+        requestId: z.string(),
+        includeArtifacts: z.boolean().optional(),
+        includeArtifactContents: z.boolean().optional(),
+        includeRuntimeHealth: z.boolean().optional(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.exportRunPackage(input)),
+            }],
+    }));
+    server.tool("export_session_package", "Export a stable runtime session package.", {
+        sessionId: z.string(),
+        includeArtifacts: z.boolean().optional(),
+        includeArtifactContents: z.boolean().optional(),
+        includeRuntimeHealth: z.boolean().optional(),
+    }, async (input) => ({
+        content: [{
+                type: "text",
+                text: renderToolOutput(await runtime.exportSessionPackage(input)),
+            }],
+    }));
+    return server;
+}
+export async function serveRuntimeMcpOverStdio(runtime, options = {}) {
+    const server = await createRuntimeMcpServer(runtime, options);
+    await server.connect(new StdioServerTransport());
+    return server;
+}

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.165";
+export declare const AGENT_HARNESS_VERSION = "0.0.167";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.165";
+export const AGENT_HARNESS_VERSION = "0.0.167";

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -1,4 +1,4 @@
-import { isToolCallParseFailure, sanitizeVisibleText, } from "../../parsing/output-parsing.js";
+import { isToolCallRecoveryFailure, sanitizeVisibleText, } from "../../parsing/output-parsing.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
@@ -82,7 +82,7 @@ export async function* streamRuntimeExecution(options) {
             error.message.includes("does not support tool binding")) {
             throw error;
         }
-        if (!isToolCallParseFailure(error)) {
+        if (!isToolCallRecoveryFailure(error)) {
             throw error;
         }
         const retried = await options.invoke(options.applyStrictToolJsonInstruction(options.binding), options.input, options.threadId, options.runtimeOptions.runId ?? options.threadId, undefined, options.history, options.runtimeOptions);

package/dist/runtime/adapter/runtime-shell.js

@@ -1,5 +1,5 @@
 import { setTimeout as sleep } from "node:timers/promises";
-import { extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION } from "../parsing/output-parsing.js";
+import { extractVisibleOutput, isToolCallRecoveryFailure, STRICT_TOOL_JSON_INSTRUCTION } from "../parsing/output-parsing.js";
 import { readStreamDelta } from "../parsing/stream-event-parsing.js";
 import { computeRemainingTimeoutMs, isRetryableProviderError, resolveProviderRetryPolicy } from "./resilience.js";
 import { isDeepAgentBinding, isLangChainBinding, withUpdatedBindingExecutionParams, } from "../support/compiled-binding.js";
@@ -153,7 +153,7 @@ export async function callRuntimeWithToolParseRecovery(input) {
         return await input.callRuntime(input.binding, input.request);
     }
     catch (error) {
-        if (input.resumePayload !== undefined || !isToolCallParseFailure(error)) {
+        if (input.resumePayload !== undefined || !isToolCallRecoveryFailure(error)) {
             throw error;
         }
         return input.callRuntime(applyStrictToolJsonInstruction(input.binding), input.request);

package/dist/runtime/harness.d.ts

@@ -1,5 +1,5 @@
 import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRunPackage, RuntimeRunPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
-import { type ToolMcpServerOptions } from "../mcp.js";
+import { type RuntimeMcpServerOptions, type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
 export declare class AgentHarnessRuntime {
@@ -99,6 +99,8 @@ export declare class AgentHarnessRuntime {
     deleteThread(threadId: string): Promise<boolean>;
     createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
+    createRuntimeMcpServer(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
+    serveRuntimeMcpOverStdio(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     routeAgent(input: MessageContent, options?: {
         threadId?: string;
     }): Promise<string>;

package/dist/runtime/harness.js

@@ -22,7 +22,7 @@ import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-
 import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
 import { getDefaultRuntimeEntryAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
 import { resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
-import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
+import { createRuntimeMcpServer, createToolMcpServerFromTools, serveRuntimeMcpOverStdio, serveToolsOverStdioFromHarness, } from "../mcp.js";
 import { closeMcpClientsForWorkspace } from "../resource/mcp-tool-support.js";
 import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
@@ -653,6 +653,12 @@ export class AgentHarnessRuntime {
         const tools = this.resolveToolMcpServerTools(options.agentId);
         return serveToolsOverStdioFromHarness(tools, options);
     }
+    async createRuntimeMcpServer(options = {}) {
+        return createRuntimeMcpServer(this, options);
+    }
+    async serveRuntimeMcpOverStdio(options = {}) {
+        return serveRuntimeMcpOverStdio(this, options);
+    }
     async routeAgent(input, options = {}) {
         return routeAgentId({
             workspace: this.workspace,

package/dist/runtime/parsing/output-parsing.d.ts

@@ -10,6 +10,8 @@ export declare function extractOutputContent(value: unknown): unknown;
 export declare function extractContentBlocks(value: unknown): unknown[];
 export declare function extractEmptyAssistantMessageFailure(value: unknown): string;
 export declare function isToolCallParseFailure(error: unknown): boolean;
+export declare function isToolCallValidationFailure(error: unknown): boolean;
+export declare function isToolCallRecoveryFailure(error: unknown): boolean;
 export declare const STRICT_TOOL_JSON_INSTRUCTION = "When calling tools, return only the tool call itself. The arguments must be a pure JSON object with no explanatory text before or after it.";
 export declare function wrapResolvedModel<T>(value: T): T;
 export declare function extractReasoningText(value: unknown): string;

package/dist/runtime/parsing/output-parsing.js

@@ -492,6 +492,28 @@ export function isToolCallParseFailure(error) {
         return false;
     return /error parsing tool call:/i.test(error.message);
 }
+function isStructuredValidationIssue(value) {
+    if (typeof value !== "object" || !value || Array.isArray(value)) {
+        return false;
+    }
+    const typed = value;
+    return typeof typed.code === "string" && Array.isArray(typed.path) && (typed.message === undefined || typeof typed.message === "string");
+}
+export function isToolCallValidationFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.trim();
+    if (!message)
+        return false;
+    const direct = tryParseJson(message);
+    if (Array.isArray(direct) && direct.length > 0 && direct.every((issue) => isStructuredValidationIssue(issue) && issue.path.length > 0)) {
+        return true;
+    }
+    return /Invalid input:\s*expected .* received undefined/i.test(message) && /"path"\s*:\s*\[/.test(message);
+}
+export function isToolCallRecoveryFailure(error) {
+    return isToolCallParseFailure(error) || isToolCallValidationFailure(error);
+}
 export const STRICT_TOOL_JSON_INSTRUCTION = "When calling tools, return only the tool call itself. The arguments must be a pure JSON object with no explanatory text before or after it.";
 function appendStrictToolInstruction(input) {
     if (Array.isArray(input)) {
@@ -518,7 +540,7 @@ export function wrapResolvedModel(value) {
                         return normalizeAgentMessage(await member.apply(currentTarget, args));
                     }
                     catch (error) {
-                        if (!isToolCallParseFailure(error)) {
+                        if (!isToolCallRecoveryFailure(error)) {
                             throw error;
                         }
                         const retryArgs = [...args];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.166",
+  "version": "0.0.168",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",