indusagi 0.12.32 → 0.12.33

package/dist/types/facade/bot/types.d.ts

@@ -0,0 +1,207 @@
+import type { AssistantMessageEvent, ImageContent, Message, Model, SimpleStreamOptions, streamSimple, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage, UserMessage } from "../ml/index.js";
+import type { Static, TSchema } from "@sinclair/typebox";
+/** Streaming entry point; may resolve synchronously or via a Promise when config is fetched async. */
+export type StreamFn = (...args: Parameters<typeof streamSimple>) => ReturnType<typeof streamSimple> | Promise<ReturnType<typeof streamSimple>>;
+/**
+ * Reasoning effort tier requested from models that expose one.
+ * Heads up: the top "xhigh" tier is currently only honored by a few OpenAI
+ * frontier models; most providers cap out at "high".
+ */
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+/**
+ * Open extension point for application-defined message kinds.
+ * Downstream code adds its own kinds by merging this module's interface:
+ *
+ * @example
+ * ```typescript
+ * declare module "./types.js" {
+ *   interface CustomAgentMessages {
+ *     reminder: ReminderMessage;
+ *     statusBanner: StatusBannerMessage;
+ *   }
+ * }
+ * ```
+ */
+export interface CustomAgentMessages {
+}
+/**
+ * AgentMessage: every base LLM message plus any app-registered custom kinds.
+ * The indirection lets applications introduce their own message kinds without
+ * giving up type safety against the underlying LLM message shapes.
+ */
+export type AgentMessage = Message | CustomAgentMessages[keyof CustomAgentMessages];
+export type AgentToolUpdateCallback<T = any> = (partialResult: AgentToolResult<T>) => void;
+export interface AgentToolResult<T> {
+    content: (TextContent | ImageContent)[];
+    details: T;
+    isError?: boolean;
+}
+export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any> extends Tool<TParameters> {
+    label: string;
+    execute: (toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails>) => Promise<AgentToolResult<TDetails>>;
+}
+export interface AgentContext {
+    systemPrompt: string;
+    messages: AgentMessage[];
+    tools?: AgentTool<any>[];
+}
+/**
+ * The agent's full runtime state: configuration plus live conversation data.
+ */
+export interface AgentState {
+    systemPrompt: string;
+    model: Model<any>;
+    thinkingLevel: ThinkingLevel;
+    tools: AgentTool<any>[];
+    messages: AgentMessage[];
+    isStreaming: boolean;
+    streamMessage: AgentMessage | null;
+    pendingToolCalls: Set<string>;
+    error?: string;
+}
+/**
+ * Settings that drive a single agent loop run.
+ */
+export interface AgentLoopConfig extends SimpleStreamOptions {
+    model: Model<any>;
+    /**
+     * Maps the AgentMessage[] down to a model-ready Message[] ahead of every model call.
+     *
+     * Every AgentMessage has to become a UserMessage, AssistantMessage, or
+     * ToolResultMessage. Anything the model shouldn't see (UI-only notices,
+     * status entries, and so on) is simply dropped here.
+     *
+     * @example
+     * ```typescript
+     * const flatten = (history: AgentMessage[]): Message[] =>
+     *   history.flatMap((entry) => {
+     *     // A bespoke kind gets restated as ordinary user text.
+     *     if (entry.role === "todo") {
+     *       return [{ role: "user", content: entry.content, timestamp: entry.timestamp }];
+     *     }
+     *     // Purely visual entries are withheld from the model.
+     *     if (entry.role === "diagnostic") {
+     *       return [];
+     *     }
+     *     // Everything else is already model-shaped, so pass it straight through.
+     *     return [entry];
+     *   });
+     * ```
+     */
+    convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
+    /**
+     * Optional hook that reshapes the context while it is still AgentMessages,
+     * i.e. before `convertToLlm` runs.
+     *
+     * Good fit for work that has to happen at the AgentMessage layer:
+     * - keeping the context window in check (trimming older entries)
+     * - pulling in extra context from elsewhere
+     *
+     * @example
+     * ```typescript
+     * const reshape = async (history: AgentMessage[]): Promise<AgentMessage[]> => {
+     *   const spent = await tallyTokens(history);
+     *   if (spent <= windowLimit) {
+     *     return history;
+     *   }
+     *   return trimFromFront(history, windowLimit);
+     * };
+     * ```
+     */
+    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
+    /**
+     * Supplies a fresh API key per model call.
+     *
+     * Handy when the credential is a short-lived OAuth token that can lapse
+     * while a slow stretch of tool calls is still running.
+     */
+    getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
+    /**
+     * Yields steering messages to splice into the run while it is in flight.
+     *
+     * Consulted after each tool finishes to pick up user interruptions. When it
+     * hands back messages, any still-pending tool calls are abandoned and those
+     * messages join the context before the next model call.
+     *
+     * This is the channel for nudging the agent mid-task.
+     */
+    getSteeringMessages?: () => Promise<AgentMessage[]>;
+    /**
+     * Yields follow-up messages to handle once the agent is otherwise done.
+     *
+     * Consulted when there are no remaining tool calls and no steering input.
+     * Returning messages appends them and pushes the agent into another turn.
+     *
+     * Use it for input that should wait until the current work wraps up.
+     */
+    getFollowUpMessages?: () => Promise<AgentMessage[]>;
+}
+type AgentLifecycleEvent = {
+    type: "agent_start";
+} | {
+    type: "agent_end";
+    messages: AgentMessage[];
+};
+type TurnEvent = {
+    type: "turn_start";
+} | {
+    type: "turn_end";
+    message: AgentMessage;
+    toolResults: ToolResultMessage[];
+};
+type MessageEvent = {
+    type: "message_start";
+    message: AgentMessage;
+} | {
+    type: "message_update";
+    message: AgentMessage;
+    assistantMessageEvent: AssistantMessageEvent;
+} | {
+    type: "message_end";
+    message: AgentMessage;
+};
+type ToolExecutionEvent = {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: any;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    args: any;
+    partialResult: any;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: any;
+    isError: boolean;
+};
+/**
+ * The events the Agent streams out so a UI can stay in sync.
+ * They report granular lifecycle progress across messages, turns, and tool runs.
+ */
+export type AgentEvent = AgentLifecycleEvent | TurnEvent | MessageEvent | ToolExecutionEvent;
+/** Grouping of the event-type strings, handy for filtering or logging. */
+export declare const AGENT_EVENT_GROUPS: {
+    readonly agent: readonly ["agent_start", "agent_end"];
+    readonly turn: readonly ["turn_start", "turn_end"];
+    readonly message: readonly ["message_start", "message_update", "message_end"];
+    readonly toolExecution: readonly ["tool_execution_start", "tool_execution_update", "tool_execution_end"];
+};
+export type AgentEventType = AgentEvent["type"];
+export type ExtractAgentEvent<TType extends AgentEventType> = Extract<AgentEvent, {
+    type: TType;
+}>;
+/**
+ * Decide at runtime whether a value matches one of the recognized AI message shapes.
+ */
+export declare function validateMessage(value: unknown): value is Message;
+/** Narrows a value to a user message. */
+export declare function isUserMessage(value: AgentMessage | unknown): value is UserMessage;
+/** Narrows a value to a thinking block carried inside an assistant message. */
+export declare function isThinking(value: unknown): value is ThinkingContent;
+/** Narrows a value to a tool-call block carried inside an assistant message. */
+export declare function isToolCall(value: unknown): value is ToolCall;
+export {};

