@cjhyy/code-shell 0.1.0-alpha.0

package/dist/skills/matcher.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Skill matcher — determines which skills are relevant for a given input/context.
+ */
+import type { SkillDefinition } from "./scanner.js";
+export interface MatchResult {
+    skill: SkillDefinition;
+    score: number;
+    matchedBy: string;
+}
+/**
+ * Match skills against user input text.
+ */
+export declare function matchSkillsByInput(skills: SkillDefinition[], input: string): MatchResult[];
+/**
+ * Match skills by tool name being used.
+ */
+export declare function matchSkillsByTool(skills: SkillDefinition[], toolName: string): MatchResult[];
+/**
+ * Build a skill listing for the system prompt.
+ */
+export declare function buildSkillListing(skills: SkillDefinition[]): string;

package/dist/skills/scanner.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Skills scanner — discovers SKILL.md files and parses their metadata.
+ *
+ * Skills are markdown files with YAML frontmatter:
+ * ---
+ * name: skill-name
+ * description: what it does
+ * triggers:
+ *   keywords: [word1, word2]
+ *   tools: [ToolName]
+ * when_to_use: description of when to invoke
+ * ---
+ * <skill content>
+ */
+export interface SkillDefinition {
+    name: string;
+    description: string;
+    triggers: {
+        keywords?: string[];
+        tools?: string[];
+        intents?: string[];
+    };
+    whenToUse: string;
+    content: string;
+    filePath: string;
+}
+/**
+ * Scan for SKILL.md files in standard locations.
+ */
+export declare function scanSkills(cwd: string): SkillDefinition[];

package/dist/skills-63RBYQRX.js

@@ -0,0 +1,13 @@
+import {
+  buildSkillListing,
+  matchSkillsByInput,
+  matchSkillsByTool,
+  scanSkills
+} from "./chunk-4SFPFHMG.js";
+import "./chunk-DI7RDLOS.js";
+export {
+  buildSkillListing,
+  matchSkillsByInput,
+  matchSkillsByTool,
+  scanSkills
+};

package/dist/skills-V3BPLW3D.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkCSO5EOEPcjs = require('./chunk-CSO5EOEP.cjs');
+require('./chunk-IJSHQGMP.cjs');
+
+
+
+
+
+exports.buildSkillListing = _chunkCSO5EOEPcjs.buildSkillListing; exports.matchSkillsByInput = _chunkCSO5EOEPcjs.matchSkillsByInput; exports.matchSkillsByTool = _chunkCSO5EOEPcjs.matchSkillsByTool; exports.scanSkills = _chunkCSO5EOEPcjs.scanSkills;

package/dist/token-counter-CHAXW5O7.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkHD7MT5XUcjs = require('./chunk-HD7MT5XU.cjs');
+require('./chunk-IJSHQGMP.cjs');
+_chunkHD7MT5XUcjs.init_token_counter.call(void 0, );
+
+
+
+
+exports.calculateContextUsage = _chunkHD7MT5XUcjs.calculateContextUsage; exports.estimateMessagesTokens = _chunkHD7MT5XUcjs.estimateMessagesTokens; exports.estimateStringTokens = _chunkHD7MT5XUcjs.estimateStringTokens;

package/dist/token-counter-DSOZGZ5Q.js

@@ -0,0 +1,13 @@
+import {
+  calculateContextUsage,
+  estimateMessagesTokens,
+  estimateStringTokens,
+  init_token_counter
+} from "./chunk-4RRUP4MM.js";
+import "./chunk-DI7RDLOS.js";
+init_token_counter();
+export {
+  calculateContextUsage,
+  estimateMessagesTokens,
+  estimateStringTokens
+};

