@botbotgo/agent-harness 0.0.100 → 0.0.102

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() {
@@ -81,13 +77,14 @@ function listProviderTools(provider) {
         toolPath: tool.toolPath ?? tool.builtinPath ?? "",
     }));
 }
+function preferProviderValue(provider, primary, fallback) {
+    return provider ? (primary(provider) ?? fallback(provider)) : undefined;
+}
 function createProviderToolResolver(provider, workspace, options) {
-    return (provider?.createResourceToolResolver?.(workspace, options) ??
-        provider?.createBuiltinToolResolver?.(workspace, options));
+    return preferProviderValue(provider, (candidate) => candidate.createResourceToolResolver?.(workspace, options), (candidate) => candidate.createBuiltinToolResolver?.(workspace, options));
 }
 function createProviderBackendResolver(provider, workspace) {
-    return (provider?.createResourceBackendResolver?.(workspace) ??
-        provider?.createBuiltinBackendResolver?.(workspace));
+    return preferProviderValue(provider, (candidate) => candidate.createResourceBackendResolver?.(workspace), (candidate) => candidate.createBuiltinBackendResolver?.(workspace));
 }
 class CompatibleCompositeBackend {
     id;
@@ -133,69 +130,66 @@ class CompatibleCompositeBackend {
         return this.composite.downloadFiles(paths);
     }
 }
+const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.';
+function unsupportedInlineBackend(kind) {
+    throw new Error(INLINE_BACKEND_ERROR.replace("%s", kind));
+}
+function resolveInlineBackendRootDir(workspaceRoot, configuredRootDir) {
+    if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
+        return path.isAbsolute(configuredRootDir)
+            ? configuredRootDir
+            : path.resolve(workspaceRoot, configuredRootDir);
+    }
+    return workspaceRoot;
+}
+function createLocalShellStyleBackend(workspaceRoot, config, options) {
+    const rootDir = resolveInlineBackendRootDir(workspaceRoot, config?.rootDir);
+    mkdirSync(rootDir, { recursive: true });
+    const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
+    return new LocalShellBackend({
+        rootDir,
+        virtualMode: options.virtualMode,
+        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
+        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
+        env: createRuntimeEnv(readStringRecord(config?.env), inheritedEnv),
+        inheritEnv: config?.inheritEnv !== false,
+    });
+}
+function createInlineBackendInstance(workspaceRoot, kind, config, runtimeLike) {
+    switch (kind) {
+        case "LocalShellBackend":
+            return createLocalShellStyleBackend(workspaceRoot, config, {
+                virtualMode: config?.virtualMode === true,
+            });
+        case "VfsSandbox":
+            return createLocalShellStyleBackend(workspaceRoot, config, {
+                virtualMode: config?.virtualMode === false ? false : true,
+            });
+        case "StateBackend":
+            return new StateBackend(runtimeLike);
+        case "StoreBackend":
+            return new StoreBackend(runtimeLike);
+        default:
+            return unsupportedInlineBackend(kind);
+    }
+}
 function createInlineBackendResolver(workspace) {
     return (binding) => {
         const backendConfig = binding.deepAgentParams?.backend;
         if (!backendConfig || typeof backendConfig !== "object") {
             return undefined;
         }
-        const resolveBackendRootDir = (configuredRootDir) => {
-            if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
-                return path.isAbsolute(configuredRootDir)
-                    ? configuredRootDir
-                    : path.resolve(workspace.workspaceRoot, configuredRootDir);
-            }
-            return workspace.workspaceRoot;
-        };
-        const createBackend = (kind, config, runtimeLike) => {
-            const configuredEnv = typeof config?.env === "object" && config.env
-                ? Object.fromEntries(Object.entries(config.env).filter((entry) => typeof entry[1] === "string"))
-                : undefined;
-            const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
-            switch (kind) {
-                case "LocalShellBackend": {
-                    const rootDir = resolveBackendRootDir(config?.rootDir);
-                    mkdirSync(rootDir, { recursive: true });
-                    return new LocalShellBackend({
-                        rootDir,
-                        virtualMode: config?.virtualMode === true,
-                        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
-                        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
-                        inheritEnv: config?.inheritEnv !== false,
-                    });
-                }
-                case "VfsSandbox": {
-                    const rootDir = resolveBackendRootDir(config?.rootDir);
-                    mkdirSync(rootDir, { recursive: true });
-                    return new LocalShellBackend({
-                        rootDir,
-                        virtualMode: config?.virtualMode === false ? false : true,
-                        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
-                        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
-                        inheritEnv: config?.inheritEnv !== false,
-                    });
-                }
-                case "StateBackend":
-                    return new StateBackend(runtimeLike);
-                case "StoreBackend":
-                    return new StoreBackend(runtimeLike);
-                default:
-                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.`);
-            }
-        };
         return (runtimeLike) => {
             const kind = typeof backendConfig.kind === "string" ? backendConfig.kind : "CompositeBackend";
             switch (kind) {
                 case "LocalShellBackend":
-                    return createBackend("LocalShellBackend", backendConfig, runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "LocalShellBackend", backendConfig, runtimeLike);
                 case "VfsSandbox":
-                    return createBackend("VfsSandbox", backendConfig, runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "VfsSandbox", backendConfig, runtimeLike);
                 case "StateBackend":
-                    return new StateBackend(runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StateBackend", backendConfig, runtimeLike);
                 case "StoreBackend":
-                    return new StoreBackend(runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StoreBackend", backendConfig, runtimeLike);
                 case "CompositeBackend": {
                     const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
                         ? backendConfig.state
@@ -206,12 +200,12 @@ function createInlineBackendResolver(workspace) {
                         : { "/memories/": { kind: "StoreBackend" } };
                     const mappedRoutes = Object.fromEntries(Object.entries(routes).map(([route, routeConfig]) => {
                         const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
-                        return [route, createBackend(routeKind, routeConfig, runtimeLike)];
+                        return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
                     }));
-                    return new CompatibleCompositeBackend(createBackend(defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
+                    return new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
                 }
                 default:
-                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.`);
+                    return unsupportedInlineBackend(kind);
             }
         };
     };
