@slopus/rig 0.0.3 → 0.0.6

package/dist/goals/isGoalStatus.js

@@ -0,0 +1,3 @@
+export function isGoalStatus(value) {
+    return value === "active" || value === "paused" || value === "blocked" || value === "complete";
+}

package/dist/goals/normalizeGoalObjective.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_GOAL_OBJECTIVE_CHARS = 20000;
+export declare function normalizeGoalObjective(objective: string): string;
+//# sourceMappingURL=normalizeGoalObjective.d.ts.map

package/dist/goals/normalizeGoalObjective.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeGoalObjective.d.ts","sourceRoot":"","sources":["../../sources/goals/normalizeGoalObjective.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAE/C,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAWhE"}

package/dist/goals/normalizeGoalObjective.js

@@ -0,0 +1,11 @@
+export const MAX_GOAL_OBJECTIVE_CHARS = 20_000;
+export function normalizeGoalObjective(objective) {
+    const normalized = objective.trim();
+    if (normalized.length === 0) {
+        throw new Error("Goal objective must not be empty.");
+    }
+    if (normalized.length > MAX_GOAL_OBJECTIVE_CHARS) {
+        throw new Error(`Goal objective must be ${MAX_GOAL_OBJECTIVE_CHARS.toLocaleString("en-US")} characters or fewer.`);
+    }
+    return normalized;
+}

package/dist/mcp/McpClientManager.d.ts