package/dist/tool-summary-5P2GKRA4.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkIMMTBZ33cjs = require('./chunk-IMMTBZ33.cjs');
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/engine/tool-summary.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var SUMMARY_SYSTEM_PROMPT = 'Generate a very brief (under 40 chars) summary of what these tools did. Use past tense, commit-subject style. Examples: "Read 3 config files", "Fixed import in auth.ts", "Searched for API endpoints". Respond with ONLY the summary text, nothing else.';
+async function generateToolUseSummary(toolCalls, results, summarize) {
+  if (toolCalls.length === 0) return null;
+  try {
+    const parts = [];
+    for (let i = 0; i < toolCalls.length; i++) {
+      const tc = toolCalls[i];
+      const result = results[i];
+      const input = JSON.stringify(tc.args).slice(0, 200);
+      const output = (_nullishCoalesce(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _ => _.result]), () => ( _optionalChain([result, 'optionalAccess', _2 => _2.error]))), () => ( ""))).slice(0, 300);
+      parts.push(`Tool: ${tc.toolName}(${input}) \u2192 ${output}`);
+    }
+    const summary = await summarize(SUMMARY_SYSTEM_PROMPT, parts.join("\n"));
+    return _optionalChain([summary, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()]) || null;
+  } catch (err) {
+    _chunkIMMTBZ33cjs.logger.warn("tool_summary.failed", { error: err.message });
+    return null;
+  }
+}
+
+
+exports.generateToolUseSummary = generateToolUseSummary;

package/dist/tool-summary-J2ICNMWP.js

@@ -0,0 +1,31 @@
+import {
+  logger
+} from "./chunk-X4HAERTQ.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/engine/tool-summary.ts
+init_esm_shims();
+var SUMMARY_SYSTEM_PROMPT = 'Generate a very brief (under 40 chars) summary of what these tools did. Use past tense, commit-subject style. Examples: "Read 3 config files", "Fixed import in auth.ts", "Searched for API endpoints". Respond with ONLY the summary text, nothing else.';
+async function generateToolUseSummary(toolCalls, results, summarize) {
+  if (toolCalls.length === 0) return null;
+  try {
+    const parts = [];
+    for (let i = 0; i < toolCalls.length; i++) {
+      const tc = toolCalls[i];
+      const result = results[i];
+      const input = JSON.stringify(tc.args).slice(0, 200);
+      const output = (result?.result ?? result?.error ?? "").slice(0, 300);
+      parts.push(`Tool: ${tc.toolName}(${input}) \u2192 ${output}`);
+    }
+    const summary = await summarize(SUMMARY_SYSTEM_PROMPT, parts.join("\n"));
+    return summary?.trim() || null;
+  } catch (err) {
+    logger.warn("tool_summary.failed", { error: err.message });
+    return null;
+  }
+}
+export {
+  generateToolUseSummary
+};

package/dist/tool-system/builtin/agent.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Built-in Agent tool — spawn a sub-agent to handle a task.
+ *
+ * Creates a new Engine instance with its own transcript,
+ * runs the task to completion, and returns the result text.
+ * Supports AbortSignal for cascading cancellation.
+ * Supports onStream for real-time output passthrough.
+ */
+import type { ToolDefinition, StreamCallback } from "../../types.js";
+import type { AgentPresetName } from "../../preset/index.js";
+export declare const agentToolDef: ToolDefinition;
+export interface SubAgentConfig {
+    llm: import("../../types.js").LLMConfig;
+    cwd: string;
+    permissionMode: string;
+    preset?: AgentPresetName;
+    enabledBuiltinTools?: string[];
+    disabledBuiltinTools?: string[];
+    customSystemPrompt?: string;
+    appendSystemPrompt?: string;
+    maxContextTokens: number;
+    sessionStorageDir?: string;
+    onStream?: StreamCallback;
+    createEngine: (config: Record<string, unknown>) => {
+        run(task: string, options?: {
+            signal?: AbortSignal;
+            onStream?: StreamCallback;
+        }): Promise<{
+            text: string;
+            reason: string;
+        }>;
+    };
+}
+export declare function setSubAgentConfig(config: SubAgentConfig | undefined): void;
+export declare function agentTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/arena.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Built-in Arena tool — multi-model collaborative analysis.
+ *
+ * Launches an arena session where multiple LLM participants independently
+ * research a topic, cross-review each other's findings, and build consensus.
+ *
+ * The LLM config (baseUrl, apiKey) is injected at runtime by the Engine via
+ * setArenaLLMConfig(), following the same pattern as setAskUserFn() and
+ * setSubAgentConfig().
+ */
+import type { ToolDefinition, LLMConfig } from "../../types.js";
+export declare const arenaToolDef: ToolDefinition;
+/**
+ * Inject the engine's LLM config so Arena participants inherit baseUrl/apiKey.
+ * Called by Engine.run() alongside setAskUserFn(), setSubAgentConfig(), etc.
+ */
+export declare function setArenaLLMConfig(config: LLMConfig | undefined): void;
+export declare function arenaTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/ask-user.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Built-in AskUserQuestion tool — ask the user a question during execution.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const askUserToolDef: ToolDefinition;
+/**
+ * Factory: the actual executor is injected at runtime by the Engine,
+ * because it depends on the CLI/UI layer to collect user input.
+ */
+export type AskUserFn = (question: string) => Promise<string>;
+export declare function setAskUserFn(fn: AskUserFn | undefined): void;
+export declare function askUserTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/bash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in Bash shell command execution tool.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const bashToolDef: ToolDefinition;
+export declare function bashTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/brief.d.ts

