@botbotgo/agent-harness 0.0.101 → 0.0.103

package/dist/resource/mcp-tool-support.js

@@ -0,0 +1,173 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
+import { AGENT_HARNESS_VERSION } from "../package-version.js";
+import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
+const mcpClientCache = new Map();
+function readStringRecord(value) {
+    if (typeof value !== "object" || !value) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function normalizeMcpTransport(value) {
+    if (value === "stdio" || value === "http" || value === "sse" || value === "websocket") {
+        return value;
+    }
+    return undefined;
+}
+export function readMcpServerConfig(workspace, tool) {
+    const mcpConfig = typeof tool.config?.mcp === "object" && tool.config?.mcp
+        ? tool.config.mcp
+        : undefined;
+    const serverRef = typeof mcpConfig?.serverRef === "string" ? mcpConfig.serverRef : undefined;
+    if (serverRef) {
+        const serverId = serverRef.startsWith("mcp/") ? serverRef.slice(4) : serverRef;
+        const server = workspace.mcpServers.get(serverId);
+        if (!server) {
+            throw new Error(`MCP tool ${tool.id} references missing MCP server ${serverRef}`);
+        }
+        return {
+            transport: server.transport,
+            command: server.command,
+            args: server.args,
+            env: server.env,
+            cwd: server.cwd,
+            url: server.url,
+            token: server.token,
+            headers: server.headers,
+        };
+    }
+    const config = typeof tool.config === "object" && tool.config
+        ? tool.config
+        : undefined;
+    const mcpServer = typeof config?.mcpServer === "object" && config.mcpServer
+        ? config.mcpServer
+        : config;
+    if (!mcpServer) {
+        return null;
+    }
+    return {
+        transport: normalizeMcpTransport(mcpServer.transport) ?? ((typeof mcpServer.url === "string" && mcpServer.url.trim()) ? "http" : "stdio"),
+        command: typeof mcpServer.command === "string" ? mcpServer.command.trim() : undefined,
+        args: Array.isArray(mcpServer.args) ? mcpServer.args.filter((item) => typeof item === "string") : undefined,
+        env: readStringRecord(mcpServer.env),
+        cwd: typeof mcpServer.cwd === "string" ? mcpServer.cwd : undefined,
+        url: typeof mcpServer.url === "string" ? mcpServer.url.trim() : undefined,
+        token: typeof mcpServer.token === "string" ? mcpServer.token : undefined,
+        headers: readStringRecord(mcpServer.headers),
+    };
+}
+function createMcpCacheKey(config) {
+    return JSON.stringify({
+        transport: config.transport ?? "stdio",
+        command: config.command,
+        args: config.args ?? [],
+        env: config.env ?? {},
+        cwd: config.cwd ?? "",
+        url: config.url ?? "",
+        token: config.token ?? "",
+        headers: config.headers ?? {},
+    });
+}
+export async function getOrCreateMcpClient(config) {
+    const cacheKey = createMcpCacheKey(config);
+    const cached = mcpClientCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const loading = (async () => {
+        const client = new Client({
+            name: "agent-harness",
+            version: AGENT_HARNESS_VERSION,
+        });
+        const headers = {
+            ...(config.headers ?? {}),
+            ...(config.token ? { Authorization: `Bearer ${config.token}` } : {}),
+        };
+        const transport = config.transport === "http"
+            ? new StreamableHTTPClientTransport(new URL(config.url ?? ""), {
+                requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+            })
+            : config.transport === "sse"
+                ? new SSEClientTransport(new URL(config.url ?? ""), {
+                    requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+                })
+                : config.transport === "websocket"
+                    ? new WebSocketClientTransport(new URL(config.url ?? ""))
+                    : new StdioClientTransport({
+                        command: config.command ?? "",
+                        args: config.args,
+                        env: createRuntimeEnv(config.env),
+                        cwd: config.cwd,
+                    });
+        await client.connect(transport);
+        return client;
+    })();
+    mcpClientCache.set(cacheKey, loading);
+    return loading;
+}
+async function getRemoteMcpToolDescriptor(config, remoteToolName) {
+    const client = await getOrCreateMcpClient(config);
+    const result = await client.listTools();
+    const tool = result.tools.find((item) => typeof item.name === "string" && item.name === remoteToolName);
+    if (!tool || typeof tool.name !== "string") {
+        return null;
+    }
+    return {
+        name: tool.name,
+        description: typeof tool.description === "string" ? tool.description : undefined,
+        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
+    };
+}
+export async function listRemoteMcpTools(config) {
+    const client = await getOrCreateMcpClient(config);
+    const result = await client.listTools();
+    return result.tools
+        .filter((tool) => typeof tool.name === "string")
+        .map((tool) => ({
+        name: tool.name,
+        description: typeof tool.description === "string" ? tool.description : undefined,
+        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
+    }));
+}
+export function createMcpToolResolver(workspace) {
+    const mcpTools = new Map(Array.from(workspace.tools.values())
+        .filter((tool) => tool.type === "mcp")
+        .map((tool) => [tool.id, tool]));
+    return (toolIds) => toolIds.flatMap((toolId) => {
+        const tool = mcpTools.get(toolId);
+        if (!tool) {
+            return [];
+        }
+        const serverConfig = readMcpServerConfig(workspace, tool);
+        if (!serverConfig) {
+            throw new Error(`MCP tool ${tool.id} must define mcp.serverRef or inline MCP server config.`);
+        }
+        const remoteToolName = tool.mcpRef ?? tool.name;
+        const descriptorPromise = getRemoteMcpToolDescriptor(serverConfig, remoteToolName);
+        return [
+            {
+                name: tool.name,
+                description: tool.description,
+                inputSchemaPromise: descriptorPromise.then((descriptor) => descriptor?.inputSchema),
+                async invoke(input) {
+                    const client = await getOrCreateMcpClient(serverConfig);
+                    const result = await client.callTool({
+                        name: remoteToolName,
+                        arguments: typeof input === "object" && input !== null ? input : {},
+                    });
+                    const textParts = Array.isArray(result.content)
+                        ? result.content
+                            .filter((item) => typeof item === "object" && item !== null && "type" in item)
+                            .flatMap((item) => item.type === "text" && typeof item.text === "string" ? [item.text] : [])
+                        : [];
+                    return textParts.length > 0 ? textParts.join("\n\n") : JSON.stringify(result);
+                },
+            },
+        ];
+    });
+}

package/dist/resource/resource-impl.d.ts

@@ -1,5 +1,5 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
+export { getOrCreateMcpClient, listRemoteMcpTools, readMcpServerConfig, type McpServerConfig, type McpToolDescriptor, } from "./mcp-tool-support.js";
 export declare function resolveLocalResourceProviderEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
 export type ResourceToolInfo = {
     toolPath: string;
@@ -12,23 +12,6 @@ export type ResourceToolInfo = {
         allow: Array<"approve" | "edit" | "reject">;
     };
 };
-export type McpServerConfig = {
-    transport?: "stdio" | "http" | "sse" | "websocket";
-    command?: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-    url?: string;
-    token?: string;
-    headers?: Record<string, string>;
-};
-export type McpToolDescriptor = {
-    name: string;
-    description?: string;
-    inputSchema?: Record<string, unknown>;
-};
-export declare function getOrCreateMcpClient(config: McpServerConfig): Promise<Client>;
-export declare function listRemoteMcpTools(config: McpServerConfig): Promise<McpToolDescriptor[]>;
 export declare function ensureResourceSources(sources?: string[], workspaceRoot?: string): Promise<void>;
 export declare function defaultResourceSkillsRoot(): string;
 export declare function defaultResourceConfigRoot(): string;

package/dist/resource/resource-impl.js

@@ -5,16 +5,12 @@ import { stat } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { CompositeBackend, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
-import { AGENT_HARNESS_VERSION } from "../package-version.js";
-import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
 import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
+import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
+import { createMcpToolResolver, } from "./mcp-tool-support.js";
 import { resolveIsolatedResourceModulePath } from "./isolation.js";
 import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
+export { getOrCreateMcpClient, listRemoteMcpTools, readMcpServerConfig, } from "./mcp-tool-support.js";
 const resourceDir = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 function installedResourceProviderEntry() {
@@ -237,7 +233,6 @@ async function findPackageRoot(startPath) {
     }
 }
 const functionToolModuleCache = new Map();
-const mcpClientCache = new Map();
 function readStringRecord(value) {
     if (typeof value !== "object" || !value) {
         return undefined;
@@ -272,127 +267,6 @@ async function loadFunctionToolModule(tool) {
     functionToolModuleCache.set(cacheKey, loading);
     return loading;
 }
-function normalizeMcpTransport(value) {
-    if (value === "stdio" || value === "http" || value === "sse" || value === "websocket") {
-        return value;
-    }
-    return undefined;
-}
-function readMcpServerConfig(workspace, tool) {
-    const mcpConfig = typeof tool.config?.mcp === "object" && tool.config?.mcp
-        ? tool.config.mcp
-        : undefined;
-    const serverRef = typeof mcpConfig?.serverRef === "string" ? mcpConfig.serverRef : undefined;
-    if (serverRef) {
-        const serverId = serverRef.startsWith("mcp/") ? serverRef.slice(4) : serverRef;
-        const server = workspace.mcpServers.get(serverId);
-        if (!server) {
-            throw new Error(`MCP tool ${tool.id} references missing MCP server ${serverRef}`);
-        }
-        return {
-            transport: server.transport,
-            command: server.command,
-            args: server.args,
-            env: server.env,
-            cwd: server.cwd,
-            url: server.url,
-            token: server.token,
-            headers: server.headers,
-        };
-    }
-    const config = typeof tool.config === "object" && tool.config
-        ? tool.config
-        : undefined;
-    const mcpServer = typeof config?.mcpServer === "object" && config.mcpServer
-        ? config.mcpServer
-        : config;
-    if (!mcpServer) {
-        return null;
-    }
-    return {
-        transport: normalizeMcpTransport(mcpServer.transport) ?? ((typeof mcpServer.url === "string" && mcpServer.url.trim()) ? "http" : "stdio"),
-        command: typeof mcpServer.command === "string" ? mcpServer.command.trim() : undefined,
-        args: Array.isArray(mcpServer.args) ? mcpServer.args.filter((item) => typeof item === "string") : undefined,
-        env: readStringRecord(mcpServer.env),
-        cwd: typeof mcpServer.cwd === "string" ? mcpServer.cwd : undefined,
-        url: typeof mcpServer.url === "string" ? mcpServer.url.trim() : undefined,
-        token: typeof mcpServer.token === "string" ? mcpServer.token : undefined,
-        headers: readStringRecord(mcpServer.headers),
-    };
-}
-function createMcpCacheKey(config) {
-    return JSON.stringify({
-        transport: config.transport ?? "stdio",
-        command: config.command,
-        args: config.args ?? [],
-        env: config.env ?? {},
-        cwd: config.cwd ?? "",
-        url: config.url ?? "",
-        token: config.token ?? "",
-        headers: config.headers ?? {},
-    });
-}
-export async function getOrCreateMcpClient(config) {
-    const cacheKey = createMcpCacheKey(config);
-    const cached = mcpClientCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const loading = (async () => {
-        const client = new Client({
-            name: "agent-harness",
-            version: AGENT_HARNESS_VERSION,
-        });
-        const headers = {
-            ...(config.headers ?? {}),
-            ...(config.token ? { Authorization: `Bearer ${config.token}` } : {}),
-        };
-        const transport = config.transport === "http"
-            ? new StreamableHTTPClientTransport(new URL(config.url ?? ""), {
-                requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
-            })
-            : config.transport === "sse"
-                ? new SSEClientTransport(new URL(config.url ?? ""), {
-                    requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
-                })
-                : config.transport === "websocket"
-                    ? new WebSocketClientTransport(new URL(config.url ?? ""))
-                    : new StdioClientTransport({
-                        command: config.command ?? "",
-                        args: config.args,
-                        env: createRuntimeEnv(config.env),
-                        cwd: config.cwd,
-                    });
-        await client.connect(transport);
-        return client;
-    })();
-    mcpClientCache.set(cacheKey, loading);
-    return loading;
-}
-async function getRemoteMcpToolDescriptor(config, remoteToolName) {
-    const client = await getOrCreateMcpClient(config);
-    const result = await client.listTools();
-    const tool = result.tools.find((item) => typeof item.name === "string" && item.name === remoteToolName);
-    if (!tool || typeof tool.name !== "string") {
-        return null;
-    }
-    return {
-        name: tool.name,
-        description: typeof tool.description === "string" ? tool.description : undefined,
-        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
-    };
-}
-export async function listRemoteMcpTools(config) {
-    const client = await getOrCreateMcpClient(config);
-    const result = await client.listTools();
-    return result.tools
-        .filter((tool) => typeof tool.name === "string")
-        .map((tool) => ({
-        name: tool.name,
-        description: typeof tool.description === "string" ? tool.description : undefined,
-        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
-    }));
-}
 function createFunctionToolResolver(workspace) {
     const functionTools = new Map(Array.from(workspace.tools.values())
         .filter((tool) => tool.type === "function" && isSupportedToolModulePath(tool.sourcePath))
@@ -421,43 +295,6 @@ function createFunctionToolResolver(workspace) {
         ];
     });
 }
-function createMcpToolResolver(workspace) {
-    const mcpTools = new Map(Array.from(workspace.tools.values())
-        .filter((tool) => tool.type === "mcp")
-        .map((tool) => [tool.id, tool]));
-    return (toolIds) => toolIds.flatMap((toolId) => {
-        const tool = mcpTools.get(toolId);
-        if (!tool) {
-            return [];
-        }
-        const serverConfig = readMcpServerConfig(workspace, tool);
-        if (!serverConfig) {
-            throw new Error(`MCP tool ${tool.id} must define mcp.serverRef or inline MCP server config.`);
-        }
-        const remoteToolName = tool.mcpRef ?? tool.name;
-        const descriptorPromise = getRemoteMcpToolDescriptor(serverConfig, remoteToolName);
-        return [
-            {
-                name: tool.name,
-                description: tool.description,
-                inputSchemaPromise: descriptorPromise.then((descriptor) => descriptor?.inputSchema),
-                async invoke(input) {
-                    const client = await getOrCreateMcpClient(serverConfig);
-                    const result = await client.callTool({
-                        name: remoteToolName,
-                        arguments: typeof input === "object" && input !== null ? input : {},
-                    });
-                    const textParts = Array.isArray(result.content)
-                        ? result.content
-                            .filter((item) => typeof item === "object" && item !== null && "type" in item)
-                            .flatMap((item) => item.type === "text" && typeof item.text === "string" ? [item.text] : [])
-                        : [];
-                    return textParts.length > 0 ? textParts.join("\n\n") : JSON.stringify(result);
-                },
-            },
-        ];
-    });
-}
 function resolvePackageEntry(packageRoot, pkg) {
     const exportsField = pkg.exports;
     if (typeof exportsField === "string") {

package/dist/runtime/adapter/invoke-runtime.d.ts

@@ -0,0 +1,22 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
+import type { ExecutedToolResult } from "./invocation-result.js";
+import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
+export type ExecutableTool = {
+    name: string;
+    schema: unknown;
+    invoke: (input: unknown) => Promise<unknown>;
+};
+export declare function invokeRuntimeWithLocalTools(options: {
+    binding: CompiledAgentBinding;
+    request: unknown;
+    resumePayload?: unknown;
+    primaryTools: CompiledTool[];
+    defersToUpstreamHitlExecution: boolean;
+    toolNameMapping: ToolNameMapping;
+    executableTools: Map<string, ExecutableTool>;
+    builtinExecutableTools: Map<string, ExecutableTool>;
+    callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+}): Promise<{
+    result: Record<string, unknown>;
+    executedToolResults: ExecutedToolResult[];
+}>;

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

@@ -0,0 +1,18 @@
+import { runLocalToolInvocationLoop } from "./local-tool-invocation.js";
+export async function invokeRuntimeWithLocalTools(options) {
+    if (options.resumePayload !== undefined || options.defersToUpstreamHitlExecution) {
+        return {
+            result: await options.callRuntimeWithToolParseRecovery(options.request),
+            executedToolResults: [],
+        };
+    }
+    return runLocalToolInvocationLoop({
+        binding: options.binding,
+        request: options.request,
+        primaryTools: options.primaryTools,
+        toolNameMapping: options.toolNameMapping,
+        executableTools: options.executableTools,
+        builtinExecutableTools: options.builtinExecutableTools,
+        callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
+    });
+}

package/dist/runtime/adapter/middleware-assembly.d.ts

@@ -0,0 +1,75 @@
+import { FilesystemBackend } from "deepagents";
+import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, DeepAgentParams, RuntimeAdapterOptions } from "../../contracts/types.js";
+import type { ExecutableTool } from "./invoke-runtime.js";
+export declare function resolveBuiltinMiddlewareBackend(input: {
+    binding: CompiledAgentBinding;
+    runtimeAdapterOptions: RuntimeAdapterOptions;
+    resolveFilesystemBackend: (binding: CompiledAgentBinding) => FilesystemBackend;
+    options?: {
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+}): unknown;
+export declare function resolveSubagents(input: {
+    subagents: CompiledSubAgent[];
+    binding?: CompiledAgentBinding;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
+    createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
+}): Promise<CompiledSubAgent[]>;
+export declare function invokeBuiltinTaskTool(input: {
+    binding: CompiledAgentBinding;
+    toolInput: unknown;
+    options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+    resolveBuiltinMiddlewareBackend: (binding: CompiledAgentBinding, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => unknown;
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
+}): Promise<unknown>;
+export declare function resolveBuiltinMiddlewareTools(input: {
+    binding: CompiledAgentBinding;
+    options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+    resolveBuiltinMiddlewareBackend: (binding: CompiledAgentBinding, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => unknown;
+    invokeBuiltinTaskTool: (binding: CompiledAgentBinding, toolInput: unknown, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => Promise<unknown>;
+}): Promise<Map<string, ExecutableTool>>;
+export declare function resolveAutomaticSummarizationMiddleware(input: {
+    binding: CompiledAgentBinding;
+    createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
+}): Promise<unknown[]>;
+export declare function resolveLangChainAutomaticMiddleware(input: {
+    binding: CompiledAgentBinding;
+    resolveAutomaticSummarizationMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
+    resolveFilesystemBackend: (binding: CompiledAgentBinding) => FilesystemBackend;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
+}): Promise<unknown[]>;
+export declare function resolveMiddleware(input: {
+    binding: CompiledAgentBinding;
+    interruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    runtimeAdapterOptions: RuntimeAdapterOptions;
+    createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
+    resolveLangChainAutomaticMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
+}): Promise<unknown[]>;