@botbotgo/agent-harness 0.0.165 → 0.0.167

package/README.md

@@ -28,7 +28,7 @@
 
 <p align="center">
   <a href="https://botbotgo.github.io/agent-harness/development/">Developer docs</a>
-  (multi-page static docs in <code>docs/development/</code>)
+  (<code>docs/development/</code>, English / 中文)
 </p>
 
 <p align="center">
@@ -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

@@ -28,7 +28,7 @@
 
 <p align="center">
   <a href="https://botbotgo.github.io/agent-harness/development/">开发文档</a>
-  （多页面静态文档位于 <code>docs/development/</code>）
+  （多页面静态文档位于 <code>docs/development/</code>，支持 English / 中文）
 </p>
 
 <p align="center">
@@ -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.164";
+export declare const AGENT_HARNESS_VERSION = "0.0.166";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.164";
+export const AGENT_HARNESS_VERSION = "0.0.166";

package/dist/runtime/adapter/local-tool-invocation.js

@@ -49,7 +49,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
             }
             const compiledTool = toolCatalog.get(toolCall.name) ?? toolCatalog.get(resolvedToolName);
-            const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema);
+            const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema, toolCall.rawArgsInput);
             const toolResult = await activeExecutable.invoke(normalizedArgs);
             const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
             executedToolResults.push({

package/dist/runtime/adapter/tool/tool-arguments.d.ts

@@ -1,7 +1,8 @@
 export declare function stringifyToolOutput(output: unknown): string;
-export declare function normalizeToolArgsForSchema(args: Record<string, unknown>, schema: unknown): Record<string, unknown>;
+export declare function normalizeToolArgsForSchema(args: Record<string, unknown>, schema: unknown, rawArgsInput?: unknown): Record<string, unknown>;
 export declare function extractToolCallsFromResult(result: unknown): Array<{
     id?: string;
     name: string;
     args: Record<string, unknown>;
+    rawArgsInput?: unknown;
 }>;

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -14,7 +14,29 @@ export function stringifyToolOutput(output) {
         return `${String(output)}`;
     }
 }
-export function normalizeToolArgsForSchema(args, schema) {
+function mapSingleFieldScalarArg(args, expectedKey, rawArgsInput) {
+    if (expectedKey in args) {
+        return args;
+    }
+    if (typeof rawArgsInput === "string") {
+        const trimmed = rawArgsInput.trim();
+        if (trimmed.length === 0) {
+            return args;
+        }
+        return {
+            ...args,
+            [expectedKey]: trimmed,
+        };
+    }
+    if (typeof rawArgsInput === "number" || typeof rawArgsInput === "boolean") {
+        return {
+            ...args,
+            [expectedKey]: rawArgsInput,
+        };
+    }
+    return args;
+}
+export function normalizeToolArgsForSchema(args, schema, rawArgsInput) {
     const schemaDef = isObject(schema) ? schema._def : undefined;
     const shape = schemaDef
         ? isRecord(schemaDef.shape)
@@ -34,19 +56,23 @@ export function normalizeToolArgsForSchema(args, schema) {
     if (expectedKey in args) {
         return args;
     }
+    const scalarMappedArgs = mapSingleFieldScalarArg(args, expectedKey, rawArgsInput);
+    if (expectedKey in scalarMappedArgs) {
+        return scalarMappedArgs;
+    }
     const aliasesByExpected = {
         city: ["location", "locality", "place"],
         location: ["city", "city_name"],
         query: ["question", "prompt", "text", "request"],
     };
     const aliases = aliasesByExpected[expectedKey] ?? [];
-    const aliasKey = aliases.find((candidate) => candidate in args);
-    if (!aliasKey || !(aliasKey in args)) {
-        return args;
+    const aliasKey = aliases.find((candidate) => candidate in scalarMappedArgs);
+    if (!aliasKey || !(aliasKey in scalarMappedArgs)) {
+        return scalarMappedArgs;
     }
     return {
-        ...args,
-        [expectedKey]: args[aliasKey],
+        ...scalarMappedArgs,
+        [expectedKey]: scalarMappedArgs[aliasKey],
     };
 }
 export function extractToolCallsFromResult(result) {
@@ -75,12 +101,13 @@ export function extractToolCallsFromResult(result) {
         if (!name) {
             return null;
         }
-        const rawArgs = salvageToolArgs(toolCall.args ?? functionPayload?.arguments) ?? {};
+        const rawArgsInput = toolCall.args ?? functionPayload?.arguments;
+        const rawArgs = salvageToolArgs(rawArgsInput) ?? {};
         if (!isObject(rawArgs)) {
             return null;
         }
         const id = typeof toolCall.id === "string" ? toolCall.id : undefined;
-        return { id, name, args: rawArgs };
+        return { id, name, args: rawArgs, rawArgsInput };
     })
         .filter((item) => item !== null);
 }

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/package.json

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