@@ -0,0 +1,6 @@
+/**
+ * BriefTool — send structured messages with markdown support.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const briefToolDef: ToolDefinition;
+export declare function briefTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ConfigTool — read or update project settings.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const configToolDef: ToolDefinition;
+export declare function configTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/cron.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Cron tools — CronCreate, CronDelete, CronList.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const cronCreateToolDef: ToolDefinition;
+export declare function cronCreateTool(args: Record<string, unknown>): Promise<string>;
+export declare const cronDeleteToolDef: ToolDefinition;
+export declare function cronDeleteTool(args: Record<string, unknown>): Promise<string>;
+export declare const cronListToolDef: ToolDefinition;
+export declare function cronListTool(_args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/edit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in Edit file tool — exact string replacement.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const editToolDef: ToolDefinition;
+export declare function editTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/file-cache.d.ts

@@ -0,0 +1,11 @@
+declare class FileStateCache {
+    private cache;
+    get(filePath: string): Promise<string | null>;
+    set(filePath: string, content: string, mtimeMs: number): void;
+    /** Invalidate a specific path (after Write/Edit). */
+    invalidate(filePath: string): void;
+    clear(): void;
+    get size(): number;
+}
+export declare const fileCache: FileStateCache;
+export {};

package/dist/tool-system/builtin/glob.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in Glob file search tool.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const globToolDef: ToolDefinition;
+export declare function globTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/grep.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in Grep content search tool.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const grepToolDef: ToolDefinition;
+export declare function grepTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Built-in tool registration.
+ */
+import type { RegisteredTool } from "../../types.js";
+export type BuiltinToolFn = (args: Record<string, unknown>) => Promise<string>;
+export interface BuiltinTool {
+    definition: RegisteredTool;
+    execute: BuiltinToolFn;
+}
+export declare const BUILTIN_TOOLS: BuiltinTool[];