package/dist/types/facade/mcp-core/client-pool.d.ts

@@ -0,0 +1,105 @@
+/**
+ * MCP Client Pool
+ *
+ * Manages multiple MCP client connections.
+ * Provides centralized lifecycle management.
+ *
+ * Reference: MCP client configuration patterns.
+ */
+import { MCPClient } from "./client.js";
+import type { MCPConnectionOptions, MCPToolDefinition, MCPResource, MCPPrompt } from "./types.js";
+/**
+ * Options for creating an MCP client pool.
+ */
+export interface MCPClientPoolOptions {
+    /** List of server configurations */
+    servers: MCPConnectionOptions[];
+}
+/**
+ * Status of a connected server.
+ */
+export interface MCPServerStatus {
+    /** Server name */
+    name: string;
+    /** Whether connected */
+    connected: boolean;
+    /** Number of tools available */
+    toolCount?: number;
+    /** Number of resources available */
+    resourceCount?: number;
+    /** Number of prompts available */
+    promptCount?: number;
+}
+/**
+ * MCP Client Pool - manages multiple MCP server connections.
+ *
+ * @example
+ * ```typescript
+ * const pool = new MCPClientPool({
+ *   servers: [
+ *     { name: "filesystem", config: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "."] } },
+ *     { name: "github", config: { command: "npx", args: ["-y", "@modelcontextprotocol/server-github"] } },
+ *   ],
+ * });
+ *
+ * await pool.connectAll();
+ * const status = pool.getStatus();
+ * await pool.disconnectAll();
+ * ```
+ */
+export declare class MCPClientPool {
+    private options;
+    private clients;
+    private isConnecting;
+    constructor(options: MCPClientPoolOptions);
+    /**
+     * Connect to all configured servers.
+     *
+     * Errors for individual servers are logged but don't fail the entire operation.
+     */
+    connectAll(): Promise<void>;
+    /**
+     * Disconnect from all servers.
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Get a specific client by name.
+     */
+    getClient(name: string): MCPClient | undefined;
+    /**
+     * Get all connected clients.
+     */
+    getAllClients(): MCPClient[];
+    /**
+     * Check if a client is connected.
+     */
+    isConnected(name: string): boolean;
+    /**
+     * Get status of all servers.
+     */
+    getStatus(): Promise<MCPServerStatus[]>;
+    /**
+     * Get all tools from all connected servers.
+     */
+    listAllTools(): Promise<Record<string, MCPToolDefinition[]>>;
+    /**
+     * Get all resources from all connected servers.
+     */
+    listAllResources(): Promise<Record<string, MCPResource[]>>;
+    /**
+     * Get all prompts from all connected servers.
+     */
+    listAllPrompts(): Promise<Record<string, MCPPrompt[]>>;
+    /**
+     * Reload all connections.
+     */
+    reload(): Promise<void>;
+    /**
+     * Add a new server connection.
+     */
+    addServer(config: MCPConnectionOptions): Promise<boolean>;
+    /**
+     * Remove a server connection.
+     */
+    removeServer(name: string): Promise<boolean>;
+}