@@ -239,7 +233,23 @@ async function findPackageRoot(startPath) {
     }
 }
 const functionToolModuleCache = new Map();
-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 listWorkspaceResourceProviders(workspace) {
+    return (workspace.resourceSources ?? [])
+        .map((source) => remoteResourceCache.get(source))
+        .filter((provider) => Boolean(provider));
+}
+function createWorkspaceProviderResolvers(workspace, factory) {
+    return listWorkspaceResourceProviders(workspace)
+        .map((provider) => factory(provider))
+        .filter((resolver) => Boolean(resolver));
+}
 async function loadFunctionToolModule(tool) {
     const cacheKey = `${tool.sourcePath}:${tool.implementationName ?? tool.id}`;
     const cached = functionToolModuleCache.get(cacheKey);
@@ -257,132 +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;
-    }
-    const envRecord = typeof mcpServer.env === "object" && mcpServer.env
-        ? Object.fromEntries(Object.entries(mcpServer.env).filter((entry) => typeof entry[1] === "string"))
-        : undefined;
-    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: envRecord,
-        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: typeof mcpServer.headers === "object" && mcpServer.headers
-            ? Object.fromEntries(Object.entries(mcpServer.headers).filter((entry) => typeof entry[1] === "string"))
-            : undefined,
-    };
-}
-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))
@@ -411,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") {
@@ -514,11 +361,11 @@ export async function ensureResourceSources(sources = [], workspaceRoot = proces
 }
 export function defaultResourceSkillsRoot() {
     const provider = requireLocalResource("default resource skill resolution");
-    return provider.defaultResourceSkillsRoot?.() ?? provider.builtinSkillsRoot?.() ?? "";
+    return preferProviderValue(provider, (candidate) => candidate.defaultResourceSkillsRoot?.(), (candidate) => candidate.builtinSkillsRoot?.()) ?? "";
 }
 export function defaultResourceConfigRoot() {
     const provider = requireLocalResource("default resource config resolution");
-    return provider.defaultResourceConfigRoot?.() ?? provider.builtinConfigRoot?.() ?? provider.builtinDefaultsRoot?.() ?? "";
+    return (preferProviderValue(provider, (candidate) => candidate.defaultResourceConfigRoot?.(), (candidate) => candidate.builtinConfigRoot?.() ?? candidate.builtinDefaultsRoot?.()) ?? "");
 }
 export async function listResourceTools(sources = [], workspaceRoot = process.cwd()) {
     await ensureResourceSources(sources, workspaceRoot);
@@ -539,11 +386,7 @@ export async function listResourceToolsForSource(source, workspaceRoot = process
 }
 export function createResourceBackendResolver(workspace) {
     const localResolver = createProviderBackendResolver(localResource, workspace);
-    const remoteResolvers = (workspace.resourceSources ?? [])
-        .map((source) => remoteResourceCache.get(source))
-        .filter((provider) => Boolean(provider))
-        .map((provider) => createProviderBackendResolver(provider, workspace))
-        .filter((resolver) => Boolean(resolver));
+    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderBackendResolver(provider, workspace));
     const inlineResolver = createInlineBackendResolver(workspace);
     return (binding) => {
         const providerResolved = localResolver?.(binding) ??
@@ -555,11 +398,7 @@ export function createResourceToolResolver(workspace, options = {}) {
     const functionResolver = createFunctionToolResolver(workspace);
     const mcpResolver = createMcpToolResolver(workspace);
     const localResolver = createProviderToolResolver(localResource, workspace, options);
-    const remoteResolvers = (workspace.resourceSources ?? [])
-        .map((source) => remoteResourceCache.get(source))
-        .filter((provider) => Boolean(provider))
-        .map((provider) => createProviderToolResolver(provider, workspace, options))
-        .filter((resolver) => Boolean(resolver));
+    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderToolResolver(provider, workspace, options));
     return (toolIds, binding) => {
         const resolved = [
             ...functionResolver(toolIds, binding),

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,
+    });
+}