@@ -0,0 +1,12 @@
+import type { McpToolLoadResult, McpToolProvider } from "./types.js";
+export interface McpClientManagerOptions {
+    env?: NodeJS.ProcessEnv;
+    homeDirectory?: string;
+}
+export declare class McpClientManager implements McpToolProvider {
+    #private;
+    constructor(options?: McpClientManagerOptions);
+    load(cwd: string): Promise<McpToolLoadResult>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=McpClientManager.d.ts.map

package/dist/mcp/McpClientManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"McpClientManager.d.ts","sourceRoot":"","sources":["../../sources/mcp/McpClientManager.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGR,iBAAiB,EACjB,eAAe,EAClB,MAAM,YAAY,CAAC;AAoBpB,MAAM,WAAW,uBAAuB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,gBAAiB,YAAW,eAAe;;gBAKxC,OAAO,GAAE,uBAA4B;IAK3C,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAU7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAgH/B"}

package/dist/mcp/McpClientManager.js

@@ -0,0 +1,123 @@
+import { connectMcpServer } from "./connectMcpServer.js";
+import { createMcpTool } from "./createMcpTool.js";
+import { loadMcpServerConfigs } from "./loadMcpServerConfigs.js";
+export class McpClientManager {
+    #connectionSets = new Map();
+    #env;
+    #homeDirectory;
+    constructor(options = {}) {
+        this.#env = options.env ?? process.env;
+        this.#homeDirectory = options.homeDirectory;
+    }
+    async load(cwd) {
+        let pending = this.#connectionSets.get(cwd);
+        if (pending === undefined) {
+            pending = this.#loadConnectionSet(cwd);
+            this.#connectionSets.set(cwd, pending);
+        }
+        const loaded = await pending;
+        return { servers: loaded.servers, tools: loaded.tools };
+    }
+    async close() {
+        const sets = await Promise.allSettled(this.#connectionSets.values());
+        this.#connectionSets.clear();
+        await Promise.allSettled(sets.flatMap((set) => set.status === "fulfilled"
+            ? set.value.connections.map((connection) => connection.close())
+            : []));
+    }
+    async #loadConnectionSet(cwd) {
+        const configs = await loadMcpServerConfigs(cwd, {
+            env: this.#env,
+            ...(this.#homeDirectory !== undefined ? { homeDirectory: this.#homeDirectory } : {}),
+        });
+        const entries = Object.entries(configs).sort(([left], [right]) => left.localeCompare(right));
+        const disabledSummaries = entries
+            .filter(([, config]) => config.enabled === false)
+            .map(([name]) => ({ name, status: "disabled", toolCount: 0 }));
+        const results = await Promise.all(entries
+            .filter(([, config]) => config.enabled !== false)
+            .map(([name, config]) => this.#connectServer(name, config, cwd)));
+        const connections = [];
+        const servers = [...disabledSummaries];
+        const tools = [];
+        const toolNames = new Set();
+        for (const result of results) {
+            if ("errorMessage" in result) {
+                servers.push({
+                    errorMessage: result.errorMessage,
+                    name: result.name,
+                    status: "failed",
+                    toolCount: 0,
+                });
+                continue;
+            }
+            const serverTools = result.tools.map((tool) => createMcpTool({
+                client: result.connection.client,
+                serverName: result.name,
+                tool,
+                ...(result.config.toolTimeoutMs !== undefined
+                    ? { timeoutMs: result.config.toolTimeoutMs }
+                    : {}),
+            }));
+            const duplicate = serverTools.find((tool) => toolNames.has(tool.name));
+            const duplicateInsideServer = new Set(serverTools.map((tool) => tool.name)).size !== serverTools.length;
+            if (duplicate !== undefined || duplicateInsideServer) {
+                await result.connection.close().catch(() => undefined);
+                servers.push({
+                    errorMessage: `MCP tool names collide after normalization for server "${result.name}".`,
+                    name: result.name,
+                    status: "failed",
+                    toolCount: 0,
+                });
+                continue;
+            }
+            connections.push(result.connection);
+            for (const tool of serverTools) {
+                toolNames.add(tool.name);
+                tools.push(tool);
+            }
+            servers.push({
+                name: result.name,
+                status: "connected",
+                toolCount: serverTools.length,
+            });
+        }
+        servers.sort((left, right) => left.name.localeCompare(right.name));
+        return { connections, servers, tools };
+    }
+    async #connectServer(name, config, cwd) {
+        let connection;
+        try {
+            connection = await connectMcpServer(name, config, cwd, this.#env);
+            const tools = await listAllTools(connection.client, config.startupTimeoutMs ?? 10_000);
+            const enabled = config.enabledTools === undefined ? undefined : new Set(config.enabledTools);
+            const disabled = new Set(config.disabledTools ?? []);
+            return {
+                config,
+                connection,
+                name,
+                tools: tools.filter((tool) => (enabled === undefined || enabled.has(tool.name)) &&
+                    !disabled.has(tool.name)),
+            };
+        }
+        catch (error) {
+            await connection?.close().catch(() => undefined);
+            return {
+                errorMessage: error instanceof Error ? error.message : String(error),
+                name,
+            };
+        }
+    }
+}
+async function listAllTools(client, timeout) {
+    const tools = [];
+    let cursor;
+    do {
+        const page = await client.listTools(cursor === undefined ? undefined : { cursor }, {
+            timeout,
+        });
+        tools.push(...page.tools);
+        cursor = page.nextCursor;
+    } while (cursor !== undefined);
+    return tools;
+}

package/dist/mcp/connectMcpServer.d.ts

@@ -0,0 +1,8 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { McpServerConfig } from "./types.js";
+export interface ConnectedMcpServer {
+    client: Client;
+    close(): Promise<void>;
+}
+export declare function connectMcpServer(name: string, config: McpServerConfig, cwd: string, env?: NodeJS.ProcessEnv): Promise<ConnectedMcpServer>;
+//# sourceMappingURL=connectMcpServer.d.ts.map

package/dist/mcp/connectMcpServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectMcpServer.d.ts","sourceRoot":"","sources":["../../sources/mcp/connectMcpServer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAKnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,wBAAsB,gBAAgB,CAClC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,MAAM,CAAC,UAAwB,GACrC,OAAO,CAAC,kBAAkB,CAAC,CAe7B"}

package/dist/mcp/connectMcpServer.js

@@ -0,0 +1,47 @@
+import { resolve } from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+export async function connectMcpServer(name, config, cwd, env = process.env) {
+    const client = new Client({ name: "rig", version: "0.0.4" });
+    const transport = createTransport(config, cwd, env);
+    try {
+        await client.connect(transport, { timeout: config.startupTimeoutMs ?? 10_000 });
+    }
+    catch (error) {
+        await transport.close().catch(() => undefined);
+        throw new Error(`MCP server "${name}" could not connect: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return {
+        client,
+        close: () => client.close(),
+    };
+}
+function createTransport(config, cwd, env) {
+    if (config.transport === "stdio") {
+        return new StdioClientTransport({
+            args: [...(config.args ?? [])],
+            command: config.command,
+            cwd: config.cwd === undefined ? cwd : resolve(cwd, config.cwd),
+            env: {
+                ...stringEnvironment(env),
+                ...config.env,
+            },
+            stderr: "ignore",
+        });
+    }
+    const headers = new Headers(config.headers);
+    if (config.bearerTokenEnvVar !== undefined) {
+        const token = env[config.bearerTokenEnvVar];
+        if (token === undefined || token === "") {
+            throw new Error(`MCP bearer token environment variable "${config.bearerTokenEnvVar}" is not set.`);
+        }
+        headers.set("Authorization", `Bearer ${token}`);
+    }
+    return new StreamableHTTPClientTransport(new URL(config.url), {
+        requestInit: { headers },
+    });
+}
+function stringEnvironment(env) {
+    return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== undefined));
+}

package/dist/mcp/createMcpTool.d.ts

@@ -0,0 +1,11 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type AnyDefinedTool } from "../agent/types.js";
+type ListedMcpTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
+export declare function createMcpTool(options: {
+    client: Client;
+    serverName: string;
+    tool: ListedMcpTool;
+    timeoutMs?: number;
+}): AnyDefinedTool;
+export {};
+//# sourceMappingURL=createMcpTool.d.ts.map

package/dist/mcp/createMcpTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMcpTool.d.ts","sourceRoot":"","sources":["../../sources/mcp/createMcpTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAGxE,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAIpE,KAAK,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/E,wBAAgB,aAAa,CAAC,OAAO,EAAE;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,aAAa,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,cAAc,CA+BjB"}

package/dist/mcp/createMcpTool.js

@@ -0,0 +1,43 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../agent/types.js";
+import { mcpResultToContentBlocks } from "./mcpResultToContentBlocks.js";
+import { normalizeMcpName } from "./normalizeMcpName.js";
+export function createMcpTool(options) {
+    const qualifiedName = `mcp__${normalizeMcpName(options.serverName)}__${normalizeMcpName(options.tool.name)}`;
+    const tool = defineTool({
+        name: qualifiedName,
+        label: qualifiedName,
+        description: options.tool.description ?? `Use ${options.tool.name} from ${options.serverName}.`,
+        arguments: Type.Unsafe(options.tool.inputSchema),
+        returnType: Type.Unknown(),
+        async execute(args, _context, execution) {
+            const result = await options.client.callTool({
+                arguments: isRecord(args) ? args : {},
+                name: options.tool.name,
+            }, undefined, {
+                ...(execution.signal !== undefined ? { signal: execution.signal } : {}),
+                ...(options.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+            });
+            if (result.isError === true) {
+                throw new Error(firstText(result) ?? "The MCP tool reported an error.");
+            }
+            return result;
+        },
+        toLLM: (result) => mcpResultToContentBlocks(result),
+        toUI: () => `${humanizeName(options.serverName)} · ${humanizeName(options.tool.name)}`,
+        locks: options.tool.annotations?.readOnlyHint === true ? [] : [`mcp:${options.serverName}`],
+    });
+    return tool;
+}
+function firstText(result) {
+    if (!isRecord(result) || !Array.isArray(result.content))
+        return undefined;
+    const text = result.content.find((content) => isRecord(content) && content.type === "text" && typeof content.text === "string");
+    return text?.text;
+}
+function humanizeName(value) {
+    return value.replace(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,5 @@
+export { McpClientManager } from "./McpClientManager.js";
+export { loadMcpServerConfigs } from "./loadMcpServerConfigs.js";
+export { mergeMcpTools } from "./mergeMcpTools.js";
+export type { McpHttpServerConfig, McpServerConfig, McpServerSummary, McpStdioServerConfig, McpToolLoadResult, McpToolProvider, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../sources/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACR,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,GAClB,MAAM,YAAY,CAAC"}

package/dist/mcp/index.js

@@ -0,0 +1,3 @@
+export { McpClientManager } from "./McpClientManager.js";
+export { loadMcpServerConfigs } from "./loadMcpServerConfigs.js";
+export { mergeMcpTools } from "./mergeMcpTools.js";

package/dist/mcp/loadMcpServerConfigs.d.ts

@@ -0,0 +1,4 @@
+import type { LoadConfigOptions } from "../config/types.js";
+import type { McpServerConfig } from "./types.js";
+export declare function loadMcpServerConfigs(cwd: string, options?: Omit<LoadConfigOptions, "cwd">): Promise<Readonly<Record<string, McpServerConfig>>>;
+//# sourceMappingURL=loadMcpServerConfigs.d.ts.map

package/dist/mcp/loadMcpServerConfigs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadMcpServerConfigs.d.ts","sourceRoot":"","sources":["../../sources/mcp/loadMcpServerConfigs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,wBAAsB,oBAAoB,CACtC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAM,GAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,CAIpD"}

package/dist/mcp/loadMcpServerConfigs.js

@@ -0,0 +1,122 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { loadConfig } from "../config/loadConfig.js";
+export async function loadMcpServerConfigs(cwd, options = {}) {
+    const loaded = await loadConfig({ ...options, cwd });
+    const projectServers = await readProjectMcpConfig(join(cwd, ".mcp.json"));
+    return { ...loaded.config.mcpServers, ...projectServers };
+}
+async function readProjectMcpConfig(path) {
+    let source;
+    try {
+        source = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return {};
+        throw error;
+    }
+    let document;
+    try {
+        document = JSON.parse(source);
+    }
+    catch (error) {
+        throw new Error(`.mcp.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(document) || !isRecord(document.mcpServers)) {
+        throw new Error('.mcp.json must contain an "mcpServers" object.');
+    }
+    return Object.fromEntries(Object.entries(document.mcpServers).map(([name, value]) => [
+        name,
+        parseProjectServer(name, value),
+    ]));
+}
+function parseProjectServer(name, value) {
+    if (!isRecord(value)) {
+        throw new Error(`MCP server "${name}" must be an object.`);
+    }
+    const type = typeof value.type === "string" ? value.type : undefined;
+    if (type !== undefined && type !== "stdio" && type !== "http") {
+        throw new Error(`MCP server "${name}" uses unsupported transport "${type}". Use stdio or http.`);
+    }
+    const common = {
+        ...optionalBoolean(value.enabled, "enabled", name),
+        ...optionalStringArray(value.enabledTools, "enabledTools", name),
+        ...optionalStringArray(value.disabledTools, "disabledTools", name),
+        ...optionalPositiveNumber(value.startupTimeoutMs, "startupTimeoutMs", name),
+        ...optionalPositiveNumber(value.toolTimeoutMs, "toolTimeoutMs", name),
+    };
+    if (type === "stdio" || typeof value.command === "string") {
+        if (typeof value.command !== "string" || value.command.trim() === "") {
+            throw new Error(`MCP server "${name}" must provide a command.`);
+        }
+        return {
+            ...common,
+            ...optionalStringArray(value.args, "args", name),
+            ...optionalStringRecord(value.env, "env", name),
+            ...optionalString(value.cwd, "cwd", name),
+            command: value.command,
+            transport: "stdio",
+        };
+    }
+    if (type === "http" || typeof value.url === "string") {
+        if (typeof value.url !== "string" || value.url.trim() === "") {
+            throw new Error(`MCP server "${name}" must provide a URL.`);
+        }
+        return {
+            ...common,
+            ...optionalStringRecord(value.headers, "headers", name),
+            ...optionalString(value.bearerTokenEnvVar, "bearerTokenEnvVar", name),
+            transport: "http",
+            url: value.url,
+        };
+    }
+    throw new Error(`MCP server "${name}" must configure either command or url.`);
+}
+function optionalBoolean(value, key, serverName) {
+    if (value === undefined)
+        return {};
+    if (typeof value !== "boolean")
+        throw invalidField(serverName, key, "a boolean");
+    return { enabled: value };
+}
+function optionalPositiveNumber(value, key, serverName) {
+    if (value === undefined)
+        return {};
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw invalidField(serverName, key, "a positive number");
+    }
+    return { [key]: value };
+}
+function optionalString(value, key, serverName) {
+    if (value === undefined)
+        return {};
+    if (typeof value !== "string")
+        throw invalidField(serverName, key, "a string");
+    return { [key]: value };
+}
+function optionalStringArray(value, key, serverName) {
+    if (value === undefined)
+        return {};
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw invalidField(serverName, key, "an array of strings");
+    }
+    return { [key]: value };
+}
+function optionalStringRecord(value, key, serverName) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value) || Object.values(value).some((entry) => typeof entry !== "string")) {
+        throw invalidField(serverName, key, "an object with string values");
+    }
+    return { [key]: value };
+}
+function invalidField(serverName, key, expectation) {
+    return new Error(`MCP server "${serverName}" field "${key}" must be ${expectation}.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+    return isRecord(error) && error.code === "ENOENT";
+}

package/dist/mcp/mcpResultToContentBlocks.d.ts

@@ -0,0 +1,3 @@
+import type { ContentBlock } from "../agent/types.js";
+export declare function mcpResultToContentBlocks(result: unknown): readonly ContentBlock[];
+//# sourceMappingURL=mcpResultToContentBlocks.d.ts.map

package/dist/mcp/mcpResultToContentBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpResultToContentBlocks.d.ts","sourceRoot":"","sources":["../../sources/mcp/mcpResultToContentBlocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,YAAY,EAAE,CAUjF"}

package/dist/mcp/mcpResultToContentBlocks.js

@@ -0,0 +1,51 @@
+export function mcpResultToContentBlocks(result) {
+    if (!isRecord(result))
+        return [{ type: "text", text: String(result) }];
+    const blocks = Array.isArray(result.content)
+        ? result.content.flatMap((content) => contentToBlocks(content))
+        : [];
+    if (blocks.length > 0)
+        return blocks;
+    if (result.structuredContent !== undefined) {
+        return [{ type: "text", text: JSON.stringify(result.structuredContent) }];
+    }
+    return [{ type: "text", text: "The MCP tool completed without returning content." }];
+}
+function contentToBlocks(content) {
+    if (!isRecord(content) || typeof content.type !== "string")
+        return [];
+    if (content.type === "text" && typeof content.text === "string") {
+        return [{ type: "text", text: content.text }];
+    }
+    if (content.type === "image" &&
+        typeof content.data === "string" &&
+        typeof content.mimeType === "string") {
+        return [{ type: "image", data: content.data, mediaType: content.mimeType }];
+    }
+    if (content.type === "resource" && isRecord(content.resource)) {
+        if (typeof content.resource.text === "string") {
+            return [{ type: "text", text: content.resource.text }];
+        }
+        return [
+            {
+                type: "text",
+                text: `MCP resource: ${typeof content.resource.uri === "string" ? content.resource.uri : "embedded content"}`,
+            },
+        ];
+    }
+    if (content.type === "resource_link") {
+        return [
+            {
+                type: "text",
+                text: `MCP resource: ${typeof content.uri === "string" ? content.uri : "linked content"}`,
+            },
+        ];
+    }
+    if (content.type === "audio") {
+        return [{ type: "text", text: "The MCP tool returned audio content." }];
+    }
+    return [];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/mcp/mergeMcpTools.d.ts

@@ -0,0 +1,7 @@
+import type { AnyDefinedTool } from "../agent/index.js";
+import type { McpServerSummary, McpToolLoadResult } from "./types.js";
+export declare function mergeMcpTools(existingTools: readonly AnyDefinedTool[], loaded: McpToolLoadResult): {
+    servers: readonly McpServerSummary[];
+    tools: readonly AnyDefinedTool[];
+};
+//# sourceMappingURL=mergeMcpTools.d.ts.map

package/dist/mcp/mergeMcpTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeMcpTools.d.ts","sourceRoot":"","sources":["../../sources/mcp/mergeMcpTools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEtE,wBAAgB,aAAa,CACzB,aAAa,EAAE,SAAS,cAAc,EAAE,EACxC,MAAM,EAAE,iBAAiB,GAC1B;IAAE,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAA;CAAE,CA6C5E"}

package/dist/mcp/mergeMcpTools.js

@@ -0,0 +1,34 @@
+import { normalizeMcpName } from "./normalizeMcpName.js";
+export function mergeMcpTools(existingTools, loaded) {
+    const existingNames = new Set(existingTools.map((tool) => tool.name));
+    const conflictingNames = new Set(loaded.tools.filter((tool) => existingNames.has(tool.name)).map((tool) => tool.name));
+    if (conflictingNames.size === 0) {
+        return { servers: loaded.servers, tools: [...existingTools, ...loaded.tools] };
+    }
+    const conflictingServers = new Set();
+    const servers = loaded.servers.map((server) => {
+        const prefix = `mcp__${normalizeMcpName(server.name)}__`;
+        const conflicts = [...conflictingNames].filter((name) => name.startsWith(prefix));
+        if (conflicts.length === 0)
+            return server;
+        conflictingServers.add(server.name);
+        return {
+            errorMessage: `Tool name conflict: ${conflicts.join(", ")}`,
+            name: server.name,
+            status: "failed",
+            toolCount: 0,
+        };
+    });
+    const unresolved = [...conflictingNames].filter((name) => !loaded.servers.some((server) => name.startsWith(`mcp__${normalizeMcpName(server.name)}__`)));
+    if (unresolved.length > 0) {
+        servers.push({
+            errorMessage: `Tool name conflict: ${unresolved.join(", ")}`,
+            name: "MCP tools",
+            status: "failed",
+            toolCount: 0,
+        });
+    }
+    const accepted = loaded.tools.filter((tool) => !existingNames.has(tool.name) &&
+        ![...conflictingServers].some((serverName) => tool.name.startsWith(`mcp__${normalizeMcpName(serverName)}__`)));
+    return { servers, tools: [...existingTools, ...accepted] };
+}

package/dist/mcp/normalizeMcpName.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeMcpName(name: string): string;
+//# sourceMappingURL=normalizeMcpName.d.ts.map

package/dist/mcp/normalizeMcpName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeMcpName.d.ts","sourceRoot":"","sources":["../../sources/mcp/normalizeMcpName.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/mcp/normalizeMcpName.js

@@ -0,0 +1,3 @@
+export function normalizeMcpName(name) {
+    return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}

package/dist/mcp/types.d.ts

@@ -0,0 +1,37 @@
+import type { AnyDefinedTool } from "../agent/index.js";
+export interface McpServerConfigBase {
+    disabledTools?: readonly string[];
+    enabled?: boolean;
+    enabledTools?: readonly string[];
+    startupTimeoutMs?: number;
+    toolTimeoutMs?: number;
+}
+export interface McpStdioServerConfig extends McpServerConfigBase {
+    args?: readonly string[];
+    command: string;
+    cwd?: string;
+    env?: Readonly<Record<string, string>>;
+    transport: "stdio";
+}
+export interface McpHttpServerConfig extends McpServerConfigBase {
+    bearerTokenEnvVar?: string;
+    headers?: Readonly<Record<string, string>>;
+    transport: "http";
+    url: string;
+}
+export type McpServerConfig = McpStdioServerConfig | McpHttpServerConfig;
+export interface McpServerSummary {
+    errorMessage?: string;
+    name: string;
+    status: "connected" | "disabled" | "failed";
+    toolCount: number;
+}
+export interface McpToolLoadResult {
+    servers: readonly McpServerSummary[];
+    tools: readonly AnyDefinedTool[];
+}
+export interface McpToolProvider {
+    close(): Promise<void>;
+    load(cwd: string): Promise<McpToolLoadResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/mcp/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../sources/mcp/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,WAAW,mBAAmB;IAChC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC7D,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACvC,SAAS,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC5D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,eAAe,GAAG,oBAAoB,GAAG,mBAAmB,CAAC;AAEzE,MAAM,WAAW,gBAAgB;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC5C,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACrC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACjD"}

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/permissions/PermissionContext.d.ts

@@ -0,0 +1,7 @@
+import type { PermissionMode } from "./PermissionMode.js";
+export interface PermissionContext {
+    readonly mode: PermissionMode;
+    runWithMode<T>(mode: PermissionMode, action: () => Promise<T> | T): Promise<T>;
+    setMode(mode: PermissionMode): void;
+}
+//# sourceMappingURL=PermissionContext.d.ts.map

package/dist/permissions/PermissionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionContext.d.ts","sourceRoot":"","sources":["../../sources/permissions/PermissionContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/E,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;CACvC"}

package/dist/permissions/PermissionContext.js

@@ -0,0 +1 @@
+export {};

package/dist/permissions/PermissionMode.d.ts

@@ -0,0 +1,3 @@
+export type PermissionMode = "auto" | "workspace_write" | "read_only" | "full_access";
+export declare const DEFAULT_PERMISSION_MODE: PermissionMode;
+//# sourceMappingURL=PermissionMode.d.ts.map

package/dist/permissions/PermissionMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionMode.d.ts","sourceRoot":"","sources":["../../sources/permissions/PermissionMode.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,iBAAiB,GAAG,WAAW,GAAG,aAAa,CAAC;AAEtF,eAAO,MAAM,uBAAuB,EAAE,cAAkC,CAAC"}

package/dist/permissions/PermissionMode.js

@@ -0,0 +1 @@
+export const DEFAULT_PERMISSION_MODE = "workspace_write";

package/dist/permissions/createPermissionContext.d.ts

@@ -0,0 +1,4 @@
+import type { PermissionContext } from "./PermissionContext.js";
+import type { PermissionMode } from "./PermissionMode.js";
+export declare function createPermissionContext(initialMode: PermissionMode): PermissionContext;
+//# sourceMappingURL=createPermissionContext.d.ts.map

package/dist/permissions/createPermissionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPermissionContext.d.ts","sourceRoot":"","sources":["../../sources/permissions/createPermissionContext.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,cAAc,GAAG,iBAAiB,CActF"}