package/dist/types/facade/mcp-core/client.d.ts

@@ -0,0 +1,157 @@
+/**
+ * MCP Client - Single Server Connection
+ *
+ * Manages connection to one MCP server and provides
+ * methods to list/call tools, read resources, etc.
+ *
+ * Reference: MCP client implementation patterns.
+ */
+import type { MCPServerConfig, MCPToolDefinition, MCPResource, MCPPrompt, MCPToolCallResult, MCPLogHandler, MCPProgressHandler, MCPElicitationHandler, MCPRoot } from "./types.js";
+/**
+ * Options for creating an MCP client.
+ */
+export interface MCPClientOptions {
+    /** Unique name for this client */
+    name: string;
+    /** Server connection configuration */
+    config: MCPServerConfig;
+    /** Optional timeout in milliseconds */
+    timeout?: number;
+    /** Optional log handler */
+    logger?: MCPLogHandler;
+    /** Whether to enable server logs (default: true) */
+    enableServerLogs?: boolean;
+    /** Whether to enable progress tracking (default: false) */
+    enableProgressTracking?: boolean;
+    /** Filesystem roots to expose to the server */
+    roots?: MCPRoot[];
+}
+/**
+ * MCP Client - manages connection to a single MCP server.
+ *
+ * Supports stdio transport (subprocess communication).
+ * Provides methods to list tools, call tools, read resources, etc.
+ *
+ * @example
+ * ```typescript
+ * const client = new MCPClient({
+ *   name: "filesystem",
+ *   config: {
+ *     command: "npx",
+ *     args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+ *   },
+ * });
+ *
+ * await client.connect();
+ * const tools = await client.listTools();
+ * const result = await client.callTool("read_file", { path: "./test.txt" });
+ * await client.disconnect();
+ * ```
+ */
+export declare class MCPClient {
+    private options;
+    private process?;
+    private buffer;
+    private messageId;
+    private pendingRequests;
+    private isConnected;
+    private connectionPromise;
+    private serverCapabilities?;
+    private logHandler?;
+    private enableServerLogs;
+    private enableProgressTracking;
+    private _roots;
+    /** Server name */
+    readonly serverName: string;
+    /** Server config */
+    readonly config: MCPServerConfig;
+    /** Request timeout */
+    readonly timeout: number;
+    constructor(options: MCPClientOptions);
+    /**
+     * Connect to the MCP server.
+     * Safe to call multiple times - returns existing connection if already connected.
+     */
+    connect(): Promise<void>;
+    private doConnect;
+    private connectHttp;
+    private connectStdio;
+    /**
+     * Disconnect from the MCP server.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Whether the client is connected.
+     */
+    get connected(): boolean;
+    /**
+     * List all tools available from the server.
+     */
+    listTools(): Promise<MCPToolDefinition[]>;
+    /**
+     * Call a tool on the server.
+     */
+    callTool(name: string, args: Record<string, unknown>): Promise<MCPToolCallResult>;
+    /**
+     * List all resources available from the server.
+     */
+    listResources(): Promise<MCPResource[]>;
+    /**
+     * Read a resource from the server.
+     */
+    readResource(uri: string): Promise<unknown>;
+    /**
+     * Subscribe to resource updates.
+     */
+    subscribeResource(uri: string): Promise<void>;
+    /**
+     * Unsubscribe from resource updates.
+     */
+    unsubscribeResource(uri: string): Promise<void>;
+    /**
+     * List all prompts available from the server.
+     */
+    listPrompts(): Promise<MCPPrompt[]>;
+    /**
+     * Get a prompt from the server.
+     */
+    getPrompt(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Get the configured roots.
+     */
+    get roots(): MCPRoot[];
+    /**
+     * Update the roots and notify the server.
+     */
+    setRoots(roots: MCPRoot[]): Promise<void>;
+    /**
+     * Set a handler for resource updated notifications.
+     */
+    setResourceUpdatedHandler(handler: (params: {
+        uri: string;
+    }) => void): void;
+    /**
+     * Set a handler for resource list changed notifications.
+     */
+    setResourceListChangedHandler(handler: () => void): void;
+    /**
+     * Set a handler for prompt list changed notifications.
+     */
+    setPromptListChangedHandler(handler: () => void): void;
+    /**
+     * Set a handler for elicitation requests.
+     */
+    setElicitationHandler(handler: MCPElicitationHandler): void;
+    /**
+     * Set a handler for progress notifications.
+     */
+    setProgressHandler(handler: MCPProgressHandler): void;
+    private ensureConnected;
+    private sendRequest;
+    private sendHttpRequest;
+    private sendNotification;
+    private processBuffer;
+    private handleMessage;
+    private handleNotification;
+    private log;
+}

package/dist/types/facade/mcp-core/config.d.ts

@@ -0,0 +1,60 @@
+/**
+ * MCP Configuration Loading
+ *
+ * Loads MCP server configurations from XDG-compliant paths:
+ * - Project: ./.indusvx/mcp.json
+ * - User: ~/.config/indusvx/mcp.json (XDG)
+ * - Legacy: ~/.indusvx/agent/mcp.json
+ *
+ * Reference: MCP configuration loading patterns.
+ */
+import type { MCPConnectionOptions, MCPConfigFile } from "./types.js";
+/**
+ * Load MCP configuration from all sources.
+ *
+ * If a specific file path is provided, loads from that file directly.
+ * Otherwise merges configurations from:
+ * 1. Project-level config: ./.indusvx/mcp.json
+ * 2. User-level (XDG): ~/.config/indusvx/mcp.json
+ * 3. Legacy: ~/.indusvx/agent/mcp.json or ~/.indusvx/agent/mcp-servers.json
+ *
+ * @param configPathOrCwd - Either a specific config file path, or a working directory
+ * @returns Array of MCP connection options
+ */
+export declare function loadMCPConfig(configPathOrCwd?: string): MCPConnectionOptions[];
+/**
+ * Get the path where user config should be saved.
+ */
+export declare function getUserConfigPath(): string;
+/**
+ * Get the path where project config should be saved.
+ */
+export declare function getProjectConfigPath(cwd?: string): string;
+/**
+ * Ensure the user config directory exists.
+ */
+export declare function ensureUserConfigDir(): string;
+/**
+ * Ensure the project config directory exists.
+ */
+export declare function ensureProjectConfigDir(cwd?: string): string;
+/**
+ * Save configuration to a file.
+ */
+export declare function saveConfig(path: string, config: MCPConfigFile): void;
+/**
+ * Save user configuration.
+ */
+export declare function saveUserConfig(config: MCPConfigFile): void;
+/**
+ * Save project configuration.
+ */
+export declare function saveProjectConfig(config: MCPConfigFile, cwd?: string): void;
+/**
+ * Create a default configuration.
+ */
+export declare function createDefaultConfig(): MCPConfigFile;
+/**
+ * Example configuration for documentation.
+ */
+export declare const EXAMPLE_CONFIG: MCPConfigFile;

package/dist/types/facade/mcp-core/errors.d.ts

@@ -0,0 +1,103 @@
+/**
+ * MCP Error Types
+ *
+ * Reference: structured MCP error handling patterns.
+ */
+/**
+ * Error codes for MCP operations.
+ */
+export declare enum MCPErrorCode {
+    /** Failed to connect to MCP server */
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    /** Request timed out */
+    TIMEOUT = "TIMEOUT",
+    /** Tool not found on server */
+    TOOL_NOT_FOUND = "TOOL_NOT_FOUND",
+    /** Invalid parameters for tool call */
+    INVALID_PARAMETERS = "INVALID_PARAMETERS",
+    /** Server returned an error */
+    SERVER_ERROR = "SERVER_ERROR",
+    /** Transport layer error */
+    TRANSPORT_ERROR = "TRANSPORT_ERROR",
+    /** Not connected to server */
+    NOT_CONNECTED = "NOT_CONNECTED",
+    /** Protocol error */
+    PROTOCOL_ERROR = "PROTOCOL_ERROR",
+    /** Configuration error */
+    CONFIG_ERROR = "CONFIG_ERROR",
+    /** Schema conversion error */
+    SCHEMA_CONVERSION_ERROR = "SCHEMA_CONVERSION_ERROR",
+    /** Resource not found */
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
+    /** Prompt not found */
+    PROMPT_NOT_FOUND = "PROMPT_NOT_FOUND",
+    /** Session error (requires reconnection) */
+    SESSION_ERROR = "SESSION_ERROR"
+}
+/**
+ * Error class for MCP operations.
+ * Provides structured error information with error codes and details.
+ */
+export declare class MCPError extends Error {
+    /** Error code */
+    readonly code: MCPErrorCode;
+    /** Additional error details */
+    readonly details?: unknown;
+    /** Server name where error occurred */
+    readonly serverName?: string;
+    /** Tool name if error occurred during tool execution */
+    readonly toolName?: string;
+    constructor(message: string, code: MCPErrorCode, details?: unknown, options?: {
+        serverName?: string;
+        toolName?: string;
+        cause?: Error;
+    });
+    /**
+     * Convert error to JSON for logging/serialization.
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Create a string representation of the error.
+     */
+    toString(): string;
+}
+/**
+ * Type guard to check if an error is an MCPError.
+ */
+export declare function isMCPError(error: unknown): error is MCPError;
+/**
+ * Check if an error indicates a session problem requiring reconnection.
+ */
+export declare function isSessionError(error: unknown): boolean;
+/**
+ * Create a connection failed error.
+ */
+export declare function createConnectionError(serverName: string, cause?: Error): MCPError;
+/**
+ * Create a timeout error.
+ */
+export declare function createTimeoutError(operation: string, serverName?: string): MCPError;
+/**
+ * Create a tool not found error.
+ */
+export declare function createToolNotFoundError(toolName: string, serverName?: string): MCPError;
+/**
+ * Create an invalid parameters error.
+ */
+export declare function createInvalidParametersError(toolName: string, details: unknown, serverName?: string): MCPError;
+/**
+ * Create a server error.
+ */
+export declare function createServerError(message: string, serverName?: string, details?: unknown): MCPError;
+/**
+ * Create a not connected error.
+ */
+export declare function createNotConnectedError(serverName?: string): MCPError;
+/**
+ * Create a config error.
+ */
+export declare function createConfigError(message: string, details?: unknown): MCPError;
+/**
+ * Create a schema conversion error.
+ */
+export declare function createSchemaConversionError(toolName: string, details: unknown, serverName?: string): MCPError;

package/dist/types/facade/mcp-core/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * MCP Module - Public Exports
+ *
+ * This module provides Model Context Protocol (MCP) support for new_indusvx.
+ * It allows connecting to MCP servers and using their tools as AgentTools.
+ *
+ * @example
+ * ```typescript
+ * import { MCPClient, MCPClientPool, loadMCPConfig } from "new_indusvx/mcp";
+ * import { ToolRegistry } from "new_indusvx/agent";
+ *
+ * // Load config from file
+ * const configs = loadMCPConfig(process.cwd());
+ *
+ * // Create a client pool
+ * const pool = new MCPClientPool({ servers: configs });
+ * await pool.connectAll();
+ *
+ * // Register tools
+ * const registry = new ToolRegistry();
+ * for (const client of pool.getAllClients()) {
+ *   const tools = await client.listTools();
+ *   await registerMCPToolsInRegistry(registry, client, tools);
+ * }
+ * ```
+ */
+import { MCPClientPool } from "./client-pool.js";
+export { MCPClient, type MCPClientOptions } from "./client.js";
+export { MCPClientPool, type MCPClientPoolOptions, type MCPServerStatus } from "./client-pool.js";
+export { MCPServer, createMCPServer, type MCPServerOptions } from "./server.js";
+export { createMCPAgentToolFactory, registerMCPToolsInRegistry, createMCPToolsMap, createMCPToolsRecord, type MCPToolClient, } from "./tool-factory.js";
+export { jsonSchemaToTypeBox, applyPassthrough, convertMCPInputSchema, convertMCPOutputSchema, } from "./schema-converter.js";
+export { loadMCPConfig, getUserConfigPath, getProjectConfigPath, ensureUserConfigDir, ensureProjectConfigDir, saveConfig, saveUserConfig, saveProjectConfig, createDefaultConfig, EXAMPLE_CONFIG, } from "./config.js";
+export { MCPError, MCPErrorCode, isMCPError, isSessionError, createConnectionError, createTimeoutError, createToolNotFoundError, createInvalidParametersError, createServerError, createNotConnectedError, createConfigError, createSchemaConversionError, } from "./errors.js";
+export type { StdioServerConfig, HttpServerConfig, MCPServerConfig, MCPConnectionOptions, MCPToolDefinition, MCPResource, MCPPrompt, MCPInitializeResult, MCPClientState, MCPToolCallRequest, MCPContentBlock, MCPToolCallResult, MCPServerConfigEntry, MCPConfigFile, MCPLoggingLevel, MCPLogMessage, MCPLogHandler, MCPProgressNotification, MCPProgressHandler, MCPElicitRequest, MCPElicitResult, MCPElicitationHandler, MCPRoot, BaseServerOptions, } from "./types.js";
+/**
+ * Convenience function: Initialize MCP and register tools.
+ *
+ * This is the simplest way to add MCP support to an agent.
+ *
+ * @example
+ * ```typescript
+ * import { initializeMCP } from "new_indusvx/mcp";
+ * import { ToolRegistry, Agent } from "new_indusvx/agent";
+ *
+ * const registry = new ToolRegistry();
+ * const { pool, toolCount } = await initializeMCP(registry, process.cwd());
+ *
+ * console.log(`Connected to ${pool.getAllClients().length} servers with ${toolCount} tools`);
+ * ```
+ */
+export declare function initializeMCP(registry: import("../bot/actions/registry.js").ToolRegistry, cwd?: string): Promise<{
+    pool: MCPClientPool;
+    toolCount: number;
+}>;