@botbotgo/agent-harness 0.0.309 → 0.0.310

package/dist/resource/backend/workspace-scoped-backend.js

@@ -0,0 +1,296 @@
+import { mkdirSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { CompositeBackend, LangSmithSandbox, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
+import { getBindingBackendConfig } from "../../runtime/support/compiled-binding.js";
+import { createRuntimeEnv } from "../../runtime/env/runtime-env.js";
+function listVirtualRootEntries(rootDir) {
+    try {
+        return new Set(readdirSync(rootDir, { withFileTypes: true }).map((entry) => entry.name));
+    }
+    catch {
+        return new Set();
+    }
+}
+function normalizeVirtualExecuteCommand(command, rootDir) {
+    if (typeof command !== "string" || command.length === 0) {
+        return command;
+    }
+    const rootEntries = listVirtualRootEntries(rootDir);
+    if (rootEntries.size === 0) {
+        return command;
+    }
+    return command.replace(/(^|[\s=:(\[{,;|&])(?<quote>["']?)(?<virtualPath>\/(?:[^\s"'`;|&()<>]+))(?:\k<quote>)/g, (match, prefix, quote = "", virtualPath) => {
+        const normalizedVirtualPath = virtualPath.replace(/\/+/g, "/");
+        const segments = normalizedVirtualPath.split("/").filter((segment) => segment.length > 0);
+        const firstSegment = segments[0];
+        if (!firstSegment || !rootEntries.has(firstSegment)) {
+            return match;
+        }
+        const translatedPath = path.resolve(rootDir, ...segments);
+        return `${prefix}${quote}${translatedPath}${quote}`;
+    });
+}
+export function normalizeWorkspaceScopedPath(rootDir, inputPath) {
+    if (typeof inputPath !== "string" || inputPath.length === 0 || !path.isAbsolute(inputPath)) {
+        return inputPath;
+    }
+    if (inputPath === "/") {
+        return ".";
+    }
+    const virtualSegments = inputPath.replace(/\/+/g, "/").split("/").filter((segment) => segment.length > 0);
+    if (virtualSegments.length > 0) {
+        const rootEntries = listVirtualRootEntries(rootDir);
+        const firstSegment = virtualSegments[0];
+        if (rootEntries.has(firstSegment)) {
+            return path.join(...virtualSegments);
+        }
+    }
+    const normalizedRootDir = path.resolve(rootDir);
+    const normalizedInputPath = path.resolve(inputPath);
+    if (normalizedInputPath === normalizedRootDir || normalizedInputPath.startsWith(`${normalizedRootDir}${path.sep}`)) {
+        return path.relative(normalizedRootDir, normalizedInputPath) || ".";
+    }
+    throw new Error(`Path '${inputPath}' is outside the workspace root '${normalizedRootDir}'. Use a workspace-relative path instead.`);
+}
+function normalizeWorkspaceScopedNullablePath(rootDir, inputPath) {
+    return typeof inputPath === "string" ? normalizeWorkspaceScopedPath(rootDir, inputPath) : inputPath;
+}
+export class WorkspaceScopedBackend {
+    backend;
+    id;
+    cwd;
+    rootDir;
+    root;
+    virtualMode;
+    execute;
+    constructor(backend, rootDir) {
+        this.backend = backend;
+        this.rootDir = path.resolve(rootDir);
+        this.root = this.rootDir;
+        this.cwd = this.rootDir;
+        this.id = typeof backend.id === "string" ? backend.id : undefined;
+        this.virtualMode = backend.virtualMode === true;
+        this.execute = typeof backend.execute === "function"
+            ? (command) => backend.execute(command)
+            : undefined;
+    }
+    ls(filePath) {
+        return this.backend.ls(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+    }
+    read(filePath, offset, limit) {
+        return this.backend.read(normalizeWorkspaceScopedPath(this.rootDir, filePath), offset, limit);
+    }
+    readRaw(filePath) {
+        return this.backend.readRaw(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+    }
+    grep(pattern, filePath, glob) {
+        return this.backend.grep(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+    }
+    grepRaw(pattern, filePath, glob) {
+        return this.backend.grepRaw(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+    }
+    glob(pattern, filePath) {
+        return this.backend.glob(pattern, typeof filePath === "string" ? normalizeWorkspaceScopedPath(this.rootDir, filePath) : filePath);
+    }
+    write(filePath, content) {
+        return this.backend.write(normalizeWorkspaceScopedPath(this.rootDir, filePath), content);
+    }
+    edit(filePath, oldString, newString, replaceAll) {
+        return this.backend.edit(normalizeWorkspaceScopedPath(this.rootDir, filePath), oldString, newString, replaceAll);
+    }
+    uploadFiles(files) {
+        return this.backend.uploadFiles(files);
+    }
+    downloadFiles(paths) {
+        const normalizedPaths = Array.isArray(paths) ? paths.map((currentPath) => normalizeWorkspaceScopedPath(this.rootDir, currentPath)) : paths;
+        return this.backend.downloadFiles(normalizedPaths);
+    }
+}
+class CompatibleCompositeBackend {
+    id;
+    execute;
+    composite;
+    constructor(defaultBackend, routes) {
+        this.composite = new CompositeBackend(defaultBackend, routes);
+        const sandboxLike = defaultBackend;
+        if (typeof sandboxLike.id === "string" && typeof sandboxLike.execute === "function") {
+            this.id = sandboxLike.id;
+            const virtualCwd = typeof sandboxLike.cwd === "string" && sandboxLike.virtualMode === true ? sandboxLike.cwd : null;
+            this.execute =
+                virtualCwd
+                    ? (command) => this.composite.execute(normalizeVirtualExecuteCommand(command, virtualCwd))
+                    : (command) => this.composite.execute(command);
+        }
+    }
+    ls(filePath) {
+        return this.composite.ls(filePath);
+    }
+    read(filePath, offset, limit) {
+        return this.composite.read(filePath, offset, limit);
+    }
+    readRaw(filePath) {
+        return this.composite.readRaw(filePath);
+    }
+    grep(pattern, filePath, glob) {
+        return this.composite.grep(pattern, filePath ?? undefined, glob ?? undefined);
+    }
+    glob(pattern, filePath) {
+        return this.composite.glob(pattern, filePath);
+    }
+    write(filePath, content) {
+        return this.composite.write(filePath, content);
+    }
+    edit(filePath, oldString, newString, replaceAll) {
+        return this.composite.edit(filePath, oldString, newString, replaceAll);
+    }
+    uploadFiles(files) {
+        return this.composite.uploadFiles(files);
+    }
+    downloadFiles(paths) {
+        return this.composite.downloadFiles(paths);
+    }
+}
+function omitKind(config) {
+    const { kind: _kind, ...rest } = config ?? {};
+    return rest;
+}
+class LazyLangSmithSandbox {
+    config;
+    sandboxPromise = null;
+    constructor(config) {
+        this.config = config;
+    }
+    get id() {
+        return "langsmith-pending";
+    }
+    get isRunning() {
+        return this.sandboxPromise !== null;
+    }
+    getSandbox() {
+        if (!this.sandboxPromise) {
+            this.sandboxPromise = LangSmithSandbox.create(omitKind(this.config));
+        }
+        return this.sandboxPromise;
+    }
+    async read(filePath, offset, limit) {
+        return (await this.getSandbox()).read(filePath, offset, limit);
+    }
+    async edit(filePath, oldString, newString, replaceAll) {
+        return (await this.getSandbox()).edit(filePath, oldString, newString, replaceAll);
+    }
+    async ls(dirPath) {
+        return (await this.getSandbox()).ls(dirPath);
+    }
+    async glob(pattern, searchPath) {
+        return (await this.getSandbox()).glob(pattern, searchPath);
+    }
+    async write(filePath, content) {
+        return (await this.getSandbox()).write(filePath, content);
+    }
+    async execute(command) {
+        return (await this.getSandbox()).execute(command);
+    }
+    async uploadFiles(files) {
+        return (await this.getSandbox()).uploadFiles(files);
+    }
+    async downloadFiles(paths) {
+        return (await this.getSandbox()).downloadFiles(paths);
+    }
+    async close() {
+        if (!this.sandboxPromise) {
+            return;
+        }
+        await (await this.sandboxPromise).close();
+    }
+}
+const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend, LangSmithSandbox.';
+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 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 createLocalShellStyleBackend(workspaceRoot, config, options) {
+    const rootDir = resolveInlineBackendRootDir(workspaceRoot, config?.rootDir);
+    mkdirSync(rootDir, { recursive: true });
+    const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
+    return new WorkspaceScopedBackend(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,
+    }), rootDir);
+}
+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);
+        case "LangSmithSandbox":
+            return new LazyLangSmithSandbox(config);
+        default:
+            return unsupportedInlineBackend(kind);
+    }
+}
+export function createInlineBackendResolver(workspace) {
+    return (binding) => {
+        const backendConfig = getBindingBackendConfig(binding);
+        if (!backendConfig || typeof backendConfig !== "object") {
+            return undefined;
+        }
+        return (runtimeLike) => {
+            const kind = typeof backendConfig.kind === "string" ? backendConfig.kind : "CompositeBackend";
+            switch (kind) {
+                case "LocalShellBackend":
+                    return createInlineBackendInstance(workspace.workspaceRoot, "LocalShellBackend", backendConfig, runtimeLike);
+                case "VfsSandbox":
+                    return createInlineBackendInstance(workspace.workspaceRoot, "VfsSandbox", backendConfig, runtimeLike);
+                case "StateBackend":
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StateBackend", backendConfig, runtimeLike);
+                case "StoreBackend":
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StoreBackend", backendConfig, runtimeLike);
+                case "LangSmithSandbox":
+                    return createInlineBackendInstance(workspace.workspaceRoot, "LangSmithSandbox", backendConfig, runtimeLike);
+                case "CompositeBackend": {
+                    const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
+                        ? backendConfig.state
+                        : { kind: "StateBackend" };
+                    const defaultBackendKind = typeof stateConfig.kind === "string" ? stateConfig.kind : "StateBackend";
+                    const routes = typeof backendConfig.routes === "object" && backendConfig.routes
+                        ? backendConfig.routes
+                        : { "/memories/": { kind: "StoreBackend" } };
+                    const mappedRoutes = Object.fromEntries(Object.entries(routes).map(([route, routeConfig]) => {
+                        const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
+                        return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
+                    }));
+                    return new WorkspaceScopedBackend(new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes), workspace.workspaceRoot);
+                }
+                default:
+                    return unsupportedInlineBackend(kind);
+            }
+        };
+    };
+}

package/dist/resource/mcp/tool-support.d.ts

@@ -0,0 +1,35 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { RuntimeAdapterOptions, WorkspaceBundle } from "../../contracts/types.js";
+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>;
+    trustTier?: "trusted" | "reviewed" | "untrusted";
+    access?: "read-only" | "read-write";
+    tenantScope?: "workspace" | "project" | "tenant" | "cross-tenant";
+    approvalPolicy?: "always" | "write" | "never";
+    promptInjectionRisk?: "low" | "medium" | "high";
+    oauth?: {
+        provider?: string;
+        scopes?: string[];
+    };
+    labels?: string[];
+};
+export type McpToolDescriptor = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+export declare function readMcpServerConfig(workspace: WorkspaceBundle, tool: WorkspaceBundle["tools"] extends Map<any, infer T> ? T : never): McpServerConfig | null;
+export declare function getOrCreateMcpClient(config: McpServerConfig): Promise<Client>;
+export declare function closeMcpClientsForWorkspace(workspace: WorkspaceBundle): Promise<void>;
+export declare function __resetMcpClientCacheForTests(): void;
+export declare function __setMcpClientCacheEntryForTests(config: McpServerConfig, clientPromise: Promise<Client>): void;
+export declare function __setMcpClientLoaderForTests(loader: (config: McpServerConfig) => Promise<Client>): void;
+export declare function listRemoteMcpTools(config: McpServerConfig): Promise<McpToolDescriptor[]>;
+export declare function createMcpToolResolver(workspace: WorkspaceBundle): NonNullable<RuntimeAdapterOptions["toolResolver"]>;

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

@@ -0,0 +1,296 @@
+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/env/runtime-env.js";
+const mcpClientCache = new Map();
+let mcpClientLoader = createConnectedMcpClient;
+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 readStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = value.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
+    return entries.length > 0 ? 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,
+            trustTier: server.trustTier,
+            access: server.access,
+            tenantScope: server.tenantScope,
+            approvalPolicy: server.approvalPolicy,
+            promptInjectionRisk: server.promptInjectionRisk,
+            oauth: server.oauth,
+            labels: server.labels,
+        };
+    }
+    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),
+        trustTier: mcpServer.trustTier === "trusted" || mcpServer.trustTier === "reviewed" || mcpServer.trustTier === "untrusted"
+            ? mcpServer.trustTier
+            : undefined,
+        access: mcpServer.access === "read-only" || mcpServer.access === "read-write" ? mcpServer.access : undefined,
+        tenantScope: mcpServer.tenantScope === "workspace" ||
+            mcpServer.tenantScope === "project" ||
+            mcpServer.tenantScope === "tenant" ||
+            mcpServer.tenantScope === "cross-tenant"
+            ? mcpServer.tenantScope
+            : undefined,
+        approvalPolicy: mcpServer.approvalPolicy === "always" || mcpServer.approvalPolicy === "write" || mcpServer.approvalPolicy === "never"
+            ? mcpServer.approvalPolicy
+            : undefined,
+        promptInjectionRisk: mcpServer.promptInjectionRisk === "low" || mcpServer.promptInjectionRisk === "medium" || mcpServer.promptInjectionRisk === "high"
+            ? mcpServer.promptInjectionRisk
+            : undefined,
+        oauth: typeof mcpServer.oauth === "object" && mcpServer.oauth
+            ? {
+                provider: typeof mcpServer.oauth.provider === "string"
+                    ? mcpServer.oauth.provider
+                    : undefined,
+                scopes: readStringArray(mcpServer.oauth.scopes),
+            }
+            : undefined,
+        labels: readStringArray(mcpServer.labels),
+    };
+}
+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 ?? {},
+        trustTier: config.trustTier ?? "",
+        access: config.access ?? "",
+        tenantScope: config.tenantScope ?? "",
+        approvalPolicy: config.approvalPolicy ?? "",
+        promptInjectionRisk: config.promptInjectionRisk ?? "",
+        oauth: config.oauth ?? {},
+        labels: config.labels ?? [],
+    });
+}
+async function createConnectedMcpClient(config) {
+    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;
+}
+function isRecoverableMcpError(error) {
+    if (typeof error !== "object" || error === null) {
+        return false;
+    }
+    const message = typeof error.message === "string"
+        ? (error.message).toLowerCase()
+        : "";
+    const code = typeof error.code === "string"
+        ? (error.code).toLowerCase()
+        : "";
+    return [
+        "connection closed",
+        "transport closed",
+        "socket closed",
+        "stream closed",
+        "network socket disconnected",
+    ].some((pattern) => message.includes(pattern))
+        || ["econnreset", "epipe", "ehostunreach", "ecancelled"].includes(code);
+}
+async function closeCachedMcpClient(cacheKey) {
+    const cached = mcpClientCache.get(cacheKey);
+    mcpClientCache.delete(cacheKey);
+    if (!cached) {
+        return;
+    }
+    try {
+        const client = await cached;
+        await client.close();
+    }
+    catch {
+        // Ignore teardown failures for clients that never connected successfully.
+    }
+}
+async function invalidateMcpClient(config) {
+    await closeCachedMcpClient(createMcpCacheKey(config));
+}
+async function withRecoveredMcpClient(config, operation) {
+    const client = await getOrCreateMcpClient(config);
+    try {
+        return await operation(client);
+    }
+    catch (error) {
+        if (!isRecoverableMcpError(error)) {
+            throw error;
+        }
+        await invalidateMcpClient(config);
+        return operation(await getOrCreateMcpClient(config));
+    }
+}
+export async function getOrCreateMcpClient(config) {
+    const cacheKey = createMcpCacheKey(config);
+    const cached = mcpClientCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const loading = mcpClientLoader(config).catch((error) => {
+        if (mcpClientCache.get(cacheKey) === loading) {
+            mcpClientCache.delete(cacheKey);
+        }
+        throw error;
+    });
+    mcpClientCache.set(cacheKey, loading);
+    return loading;
+}
+export async function closeMcpClientsForWorkspace(workspace) {
+    const cacheKeys = new Set();
+    for (const tool of workspace.tools.values()) {
+        if (tool.type !== "mcp") {
+            continue;
+        }
+        const config = readMcpServerConfig(workspace, tool);
+        if (!config) {
+            continue;
+        }
+        cacheKeys.add(createMcpCacheKey(config));
+    }
+    await Promise.all(Array.from(cacheKeys, (cacheKey) => closeCachedMcpClient(cacheKey)));
+}
+export function __resetMcpClientCacheForTests() {
+    mcpClientCache.clear();
+    mcpClientLoader = createConnectedMcpClient;
+}
+export function __setMcpClientCacheEntryForTests(config, clientPromise) {
+    mcpClientCache.set(createMcpCacheKey(config), clientPromise);
+}
+export function __setMcpClientLoaderForTests(loader) {
+    mcpClientLoader = loader;
+}
+async function getRemoteMcpToolDescriptor(config, remoteToolName) {
+    const result = await withRecoveredMcpClient(config, (client) => 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 result = await withRecoveredMcpClient(config, (client) => 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 result = await withRecoveredMcpClient(serverConfig, (client) => 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/mcp-tool-support.d.ts

@@ -1,35 +1,2 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
-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>;
-    trustTier?: "trusted" | "reviewed" | "untrusted";
-    access?: "read-only" | "read-write";
-    tenantScope?: "workspace" | "project" | "tenant" | "cross-tenant";
-    approvalPolicy?: "always" | "write" | "never";
-    promptInjectionRisk?: "low" | "medium" | "high";
-    oauth?: {
-        provider?: string;
-        scopes?: string[];
-    };
-    labels?: string[];
-};
-export type McpToolDescriptor = {
-    name: string;
-    description?: string;
-    inputSchema?: Record<string, unknown>;
-};
-export declare function readMcpServerConfig(workspace: WorkspaceBundle, tool: WorkspaceBundle["tools"] extends Map<any, infer T> ? T : never): McpServerConfig | null;
-export declare function getOrCreateMcpClient(config: McpServerConfig): Promise<Client>;
-export declare function closeMcpClientsForWorkspace(workspace: WorkspaceBundle): Promise<void>;
-export declare function __resetMcpClientCacheForTests(): void;
-export declare function __setMcpClientCacheEntryForTests(config: McpServerConfig, clientPromise: Promise<Client>): void;
-export declare function __setMcpClientLoaderForTests(loader: (config: McpServerConfig) => Promise<Client>): void;
-export declare function listRemoteMcpTools(config: McpServerConfig): Promise<McpToolDescriptor[]>;
-export declare function createMcpToolResolver(workspace: WorkspaceBundle): NonNullable<RuntimeAdapterOptions["toolResolver"]>;
+export { AGENT_HARNESS_VERSION } from "../package-version.js";
+export * from "./mcp/tool-support.js";