indusagi 0.12.32 → 0.12.34

package/dist/mcp.js

@@ -0,0 +1,1732 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/facade/mcp-core/client.ts
+import { spawn } from "child_process";
+
+// src/facade/mcp-core/errors.ts
+var MCPErrorCode = /* @__PURE__ */ ((MCPErrorCode2) => {
+  MCPErrorCode2["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+  MCPErrorCode2["TIMEOUT"] = "TIMEOUT";
+  MCPErrorCode2["TOOL_NOT_FOUND"] = "TOOL_NOT_FOUND";
+  MCPErrorCode2["INVALID_PARAMETERS"] = "INVALID_PARAMETERS";
+  MCPErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
+  MCPErrorCode2["TRANSPORT_ERROR"] = "TRANSPORT_ERROR";
+  MCPErrorCode2["NOT_CONNECTED"] = "NOT_CONNECTED";
+  MCPErrorCode2["PROTOCOL_ERROR"] = "PROTOCOL_ERROR";
+  MCPErrorCode2["CONFIG_ERROR"] = "CONFIG_ERROR";
+  MCPErrorCode2["SCHEMA_CONVERSION_ERROR"] = "SCHEMA_CONVERSION_ERROR";
+  MCPErrorCode2["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
+  MCPErrorCode2["PROMPT_NOT_FOUND"] = "PROMPT_NOT_FOUND";
+  MCPErrorCode2["SESSION_ERROR"] = "SESSION_ERROR";
+  return MCPErrorCode2;
+})(MCPErrorCode || {});
+var MCPError = class extends Error {
+  /** Error code */
+  code;
+  /** Additional error details */
+  details;
+  /** Server name where error occurred */
+  serverName;
+  /** Tool name if error occurred during tool execution */
+  toolName;
+  constructor(message, code, details, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.name = "MCPError";
+    this.code = code;
+    this.details = details;
+    this.serverName = options?.serverName;
+    this.toolName = options?.toolName;
+  }
+  /**
+   * Convert error to JSON for logging/serialization.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      serverName: this.serverName,
+      toolName: this.toolName
+    };
+  }
+  /**
+   * Create a string representation of the error.
+   */
+  toString() {
+    let str = `${this.name} [${this.code}]: ${this.message}`;
+    if (this.serverName) str += ` (server: ${this.serverName})`;
+    if (this.toolName) str += ` (tool: ${this.toolName})`;
+    return str;
+  }
+};
+function isMCPError(error) {
+  return error instanceof MCPError;
+}
+function isSessionError(error) {
+  if (!isMCPError(error)) return false;
+  return error.code === "SESSION_ERROR" /* SESSION_ERROR */ || error.code === "NOT_CONNECTED" /* NOT_CONNECTED */;
+}
+function createConnectionError(serverName, cause) {
+  return new MCPError(
+    `Failed to connect to MCP server: ${serverName}`,
+    "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+    { cause: cause?.message },
+    { serverName, cause }
+  );
+}
+function createTimeoutError(operation, serverName) {
+  return new MCPError(`Operation timed out: ${operation}`, "TIMEOUT" /* TIMEOUT */, { operation }, { serverName });
+}
+function createToolNotFoundError(toolName, serverName) {
+  return new MCPError(`Tool not found: ${toolName}`, "TOOL_NOT_FOUND" /* TOOL_NOT_FOUND */, { toolName }, { serverName, toolName });
+}
+function createInvalidParametersError(toolName, details, serverName) {
+  return new MCPError(
+    `Invalid parameters for tool: ${toolName}`,
+    "INVALID_PARAMETERS" /* INVALID_PARAMETERS */,
+    details,
+    { serverName, toolName }
+  );
+}
+function createServerError(message, serverName, details) {
+  return new MCPError(message, "SERVER_ERROR" /* SERVER_ERROR */, details, { serverName });
+}
+function createNotConnectedError(serverName) {
+  return new MCPError("Not connected to MCP server", "NOT_CONNECTED" /* NOT_CONNECTED */, void 0, { serverName });
+}
+function createConfigError(message, details) {
+  return new MCPError(message, "CONFIG_ERROR" /* CONFIG_ERROR */, details);
+}
+function createSchemaConversionError(toolName, details, serverName) {
+  return new MCPError(
+    `Failed to convert schema for tool: ${toolName}`,
+    "SCHEMA_CONVERSION_ERROR" /* SCHEMA_CONVERSION_ERROR */,
+    details,
+    { serverName, toolName }
+  );
+}
+
+// src/facade/mcp-core/client.ts
+var DEFAULT_REQUEST_TIMEOUT = 6e4;
+var MCPClient = class {
+  constructor(options) {
+    this.options = options;
+    this.serverName = options.name;
+    this.config = options.config;
+    this.timeout = options.timeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this.logHandler = options.logger;
+    this.enableServerLogs = options.enableServerLogs ?? true;
+    this.enableProgressTracking = options.enableProgressTracking ?? false;
+    this._roots = options.roots ?? [];
+  }
+  options;
+  process;
+  buffer = "";
+  messageId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  isConnected = false;
+  connectionPromise = null;
+  serverCapabilities;
+  logHandler;
+  enableServerLogs;
+  enableProgressTracking;
+  _roots;
+  /** Server name */
+  serverName;
+  /** Server config */
+  config;
+  /** Request timeout */
+  timeout;
+  // ========================================================================
+  // Connection Lifecycle
+  // ========================================================================
+  /**
+   * Connect to the MCP server.
+   * Safe to call multiple times - returns existing connection if already connected.
+   */
+  async connect() {
+    if (this.isConnected) return;
+    if (this.connectionPromise) {
+      return this.connectionPromise;
+    }
+    this.connectionPromise = this.doConnect();
+    try {
+      await this.connectionPromise;
+    } finally {
+      this.connectionPromise = null;
+    }
+  }
+  async doConnect() {
+    if ("command" in this.config) {
+      await this.connectStdio(this.config);
+    } else if ("url" in this.config) {
+      await this.connectHttp(this.config);
+    } else {
+      throw new MCPError(
+        "Server configuration must include either a command or a url",
+        "CONFIG_ERROR" /* CONFIG_ERROR */,
+        void 0,
+        { serverName: this.serverName }
+      );
+    }
+    const initResult = await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        ...this._roots.length > 0 ? { roots: { listChanged: true } } : {},
+        elicitation: {}
+      },
+      clientInfo: {
+        name: "new_indusvx",
+        version: "1.0.0"
+      }
+    });
+    this.serverCapabilities = initResult.capabilities;
+    this.isConnected = true;
+    await this.sendNotification("notifications/initialized", {});
+    this.log("info", `Connected to MCP server`);
+  }
+  async connectHttp(config) {
+    this.log("debug", `Starting HTTP transport: ${config.url.toString()}`);
+    this.isConnected = true;
+  }
+  async connectStdio(config) {
+    return new Promise((resolve, reject) => {
+      this.log("debug", `Starting stdio transport: ${config.command} ${(config.args ?? []).join(" ")}`);
+      this.process = spawn(config.command, config.args ?? [], {
+        env: { ...process.env, ...config.env },
+        cwd: config.cwd,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      this.process.stdout?.on("data", (data) => {
+        this.buffer += data.toString("utf-8");
+        this.processBuffer();
+      });
+      this.process.stderr?.on("data", (data) => {
+        const message = data.toString("utf-8").trim();
+        if (message) {
+          this.log("debug", `[stderr] ${message}`);
+        }
+      });
+      this.process.on("error", (error) => {
+        const mcpError = new MCPError(
+          `Failed to spawn MCP server: ${error.message}`,
+          "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+          { error: error.message },
+          { serverName: this.serverName, cause: error }
+        );
+        reject(mcpError);
+      });
+      this.process.on("close", (code) => {
+        this.isConnected = false;
+        if (code !== 0 && code !== null) {
+          this.log("warning", `Process exited with code ${code}`);
+        }
+        for (const [id, { reject: reqReject, timeout }] of this.pendingRequests) {
+          clearTimeout(timeout);
+          reqReject(new MCPError("Connection closed", "NOT_CONNECTED" /* NOT_CONNECTED */));
+        }
+        this.pendingRequests.clear();
+      });
+      setTimeout(resolve, 500);
+    });
+  }
+  /**
+   * Disconnect from the MCP server.
+   */
+  async disconnect() {
+    if ("url" in this.config) {
+      this.isConnected = false;
+      this.log("debug", "Disconnected from HTTP MCP server");
+      return;
+    }
+    if (!this.process) {
+      this.log("debug", "Disconnect called but no process was running");
+      return;
+    }
+    this.log("debug", "Disconnecting from MCP server");
+    try {
+      this.process.kill();
+      this.process = void 0;
+      this.isConnected = false;
+      for (const [id, { reject, timeout }] of this.pendingRequests) {
+        clearTimeout(timeout);
+        reject(new MCPError("Connection closed", "NOT_CONNECTED" /* NOT_CONNECTED */));
+      }
+      this.pendingRequests.clear();
+      this.log("debug", "Successfully disconnected");
+    } catch (error) {
+      this.log("error", `Error during disconnect: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Whether the client is connected.
+   */
+  get connected() {
+    return this.isConnected;
+  }
+  // ========================================================================
+  // Tool Operations
+  // ========================================================================
+  /**
+   * List all tools available from the server.
+   */
+  async listTools() {
+    this.ensureConnected();
+    const result = await this.sendRequest("tools/list", {});
+    return result.tools;
+  }
+  /**
+   * Call a tool on the server.
+   */
+  async callTool(name, args) {
+    this.ensureConnected();
+    this.log("debug", `Calling tool: ${name}`);
+    try {
+      const result = await this.sendRequest("tools/call", {
+        name,
+        arguments: args
+      });
+      this.log("debug", `Tool ${name} executed successfully`);
+      return result;
+    } catch (error) {
+      this.log("error", `Tool ${name} failed: ${error}`);
+      throw error;
+    }
+  }
+  // ========================================================================
+  // Resource Operations
+  // ========================================================================
+  /**
+   * List all resources available from the server.
+   */
+  async listResources() {
+    this.ensureConnected();
+    if (!this.serverCapabilities?.resources) {
+      return [];
+    }
+    const result = await this.sendRequest("resources/list", {});
+    return result.resources;
+  }
+  /**
+   * Read a resource from the server.
+   */
+  async readResource(uri) {
+    this.ensureConnected();
+    return await this.sendRequest("resources/read", { uri });
+  }
+  /**
+   * Subscribe to resource updates.
+   */
+  async subscribeResource(uri) {
+    this.ensureConnected();
+    await this.sendRequest("resources/subscribe", { uri });
+  }
+  /**
+   * Unsubscribe from resource updates.
+   */
+  async unsubscribeResource(uri) {
+    this.ensureConnected();
+    await this.sendRequest("resources/unsubscribe", { uri });
+  }
+  // ========================================================================
+  // Prompt Operations
+  // ========================================================================
+  /**
+   * List all prompts available from the server.
+   */
+  async listPrompts() {
+    this.ensureConnected();
+    if (!this.serverCapabilities?.prompts) {
+      return [];
+    }
+    const result = await this.sendRequest("prompts/list", {});
+    return result.prompts;
+  }
+  /**
+   * Get a prompt from the server.
+   */
+  async getPrompt(name, args) {
+    this.ensureConnected();
+    return await this.sendRequest("prompts/get", { name, arguments: args });
+  }
+  // ========================================================================
+  // Roots Operations
+  // ========================================================================
+  /**
+   * Get the configured roots.
+   */
+  get roots() {
+    return [...this._roots];
+  }
+  /**
+   * Update the roots and notify the server.
+   */
+  async setRoots(roots) {
+    this.log("debug", `Updating roots to ${roots.length} entries`);
+    this._roots = [...roots];
+    if (this.isConnected) {
+      await this.sendNotification("notifications/roots/list_changed", {});
+    }
+  }
+  // ========================================================================
+  // Handler Registration
+  // ========================================================================
+  /**
+   * Set a handler for resource updated notifications.
+   */
+  setResourceUpdatedHandler(handler) {
+    this.log("debug", "Resource updated handler registered");
+  }
+  /**
+   * Set a handler for resource list changed notifications.
+   */
+  setResourceListChangedHandler(handler) {
+    this.log("debug", "Resource list changed handler registered");
+  }
+  /**
+   * Set a handler for prompt list changed notifications.
+   */
+  setPromptListChangedHandler(handler) {
+    this.log("debug", "Prompt list changed handler registered");
+  }
+  /**
+   * Set a handler for elicitation requests.
+   */
+  setElicitationHandler(handler) {
+    this.log("debug", "Elicitation handler registered");
+  }
+  /**
+   * Set a handler for progress notifications.
+   */
+  setProgressHandler(handler) {
+    this.log("debug", "Progress handler registered");
+  }
+  // ========================================================================
+  // Private Methods
+  // ========================================================================
+  ensureConnected() {
+    const isHttpTransport = "url" in this.config;
+    if (!this.isConnected || !isHttpTransport && !this.process) {
+      throw new MCPError(
+        "Not connected to MCP server",
+        "NOT_CONNECTED" /* NOT_CONNECTED */,
+        void 0,
+        { serverName: this.serverName }
+      );
+    }
+  }
+  async sendRequest(method, params) {
+    if (method !== "initialize") {
+      this.ensureConnected();
+    }
+    if ("url" in this.config) {
+      return this.sendHttpRequest(method, params);
+    }
+    if (!this.process) {
+      throw new MCPError(
+        "Not connected to MCP server",
+        "NOT_CONNECTED" /* NOT_CONNECTED */,
+        void 0,
+        { serverName: this.serverName }
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const id = ++this.messageId;
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(
+          new MCPError(
+            `Request timeout: ${method}`,
+            "TIMEOUT" /* TIMEOUT */,
+            { method, id },
+            { serverName: this.serverName }
+          )
+        );
+      }, this.timeout);
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timeout
+      });
+      const message = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      };
+      this.log("debug", `Sending request: ${method} (id: ${id})`);
+      try {
+        const messageStr = JSON.stringify(message) + "\n";
+        this.process.stdin.write(messageStr);
+      } catch (error) {
+        this.pendingRequests.delete(id);
+        clearTimeout(timeout);
+        reject(
+          new MCPError(
+            `Failed to send request: ${error}`,
+            "TRANSPORT_ERROR" /* TRANSPORT_ERROR */,
+            { error: String(error) },
+            { serverName: this.serverName }
+          )
+        );
+      }
+    });
+  }
+  async sendHttpRequest(method, params) {
+    const config = this.config;
+    const id = ++this.messageId;
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    this.log("debug", `Sending HTTP request: ${method} (id: ${id})`);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(config.url.toString(), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json, text/event-stream",
+          ...config.headers
+        },
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage = `HTTP error: ${response.status} ${response.statusText}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          if (errorJson.error?.message) {
+            errorMessage = errorJson.error.message;
+          }
+        } catch {
+          if (errorText) {
+            errorMessage = errorText;
+          }
+        }
+        throw new MCPError(
+          errorMessage,
+          "TRANSPORT_ERROR" /* TRANSPORT_ERROR */,
+          { status: response.status, body: errorText },
+          { serverName: this.serverName }
+        );
+      }
+      const responseText = await response.text();
+      let result;
+      if (responseText.startsWith("event:") || responseText.startsWith("data:")) {
+        const lines = responseText.split("\n");
+        let dataLine = "";
+        for (const line of lines) {
+          if (line.startsWith("data:")) {
+            dataLine = line.slice(5).trim();
+            break;
+          }
+        }
+        if (dataLine) {
+          result = JSON.parse(dataLine);
+        } else {
+          throw new MCPError(
+            "Empty SSE response",
+            "TRANSPORT_ERROR" /* TRANSPORT_ERROR */,
+            { response: responseText },
+            { serverName: this.serverName }
+          );
+        }
+      } else {
+        result = JSON.parse(responseText);
+      }
+      if (result.error) {
+        throw new MCPError(
+          result.error.message || "MCP error",
+          "SERVER_ERROR" /* SERVER_ERROR */,
+          result.error,
+          { serverName: this.serverName }
+        );
+      }
+      this.log("debug", `HTTP request ${id} succeeded`);
+      return result.result;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof MCPError) throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new MCPError(
+          `Request timeout: ${method}`,
+          "TIMEOUT" /* TIMEOUT */,
+          { method, id },
+          { serverName: this.serverName }
+        );
+      }
+      throw new MCPError(
+        `HTTP request failed: ${error}`,
+        "TRANSPORT_ERROR" /* TRANSPORT_ERROR */,
+        { error: String(error) },
+        { serverName: this.serverName }
+      );
+    }
+  }
+  async sendNotification(method, params) {
+    const message = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    this.log("debug", `Sending notification: ${method}`);
+    if ("url" in this.config) {
+      const config = this.config;
+      try {
+        await fetch(config.url.toString(), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.headers
+          },
+          body: JSON.stringify(message)
+        });
+      } catch (error) {
+        this.log("error", `Failed to send HTTP notification: ${error}`);
+      }
+      return;
+    }
+    if (!this.process) {
+      throw new MCPError(
+        "Not connected to MCP server",
+        "NOT_CONNECTED" /* NOT_CONNECTED */,
+        void 0,
+        { serverName: this.serverName }
+      );
+    }
+    try {
+      const messageStr = JSON.stringify(message) + "\n";
+      this.process.stdin.write(messageStr);
+    } catch (error) {
+      this.log("error", `Failed to send notification: ${error}`);
+    }
+  }
+  processBuffer() {
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const message = JSON.parse(trimmed);
+        this.handleMessage(message);
+      } catch (error) {
+        this.log("warning", `Failed to parse message: ${trimmed}`);
+      }
+    }
+  }
+  handleMessage(message) {
+    if (message.id !== void 0 && this.pendingRequests.has(message.id)) {
+      const { resolve, reject, timeout } = this.pendingRequests.get(message.id);
+      this.pendingRequests.delete(message.id);
+      clearTimeout(timeout);
+      if (message.error) {
+        this.log("debug", `Request ${message.id} failed: ${message.error.message}`);
+        reject(
+          new MCPError(
+            message.error.message || "Unknown error",
+            "SERVER_ERROR" /* SERVER_ERROR */,
+            message.error,
+            { serverName: this.serverName }
+          )
+        );
+      } else {
+        this.log("debug", `Request ${message.id} succeeded`);
+        resolve(message.result);
+      }
+    }
+    if (message.method) {
+      this.handleNotification(message.method, message.params);
+    }
+  }
+  handleNotification(method, params) {
+    this.log("debug", `Received notification: ${method}`);
+    switch (method) {
+      case "notifications/message":
+        if (this.enableServerLogs && params) {
+          const { level, ...rest } = params;
+          this.log(level || "info", "[SERVER]", rest);
+        }
+        break;
+      case "notifications/progress":
+        this.log("debug", `Progress: ${JSON.stringify(params)}`);
+        break;
+      case "notifications/resources/updated":
+        this.log("debug", `Resource updated: ${JSON.stringify(params)}`);
+        break;
+      case "notifications/resources/list_changed":
+        this.log("debug", "Resource list changed");
+        break;
+      case "notifications/prompts/list_changed":
+        this.log("debug", "Prompt list changed");
+        break;
+    }
+  }
+  log(level, message, details) {
+    const msg = `[${this.serverName}] ${message}`;
+    if (this.logHandler) {
+      this.logHandler({
+        level,
+        message: msg,
+        timestamp: /* @__PURE__ */ new Date(),
+        serverName: this.serverName,
+        details
+      });
+    } else {
+      if (process.env.INDUSAGI_DEBUG || level === "error") {
+        const prefix = `[MCP:${level.toUpperCase()}]`;
+        if (details) {
+          if (level === "error") {
+            console.error(prefix, msg, details);
+          } else {
+            console.log(prefix, msg, details);
+          }
+        } else {
+          if (level === "error") {
+            console.error(prefix, msg);
+          } else {
+            console.log(prefix, msg);
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/facade/mcp-core/client-pool.ts
+var MCPClientPool = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  clients = /* @__PURE__ */ new Map();
+  isConnecting = false;
+  /**
+   * Connect to all configured servers.
+   *
+   * Errors for individual servers are logged but don't fail the entire operation.
+   */
+  async connectAll() {
+    if (this.isConnecting) {
+      throw new MCPError(
+        "Already connecting to servers",
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */
+      );
+    }
+    this.isConnecting = true;
+    try {
+      for (const serverConfig of this.options.servers) {
+        try {
+          const client = new MCPClient(serverConfig);
+          await client.connect();
+          this.clients.set(serverConfig.name, client);
+          console.log(`[MCP] Connected to ${serverConfig.name}`);
+        } catch (error) {
+          console.error(
+            `[MCP] Failed to connect to ${serverConfig.name}:`,
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    } finally {
+      this.isConnecting = false;
+    }
+  }
+  /**
+   * Disconnect from all servers.
+   */
+  async disconnectAll() {
+    for (const [name, client] of this.clients) {
+      try {
+        await client.disconnect();
+        console.log(`[MCP] Disconnected from ${name}`);
+      } catch (error) {
+        console.error(`[MCP] Error disconnecting from ${name}:`, error);
+      }
+    }
+    this.clients.clear();
+  }
+  /**
+   * Get a specific client by name.
+   */
+  getClient(name) {
+    return this.clients.get(name);
+  }
+  /**
+   * Get all connected clients.
+   */
+  getAllClients() {
+    return Array.from(this.clients.values());
+  }
+  /**
+   * Check if a client is connected.
+   */
+  isConnected(name) {
+    return this.clients.get(name)?.connected ?? false;
+  }
+  /**
+   * Get status of all servers.
+   */
+  async getStatus() {
+    const statuses = [];
+    for (const [name, client] of this.clients) {
+      const status = {
+        name,
+        connected: client.connected
+      };
+      if (client.connected) {
+        try {
+          const tools = await client.listTools();
+          status.toolCount = tools.length;
+        } catch {
+        }
+        try {
+          const resources = await client.listResources();
+          status.resourceCount = resources.length;
+        } catch {
+        }
+        try {
+          const prompts = await client.listPrompts();
+          status.promptCount = prompts.length;
+        } catch {
+        }
+      }
+      statuses.push(status);
+    }
+    return statuses;
+  }
+  /**
+   * Get all tools from all connected servers.
+   */
+  async listAllTools() {
+    const allTools = {};
+    for (const [name, client] of this.clients) {
+      if (client.connected) {
+        try {
+          allTools[name] = await client.listTools();
+        } catch (error) {
+          console.error(`[MCP] Failed to list tools from ${name}:`, error);
+          allTools[name] = [];
+        }
+      }
+    }
+    return allTools;
+  }
+  /**
+   * Get all resources from all connected servers.
+   */
+  async listAllResources() {
+    const allResources = {};
+    for (const [name, client] of this.clients) {
+      if (client.connected) {
+        try {
+          allResources[name] = await client.listResources();
+        } catch (error) {
+          console.error(`[MCP] Failed to list resources from ${name}:`, error);
+          allResources[name] = [];
+        }
+      }
+    }
+    return allResources;
+  }
+  /**
+   * Get all prompts from all connected servers.
+   */
+  async listAllPrompts() {
+    const allPrompts = {};
+    for (const [name, client] of this.clients) {
+      if (client.connected) {
+        try {
+          allPrompts[name] = await client.listPrompts();
+        } catch (error) {
+          console.error(`[MCP] Failed to list prompts from ${name}:`, error);
+          allPrompts[name] = [];
+        }
+      }
+    }
+    return allPrompts;
+  }
+  /**
+   * Reload all connections.
+   */
+  async reload() {
+    await this.disconnectAll();
+    await this.connectAll();
+  }
+  /**
+   * Add a new server connection.
+   */
+  async addServer(config) {
+    if (this.clients.has(config.name)) {
+      console.warn(`[MCP] Server ${config.name} already exists`);
+      return false;
+    }
+    try {
+      const client = new MCPClient(config);
+      await client.connect();
+      this.clients.set(config.name, client);
+      console.log(`[MCP] Connected to ${config.name}`);
+      return true;
+    } catch (error) {
+      console.error(`[MCP] Failed to connect to ${config.name}:`, error);
+      return false;
+    }
+  }
+  /**
+   * Remove a server connection.
+   */
+  async removeServer(name) {
+    const client = this.clients.get(name);
+    if (!client) {
+      return false;
+    }
+    try {
+      await client.disconnect();
+      this.clients.delete(name);
+      console.log(`[MCP] Disconnected from ${name}`);
+      return true;
+    } catch (error) {
+      console.error(`[MCP] Error disconnecting from ${name}:`, error);
+      return false;
+    }
+  }
+};
+
+// src/facade/mcp-core/config.ts
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+function loadMCPConfig(configPathOrCwd = process.cwd()) {
+  const configs = [];
+  if (existsSync(configPathOrCwd)) {
+    try {
+      const stats = __require("fs").statSync(configPathOrCwd);
+      if (stats.isFile()) {
+        const fileConfigs = parseConfigFile(configPathOrCwd);
+        configs.push(...fileConfigs);
+        return configs;
+      }
+    } catch {
+    }
+  }
+  const cwd = configPathOrCwd;
+  const projectConfig = join(cwd, ".indusvx", "mcp.json");
+  if (existsSync(projectConfig)) {
+    try {
+      const projectConfigs = parseConfigFile(projectConfig);
+      configs.push(...projectConfigs);
+      console.log(`[MCP] Loaded ${projectConfigs.length} servers from project config`);
+    } catch (error) {
+      console.error(`[MCP] Error loading project config:`, error);
+    }
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  const userConfig = join(xdgConfigHome, "indusvx", "mcp.json");
+  if (existsSync(userConfig)) {
+    try {
+      const userConfigs = parseConfigFile(userConfig);
+      configs.push(...userConfigs);
+      console.log(`[MCP] Loaded ${userConfigs.length} servers from user config`);
+    } catch (error) {
+      console.error(`[MCP] Error loading user config:`, error);
+    }
+  }
+  const legacyConfig = join(homedir(), ".indusvx", "agent", "mcp.json");
+  if (existsSync(legacyConfig)) {
+    try {
+      const legacyConfigs = parseConfigFile(legacyConfig);
+      configs.push(...legacyConfigs);
+      console.log(`[MCP] Loaded ${legacyConfigs.length} servers from legacy config`);
+    } catch (error) {
+      console.error(`[MCP] Error loading legacy config:`, error);
+    }
+  }
+  const legacyServersConfig = join(homedir(), ".indusvx", "agent", "mcp-servers.json");
+  if (existsSync(legacyServersConfig)) {
+    try {
+      const legacyConfigs = parseConfigFile(legacyServersConfig);
+      configs.push(...legacyConfigs);
+      console.log(`[MCP] Loaded ${legacyConfigs.length} servers from mcp-servers.json`);
+    } catch (error) {
+      console.error(`[MCP] Error loading mcp-servers.json:`, error);
+    }
+  }
+  return configs;
+}
+function parseConfigFile(path) {
+  const content = readFileSync(path, "utf-8");
+  const config = JSON.parse(content);
+  if (!config.servers) {
+    console.warn(`[MCP] Invalid config file ${path}: missing "servers" field`);
+    return [];
+  }
+  let serversArray;
+  if (Array.isArray(config.servers)) {
+    serversArray = config.servers;
+  } else if (typeof config.servers === "object") {
+    serversArray = Object.entries(config.servers).map(([name, serverConfig]) => ({
+      name,
+      ...serverConfig
+    }));
+  } else {
+    console.warn(`[MCP] Invalid config file ${path}: "servers" must be array or object`);
+    return [];
+  }
+  return serversArray.filter((server) => server.enabled !== false).map((server) => {
+    if (server.url) {
+      return {
+        name: server.name,
+        config: {
+          url: new URL(server.url),
+          headers: server.headers
+        },
+        timeout: server.timeout
+      };
+    } else if (server.command) {
+      return {
+        name: server.name,
+        config: {
+          command: server.command,
+          args: server.args,
+          env: server.env
+        },
+        timeout: server.timeout
+      };
+    }
+    throw new MCPError(
+      `Invalid server config: ${server.name}`,
+      "CONFIG_ERROR" /* CONFIG_ERROR */,
+      { server }
+    );
+  });
+}
+function getUserConfigPath() {
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(xdgConfigHome, "indusvx", "mcp.json");
+}
+function getProjectConfigPath(cwd = process.cwd()) {
+  return join(cwd, ".indusvx", "mcp.json");
+}
+function ensureUserConfigDir() {
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  const configDir = join(xdgConfigHome, "indusvx");
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  return configDir;
+}
+function ensureProjectConfigDir(cwd = process.cwd()) {
+  const configDir = join(cwd, ".indusvx");
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  return configDir;
+}
+function saveConfig(path, config) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const content = JSON.stringify(config, null, 2);
+  __require("fs").writeFileSync(path, content, "utf-8");
+}
+function saveUserConfig(config) {
+  saveConfig(getUserConfigPath(), config);
+}
+function saveProjectConfig(config, cwd = process.cwd()) {
+  saveConfig(getProjectConfigPath(cwd), config);
+}
+function createDefaultConfig() {
+  return {
+    servers: []
+  };
+}
+var EXAMPLE_CONFIG = {
+  servers: [
+    {
+      name: "filesystem",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"],
+      enabled: true
+    },
+    {
+      name: "github",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-github"],
+      env: {
+        GITHUB_TOKEN: "your-github-token"
+      },
+      enabled: true
+    },
+    {
+      name: "remote-server",
+      url: "http://localhost:8080/mcp",
+      headers: {
+        Authorization: "Bearer your-token"
+      },
+      enabled: false
+    }
+  ]
+};
+
+// src/facade/mcp-core/schema-converter.ts
+import { Type } from "@sinclair/typebox";
+function jsonSchemaToTypeBox(schema) {
+  if (schema.type === "null") {
+    return Type.Null({ description: schema.description });
+  }
+  if (schema.enum) {
+    if (schema.enum.length === 1) {
+      return Type.Literal(schema.enum[0], {
+        description: schema.description
+      });
+    }
+    const literals = schema.enum.map((e) => {
+      if (e === null) return Type.Null();
+      return Type.Literal(e);
+    });
+    return Type.Union(literals, { description: schema.description });
+  }
+  if (schema.const !== void 0) {
+    if (schema.const === null) {
+      return Type.Null({ description: schema.description });
+    }
+    return Type.Literal(schema.const, {
+      description: schema.description
+    });
+  }
+  if (schema.oneOf || schema.anyOf) {
+    const schemas = (schema.oneOf || schema.anyOf).map((s) => jsonSchemaToTypeBox(s));
+    return Type.Union(schemas, { description: schema.description });
+  }
+  if (schema.allOf) {
+    const schemas = schema.allOf.map((s) => jsonSchemaToTypeBox(s));
+    return Type.Intersect(schemas, { description: schema.description });
+  }
+  if (schema.type === "array" || Array.isArray(schema.type) && schema.type.includes("array")) {
+    return convertArraySchema(schema);
+  }
+  if (schema.type === "object" || Array.isArray(schema.type) && schema.type.includes("object")) {
+    return convertObjectSchema(schema);
+  }
+  switch (schema.type) {
+    case "string":
+      return convertStringSchema(schema);
+    case "number":
+    case "integer":
+      return convertNumberSchema(schema);
+    case "boolean":
+      return Type.Boolean({ description: schema.description });
+    default:
+      if (schema.properties) {
+        return convertObjectSchema(schema);
+      }
+      if (schema.items) {
+        return convertArraySchema(schema);
+      }
+      return Type.Any({ description: schema.description });
+  }
+}
+function convertStringSchema(schema) {
+  return Type.String({
+    description: schema.description,
+    minLength: schema.minLength,
+    maxLength: schema.maxLength,
+    pattern: schema.pattern,
+    format: schema.format
+  });
+}
+function convertNumberSchema(schema) {
+  const options = {
+    description: schema.description
+  };
+  if (schema.minimum !== void 0) options.minimum = schema.minimum;
+  if (schema.maximum !== void 0) options.maximum = schema.maximum;
+  if (typeof schema.exclusiveMinimum === "number") options.exclusiveMinimum = schema.exclusiveMinimum;
+  if (typeof schema.exclusiveMaximum === "number") options.exclusiveMaximum = schema.exclusiveMaximum;
+  if (schema.multipleOf !== void 0) options.multipleOf = schema.multipleOf;
+  return Type.Number(options);
+}
+function convertArraySchema(schema) {
+  let itemsSchema;
+  if (schema.items) {
+    if (Array.isArray(schema.items)) {
+      const items = schema.items.map((item) => jsonSchemaToTypeBox(item));
+      itemsSchema = Type.Tuple(items);
+    } else {
+      itemsSchema = jsonSchemaToTypeBox(schema.items);
+    }
+  } else {
+    itemsSchema = Type.Any();
+  }
+  return Type.Array(itemsSchema, {
+    description: schema.description,
+    minItems: schema.minItems,
+    maxItems: schema.maxItems
+  });
+}
+function convertObjectSchema(schema) {
+  const properties = {};
+  const required = new Set(schema.required ?? []);
+  for (const [key, value] of Object.entries(schema.properties ?? {})) {
+    let propSchema = jsonSchemaToTypeBox(value);
+    if (!required.has(key)) {
+      propSchema = Type.Optional(propSchema);
+    }
+    properties[key] = propSchema;
+  }
+  let additionalProperties = void 0;
+  if (schema.additionalProperties === true) {
+    additionalProperties = true;
+  } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    additionalProperties = jsonSchemaToTypeBox(schema.additionalProperties);
+  } else if (schema.additionalProperties === false) {
+    additionalProperties = false;
+  }
+  return Type.Object(properties, {
+    description: schema.description,
+    additionalProperties
+  });
+}
+function applyPassthrough(schema) {
+  const kind = schema[/* @__PURE__ */ Symbol.for("TypeBox.Kind")];
+  if (kind === "Object") {
+    const shape = { ...schema.properties };
+    for (const key of Object.keys(shape)) {
+      shape[key] = applyPassthrough(shape[key]);
+    }
+    return Type.Object(shape, {
+      description: schema.description,
+      additionalProperties: true
+    });
+  }
+  if (kind === "Array") {
+    return Type.Array(applyPassthrough(schema.items), {
+      description: schema.description,
+      minItems: schema.minItems,
+      maxItems: schema.maxItems
+    });
+  }
+  if (kind === "Union") {
+    return Type.Union(
+      schema.anyOf.map((s) => applyPassthrough(s)),
+      { description: schema.description }
+    );
+  }
+  if (kind === "Intersect") {
+    return Type.Intersect(
+      schema.allOf.map((s) => applyPassthrough(s)),
+      { description: schema.description }
+    );
+  }
+  if (kind === "Optional") {
+    return Type.Optional(applyPassthrough(schema.schema ?? schema.type));
+  }
+  return schema;
+}
+function convertMCPInputSchema(inputSchema) {
+  const typeboxSchema = jsonSchemaToTypeBox(inputSchema);
+  return applyPassthrough(typeboxSchema);
+}
+function convertMCPOutputSchema(outputSchema) {
+  if (!outputSchema) return void 0;
+  const typeboxSchema = jsonSchemaToTypeBox(outputSchema);
+  return applyPassthrough(typeboxSchema);
+}
+
+// src/facade/mcp-core/tool-factory.ts
+function createMCPAgentToolFactory(mcpTool, client) {
+  return () => {
+    const namespacedName = `${client.serverName}_${mcpTool.name}`;
+    const parameters = convertMCPInputSchema(mcpTool.inputSchema);
+    return {
+      name: namespacedName,
+      label: mcpTool.name,
+      description: `[${client.serverName}] ${mcpTool.description || ""}`,
+      category: "mcp",
+      parameters,
+      execute: async (toolCallId, params, signal, onUpdate) => {
+        const typedParams = params;
+        try {
+          if (!client.connected) {
+            throw new MCPError(
+              `MCP server ${client.serverName} not connected`,
+              "NOT_CONNECTED" /* NOT_CONNECTED */,
+              void 0,
+              { serverName: client.serverName, toolName: mcpTool.name }
+            );
+          }
+          if (signal?.aborted) {
+            throw new MCPError(
+              "Tool execution aborted",
+              "TIMEOUT" /* TIMEOUT */,
+              void 0,
+              { serverName: client.serverName, toolName: mcpTool.name }
+            );
+          }
+          const result = await client.callTool(mcpTool.name, typedParams);
+          return convertMCPResultToAgentResult(result, client.serverName, mcpTool.name);
+        } catch (error) {
+          if (error instanceof MCPError) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `MCP Error: ${error.message}`
+                }
+              ],
+              details: {
+                error: error.message,
+                code: error.code,
+                serverName: error.serverName,
+                toolName: error.toolName
+              },
+              isError: true
+            };
+          }
+          if (error instanceof Error && error.name === "AbortError") {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Tool execution aborted`
+                }
+              ],
+              details: {
+                error: "Aborted"
+              },
+              isError: true
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            details: {
+              error: String(error)
+            },
+            isError: true
+          };
+        }
+      }
+    };
+  };
+}
+function truncateTextForDisplay(text, maxLines = 4, maxChars = 500) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines && text.length <= maxChars) {
+    return text;
+  }
+  let truncated = lines.slice(0, maxLines).join("\n");
+  if (truncated.length > maxChars) {
+    truncated = truncated.slice(0, maxChars);
+  }
+  const remaining = lines.length - maxLines;
+  if (remaining > 0) {
+    truncated += `
+... (${remaining} more lines)`;
+  } else if (text.length > maxChars) {
+    truncated += "...";
+  }
+  return truncated;
+}
+function convertMCPResultToAgentResult(result, serverName, toolName) {
+  const content = [];
+  if (result.content && Array.isArray(result.content)) {
+    for (const item of result.content) {
+      if (item.type === "text") {
+        const truncatedText = truncateTextForDisplay(item.text);
+        content.push({ type: "text", text: truncatedText });
+      } else if (item.type === "image") {
+        content.push({
+          type: "image",
+          data: item.data,
+          mimeType: item.mimeType
+        });
+      }
+    }
+  } else if (typeof result === "string") {
+    const truncatedText = truncateTextForDisplay(result);
+    content.push({ type: "text", text: truncatedText });
+  } else {
+    const jsonStr = JSON.stringify(result, null, 2);
+    const truncatedText = truncateTextForDisplay(jsonStr);
+    content.push({ type: "text", text: truncatedText });
+  }
+  return {
+    content,
+    details: result,
+    isError: result.isError || false
+  };
+}
+async function registerMCPToolsInRegistry(registry, client, tools) {
+  let registeredCount = 0;
+  for (const tool of tools) {
+    try {
+      const factory = createMCPAgentToolFactory(tool, client);
+      registry.register(
+        {
+          name: `${client.serverName}_${tool.name}`,
+          label: tool.name,
+          category: "mcp",
+          description: `[${client.serverName}] ${tool.description || ""}`
+        },
+        factory
+      );
+      registeredCount++;
+    } catch (error) {
+      console.error(`Failed to register MCP tool ${tool.name}:`, error);
+    }
+  }
+  return registeredCount;
+}
+function createMCPToolsMap(tools, client) {
+  const toolMap = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const factory = createMCPAgentToolFactory(tool, client);
+    const namespacedName = `${client.serverName}_${tool.name}`;
+    toolMap.set(namespacedName, factory());
+  }
+  return toolMap;
+}
+function createMCPToolsRecord(tools, client) {
+  const toolRecord = {};
+  for (const tool of tools) {
+    const factory = createMCPAgentToolFactory(tool, client);
+    const namespacedName = `${client.serverName}_${tool.name}`;
+    toolRecord[namespacedName] = factory();
+  }
+  return toolRecord;
+}
+
+// src/facade/mcp-core/server.ts
+var MCPServer = class {
+  constructor(options) {
+    this.options = options;
+    this.name = options.name;
+    this.version = options.version || "1.0.0";
+    for (const tool of options.tools) {
+      const converted = this.convertTool(tool);
+      this.tools.set(converted.name, converted);
+    }
+    console.error(`[MCP Server] Initialized "${this.name}" v${this.version} with ${this.tools.size} tools`);
+  }
+  options;
+  tools = /* @__PURE__ */ new Map();
+  buffer = "";
+  isConnected = false;
+  /** Server name */
+  name;
+  /** Server version */
+  version;
+  // ========================================================================
+  // Lifecycle
+  // ========================================================================
+  /**
+   * Start the server using stdio transport.
+   *
+   * This is typically used when running the server as a subprocess
+   * that MCP clients (like Claude Desktop) spawn.
+   */
+  async startStdio() {
+    this.isConnected = true;
+    console.error(`[MCP Server] Starting stdio transport`);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      this.buffer += chunk;
+      this.processBuffer();
+    });
+    process.stdin.on("end", () => {
+      console.error(`[MCP Server] Stdin closed, shutting down`);
+      this.isConnected = false;
+      process.exit(0);
+    });
+    return new Promise(() => {
+    });
+  }
+  /**
+   * Stop the server.
+   */
+  async stop() {
+    this.isConnected = false;
+    console.error(`[MCP Server] Stopped`);
+  }
+  // ========================================================================
+  // Tool Management
+  // ========================================================================
+  /**
+   * Add a tool to the server.
+   */
+  addTool(tool) {
+    const converted = this.convertTool(tool);
+    this.tools.set(converted.name, converted);
+    console.error(`[MCP Server] Added tool: ${converted.name}`);
+  }
+  /**
+   * Remove a tool from the server.
+   */
+  removeTool(name) {
+    const result = this.tools.delete(name);
+    if (result) {
+      console.error(`[MCP Server] Removed tool: ${name}`);
+    }
+    return result;
+  }
+  /**
+   * List all available tools.
+   */
+  listTools() {
+    return Array.from(this.tools.values());
+  }
+  // ========================================================================
+  // Private Methods
+  // ========================================================================
+  convertTool(tool) {
+    const inputSchema = this.typeBoxToJsonSchema(tool.parameters);
+    return {
+      name: tool.name,
+      description: tool.description || tool.label,
+      inputSchema,
+      execute: async (args) => {
+        const result = await tool.execute(
+          `mcp_${Date.now()}`,
+          args,
+          void 0,
+          void 0
+        );
+        return result;
+      }
+    };
+  }
+  typeBoxToJsonSchema(schema) {
+    if (!schema) {
+      return { type: "object", properties: {} };
+    }
+    if (schema.type || schema.properties || schema.$schema) {
+      return schema;
+    }
+    const jsonSchema = schema.toJSONSchema?.() || schema;
+    return {
+      type: "object",
+      properties: jsonSchema.properties || {},
+      required: jsonSchema.required || []
+    };
+  }
+  processBuffer() {
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const message = JSON.parse(trimmed);
+        this.handleMessage(message);
+      } catch (error) {
+        console.error(`[MCP Server] Failed to parse message: ${trimmed}`);
+      }
+    }
+  }
+  async handleMessage(message) {
+    console.error(`[MCP Server] Received: ${message.method || `response to ${message.id}`}`);
+    try {
+      if (message.method) {
+        const response = await this.handleRequest(message);
+        this.sendResponse(message.id, response);
+      }
+    } catch (error) {
+      console.error(`[MCP Server] Error handling message:`, error);
+      if (message.id !== void 0) {
+        this.sendError(message.id, error);
+      }
+    }
+  }
+  async handleRequest(message) {
+    switch (message.method) {
+      case "initialize":
+        return this.handleInitialize(message.params);
+      case "tools/list":
+        return this.handleToolsList();
+      case "tools/call":
+        return this.handleToolsCall(message.params);
+      case "resources/list":
+        return { resources: [] };
+      case "prompts/list":
+        return { prompts: [] };
+      default:
+        throw new MCPError(
+          `Unknown method: ${message.method}`,
+          "PROTOCOL_ERROR" /* PROTOCOL_ERROR */
+        );
+    }
+  }
+  handleInitialize(params) {
+    console.error(`[MCP Server] Initialize from client: ${params?.clientInfo?.name || "unknown"}`);
+    return {
+      protocolVersion: "2024-11-05",
+      serverInfo: {
+        name: this.name,
+        version: this.version
+      },
+      capabilities: {
+        tools: {}
+      }
+    };
+  }
+  handleToolsList() {
+    const tools = Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+    return { tools };
+  }
+  async handleToolsCall(params) {
+    const { name, arguments: args } = params;
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    }
+    try {
+      console.error(`[MCP Server] Executing tool: ${name}`);
+      const result = await tool.execute(args || {});
+      if (result && typeof result === "object" && "content" in result) {
+        const agentResult = result;
+        const content = [];
+        for (const item of agentResult.content || []) {
+          if (item.type === "text") {
+            content.push({ type: "text", text: item.text });
+          } else if (item.type === "image") {
+            content.push({
+              type: "text",
+              text: `[Image: ${item.mimeType}, ${item.data.length} bytes]`
+            });
+          }
+        }
+        return {
+          content,
+          isError: agentResult.isError || false
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      console.error(`[MCP Server] Tool execution failed:`, error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  sendResponse(id, result) {
+    const response = {
+      jsonrpc: "2.0",
+      id,
+      result
+    };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+  sendError(id, error) {
+    const response = {
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: -32e3,
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+};
+function createMCPServer(options) {
+  return new MCPServer(options);
+}
+
+// src/facade/mcp-core/index.ts
+async function initializeMCP(registry, cwd = process.cwd()) {
+  const configs = loadMCPConfig(cwd);
+  if (configs.length === 0) {
+    console.log("[MCP] No servers configured");
+    return { pool: new MCPClientPool({ servers: [] }), toolCount: 0 };
+  }
+  const pool = new MCPClientPool({ servers: configs });
+  await pool.connectAll();
+  let totalTools = 0;
+  for (const client of pool.getAllClients()) {
+    try {
+      const tools = await client.listTools();
+      const count = await registerMCPToolsInRegistry(registry, client, tools);
+      totalTools += count;
+      console.log(`[MCP] Registered ${count} tools from ${client.serverName}`);
+    } catch (error) {
+      console.error(`[MCP] Failed to register tools from ${client.serverName}:`, error);
+    }
+  }
+  return { pool, toolCount: totalTools };
+}
+export {
+  EXAMPLE_CONFIG,
+  MCPClient,
+  MCPClientPool,
+  MCPError,
+  MCPErrorCode,
+  MCPServer,
+  applyPassthrough,
+  convertMCPInputSchema,
+  convertMCPOutputSchema,
+  createConfigError,
+  createConnectionError,
+  createDefaultConfig,
+  createInvalidParametersError,
+  createMCPAgentToolFactory,
+  createMCPServer,
+  createMCPToolsMap,
+  createMCPToolsRecord,
+  createNotConnectedError,
+  createSchemaConversionError,
+  createServerError,
+  createTimeoutError,
+  createToolNotFoundError,
+  ensureProjectConfigDir,
+  ensureUserConfigDir,
+  getProjectConfigPath,
+  getUserConfigPath,
+  initializeMCP,
+  isMCPError,
+  isSessionError,
+  jsonSchemaToTypeBox,
+  loadMCPConfig,
+  registerMCPToolsInRegistry,
+  saveConfig,
+  saveProjectConfig,
+  saveUserConfig
+};