package/dist/tool-system/builtin/lsp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LSPTool — language server protocol operations for code intelligence.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const lspToolDef: ToolDefinition;
+export declare function lspTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/mcp-tools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * MCP (Model Context Protocol) tools — list, read, and auth for MCP resources.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const mcpToolDef: ToolDefinition;
+export declare function mcpToolExecute(args: Record<string, unknown>): Promise<string>;
+export declare const listMcpResourcesToolDef: ToolDefinition;
+export declare function listMcpResourcesTool(args: Record<string, unknown>): Promise<string>;
+export declare const readMcpResourceToolDef: ToolDefinition;
+export declare function readMcpResourceTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/notebook-edit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * NotebookEditTool — read and edit Jupyter notebook (.ipynb) cells.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const notebookEditToolDef: ToolDefinition;
+export declare function notebookEditTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/plan.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Plan mode — restricts the agent to read-only exploration and text output.
+ *
+ * In plan mode the agent:
+ *   - Can only use read-only tools (Read, Glob, Grep, Bash read-only, WebSearch, etc.)
+ *   - CANNOT write, edit, or create files
+ *   - Outputs its plan as text directly in the conversation
+ *   - Exits plan mode when the user approves or via ExitPlanMode tool
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const enterPlanModeToolDef: ToolDefinition;
+export declare const exitPlanModeToolDef: ToolDefinition;
+export declare function isInPlanMode(): boolean;
+export declare function setInPlanMode(value: boolean): void;
+export declare function resetPlanMode(): void;
+export declare function restorePlanMode(): void;
+export declare function enterPlanModeTool(_args: Record<string, unknown>): Promise<string>;
+export declare function exitPlanModeTool(_args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/powershell.d.ts

@@ -0,0 +1,6 @@
+/**
+ * PowerShellTool — execute PowerShell commands (Windows).
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const powershellToolDef: ToolDefinition;
+export declare function powershellTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/read.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in Read file tool.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const readToolDef: ToolDefinition;
+export declare function readTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/remote-trigger.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RemoteTriggerTool — trigger remote agents/workflows.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const remoteTriggerToolDef: ToolDefinition;
+export declare function remoteTriggerTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/repl.d.ts

@@ -0,0 +1,6 @@
+/**
+ * REPLTool — execute code in an interactive REPL environment.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const replToolDef: ToolDefinition;
+export declare function replTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/send-message.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SendMessage tool — send messages between named agents.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const sendMessageToolDef: ToolDefinition;
+export declare function sendMessageTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/skill.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SkillTool — invoke custom skills/plugins by name.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const skillToolDef: ToolDefinition;
+export declare function skillTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/sleep.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SleepTool — pause execution for a specified duration.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const sleepToolDef: ToolDefinition;
+export declare function sleepTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/task.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Built-in Task management tools — TaskCreate, TaskList, TaskUpdate, TaskStop.
+ *
+ * Provides an in-memory task list that the agent uses to track progress
+ * on complex multi-step work. Tasks are displayed in the terminal UI
+ * so the user can see what the agent is doing.
+ */
+import type { ToolDefinition, StreamCallback } from "../../types.js";
+export type TaskStatus = "pending" | "in_progress" | "completed" | "stopped";
+export interface Task {
+    id: string;
+    subject: string;
+    description: string;
+    activeForm?: string;
+    status: TaskStatus;
+    createdAt: number;
+    updatedAt: number;
+    blockedBy: string[];
+    blocks: string[];
+}
+declare class TaskManager {
+    private tasks;
+    private nextId;
+    private onUpdate?;
+    reset(): void;
+    setStreamCallback(cb?: StreamCallback): void;
+    create(subject: string, description: string, activeForm?: string): Task;
+    get(id: string): Task | undefined;
+    list(): Task[];
+    update(id: string, updates: Partial<Pick<Task, "subject" | "description" | "activeForm" | "status">> & {
+        addBlockedBy?: string[];
+        addBlocks?: string[];
+    }): Task | undefined;
+    stop(id: string): Task | undefined;
+    delete(id: string): boolean;
+    private emitUpdate;
+}
+export declare const taskManager: TaskManager;
+export declare const taskCreateToolDef: ToolDefinition;
+export declare const taskListToolDef: ToolDefinition;
+export declare const taskUpdateToolDef: ToolDefinition;
+export declare const taskStopToolDef: ToolDefinition;
+export declare function taskCreateTool(args: Record<string, unknown>): Promise<string>;
+export declare function taskListTool(_args: Record<string, unknown>): Promise<string>;
+export declare function taskUpdateTool(args: Record<string, unknown>): Promise<string>;
+export declare function taskStopTool(args: Record<string, unknown>): Promise<string>;
+export declare const taskGetToolDef: ToolDefinition;
+export declare function taskGetTool(args: Record<string, unknown>): Promise<string>;
+export declare const taskOutputToolDef: ToolDefinition;
+export declare function taskOutputTool(args: Record<string, unknown>): Promise<string>;
+export {};

package/dist/tool-system/builtin/tool-search.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Built-in ToolSearch tool — deferred tool schema discovery.
+ *
+ * MCP tools are initially registered with name-only (deferred).
+ * The model uses ToolSearch to discover full schemas on demand,
+ * saving context by not loading all MCP tool schemas upfront.
+ */
+import type { ToolDefinition } from "../../types.js";
+import type { ToolRegistry } from "../registry.js";
+export declare const toolSearchToolDef: ToolDefinition;
+export declare function setToolSearchRegistry(registry: ToolRegistry): void;
+export declare function toolSearchTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/web-fetch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in WebFetch tool — fetch a URL and extract readable text content.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const webFetchToolDef: ToolDefinition;
+export declare function webFetchTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/web-search.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in WebSearch tool — search the web via Serper, Tavily, or SearXNG.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const webSearchToolDef: ToolDefinition;
+export declare function webSearchTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/worktree.d.ts

@@ -0,0 +1,10 @@
+/**
+ * EnterWorktree / ExitWorktree tools — create and manage isolated git worktrees.
+ */
+import type { ToolDefinition } from "../../types.js";
+import { type WorktreeSession } from "../../git/worktree.js";
+export declare function getActiveWorktree(): WorktreeSession | undefined;
+export declare const enterWorktreeToolDef: ToolDefinition;
+export declare function enterWorktreeTool(args: Record<string, unknown>): Promise<string>;
+export declare const exitWorktreeToolDef: ToolDefinition;
+export declare function exitWorktreeTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/write.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in Write file tool.
+ */
+import type { ToolDefinition } from "../../types.js";
+export declare const writeToolDef: ToolDefinition;
+export declare function writeTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/executor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tool executor — orchestrates permission checks, hooks, and execution.
+ */
+import type { ToolCall, ToolResult, Message } from "../types.js";
+import type { HookRegistry } from "../hooks/registry.js";
+import { ToolRegistry } from "./registry.js";
+import { PermissionClassifier } from "./permission.js";
+export declare class ToolExecutor {
+    private readonly registry;
+    private readonly permission;
+    private readonly hooks;
+    private signal?;
+    constructor(registry: ToolRegistry, permission: PermissionClassifier, hooks: HookRegistry);
+    /** Set the abort signal for cascading cancellation. */
+    setSignal(signal?: AbortSignal): void;
+    /** Check if a tool is safe for concurrent execution (read-only). */
+    isConcurrencySafe(toolName: string): boolean;
+    executeSingle(call: ToolCall): Promise<ToolResult>;
+    private isReadOnlyBashCommand;
+    executeAll(calls: ToolCall[]): Promise<ToolResult[]>;
+    /**
+     * Convert tool results into Message entries for the transcript.
+     */
+    resultsToMessages(toolCalls: ToolCall[], results: ToolResult[]): Message[];
+}

package/dist/tool-system/mcp-manager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * MCP Server Manager — connects to external MCP servers and registers their tools.
+ *
+ * Supports stdio and streamable-http transports.
+ */
+import type { MCPServerConfig } from "../types.js";
+import { ToolRegistry } from "./registry.js";
+export declare class MCPManager {
+    private readonly toolRegistry;
+    private static instance;
+    private connections;
+    constructor(toolRegistry: ToolRegistry);
+    static getInstance(): MCPManager;
+    /**
+     * Connect to all configured MCP servers and register their tools.
+     */
+    connectAll(servers: Record<string, MCPServerConfig>): Promise<void>;
+    /**
+     * Connect to a single MCP server.
+     */
+    connect(name: string, config: MCPServerConfig): Promise<void>;
+    /**
+     * Discover tools from an MCP server and register them.
+     */
+    private discoverTools;
+    /**
+     * Disconnect all MCP servers.
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * List connected servers.
+     */
+    listServers(): string[];
+    /**
+     * Call a tool on a specific MCP server.
+     */
+    callTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /**
+     * List resources from MCP servers.
+     */
+    listResources(serverName?: string): Promise<Array<{
+        uri: string;
+        name: string;
+        description?: string;
+    }>>;
+    /**
+     * Read a resource from an MCP server.
+     */
+    readResource(serverName: string, uri: string): Promise<string>;
+}