indusagi 0.12.34 → 0.13.0

package/dist/mcp.js

@@ -1,12 +1,21 @@
-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";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import {
+  ListRootsRequestSchema,
+  ElicitRequestSchema,
+  CreateMessageRequestSchema,
+  PingRequestSchema,
+  ToolListChangedNotificationSchema,
+  ResourceListChangedNotificationSchema,
+  ResourceUpdatedNotificationSchema,
+  PromptListChangedNotificationSchema,
+  ProgressNotificationSchema,
+  LoggingMessageNotificationSchema,
+  CancelledNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
 
 // src/facade/mcp-core/errors.ts
 var MCPErrorCode = /* @__PURE__ */ ((MCPErrorCode2) => {
@@ -114,6 +123,7 @@ function createSchemaConversionError(toolName, details, serverName) {
 
 // src/facade/mcp-core/client.ts
 var DEFAULT_REQUEST_TIMEOUT = 6e4;
+var DEFAULT_CONNECT_TIMEOUT = 3e4;
 var MCPClient = class {
   constructor(options) {
     this.options = options;
@@ -126,10 +136,8 @@ var MCPClient = class {
     this._roots = options.roots ?? [];
   }
   options;
-  process;
-  buffer = "";
-  messageId = 0;
-  pendingRequests = /* @__PURE__ */ new Map();
+  client;
+  transport;
   isConnected = false;
   connectionPromise = null;
   serverCapabilities;
@@ -137,6 +145,19 @@ var MCPClient = class {
   enableServerLogs;
   enableProgressTracking;
   _roots;
+  // --- Host-overridable handlers (Core of #13) --------------------------------
+  // Server-initiated REQUESTS are answered by request handlers registered on the
+  // SDK client; the handlers delegate to these host-supplied callbacks when set,
+  // and fall back to sensible defaults otherwise.
+  elicitationHandler;
+  samplingHandler;
+  // Server-initiated NOTIFICATIONS are dispatched to these (so the host can, for
+  // example, re-list tools when a `tools/list_changed` arrives).
+  resourceUpdatedHandler;
+  resourceListChangedHandler;
+  toolListChangedHandler;
+  promptListChangedHandler;
+  progressHandler;
   /** Server name */
   serverName;
   /** Server config */
@@ -163,106 +184,169 @@ var MCPClient = class {
     }
   }
   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"
+    const transport = this.createTransport(this.config);
+    this.transport = transport;
+    const client = new Client(
+      { name: "indusagi-coding-agent", version: "0.13.0" },
+      {
+        capabilities: {
+          roots: { listChanged: true },
+          elicitation: {},
+          sampling: {}
+        }
       }
-    });
-    this.serverCapabilities = initResult.capabilities;
+    );
+    this.client = client;
+    this.registerServerHandlers(client);
+    const prevOnClose = transport.onclose;
+    transport.onclose = () => {
+      this.isConnected = false;
+      this.log("debug", "Transport closed");
+      prevOnClose?.();
+    };
+    await client.connect(transport, { timeout: DEFAULT_CONNECT_TIMEOUT });
+    this.serverCapabilities = client.getServerCapabilities();
     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 },
+  /**
+   * Build the SDK transport for the configured server.
+   *
+   *  - stdio: `StdioClientTransport` (inherits the parent env, merges config.env).
+   *  - http:  `StreamableHTTPClientTransport` (POST + server-push SSE channel,
+   *           reconnect + session-expiry handled by the SDK), unless the config
+   *           asks for the legacy `SSEClientTransport`.
+   */
+  createTransport(config) {
+    if ("command" in config) {
+      return new StdioClientTransport({
+        command: config.command,
+        args: config.args ?? [],
+        env: { ...sanitizeEnv(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}`);
-        }
+        stderr: "pipe"
       });
-      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 }
+    }
+    if ("url" in config) {
+      const requestInit = config.headers ? { headers: config.headers } : void 0;
+      if (config.transport === "sse") {
+        return new SSEClientTransport(config.url, { requestInit });
+      }
+      return new StreamableHTTPClientTransport(config.url, { requestInit });
+    }
+    throw new MCPError(
+      "Server configuration must include either a command or a url",
+      "CONFIG_ERROR" /* CONFIG_ERROR */,
+      void 0,
+      { serverName: this.serverName }
+    );
+  }
+  /**
+   * Register handlers for server-initiated REQUESTS and NOTIFICATIONS.
+   *
+   * REQUESTS (have both `.method` AND `.id`) must be ANSWERED with a JSON-RPC
+   * RESPONSE carrying the matching id — the SDK does this automatically for the
+   * value a request handler returns (or rejects). The previous hand-rolled
+   * transport routed these into the notification path, so they were never
+   * answered (bug #13).
+   *
+   * Defaults:
+   *   - ping              → {}
+   *   - roots/list        → the configured roots
+   *   - elicitation/create→ decline ({action:"cancel"}) unless a host handler is set
+   *   - sampling          → reject "Method not found" unless a host handler is set
+   */
+  registerServerHandlers(client) {
+    client.setRequestHandler(PingRequestSchema, async () => ({}));
+    client.setRequestHandler(ListRootsRequestSchema, async () => ({
+      roots: this._roots.map((r) => ({ uri: r.uri, name: r.name }))
+    }));
+    client.setRequestHandler(ElicitRequestSchema, async (request) => {
+      if (!this.elicitationHandler) {
+        return { action: "cancel" };
+      }
+      const params = request.params;
+      const elicitRequest = {
+        message: params.message,
+        requestedSchema: params.requestedSchema ?? {}
+      };
+      const result = await this.elicitationHandler(elicitRequest);
+      return mapToSdkElicitResult(result);
+    });
+    client.setRequestHandler(CreateMessageRequestSchema, async (request) => {
+      if (!this.samplingHandler) {
+        throw new MCPError(
+          "Method not found: sampling/createMessage",
+          "SERVER_ERROR" /* SERVER_ERROR */,
+          { method: "sampling/createMessage" },
+          { serverName: this.serverName }
         );
-        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);
+      }
+      return await this.samplingHandler(request.params);
+    });
+    client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
+      this.log("debug", "Tool list changed");
+      this.toolListChangedHandler?.();
+    });
+    client.setNotificationHandler(ResourceListChangedNotificationSchema, () => {
+      this.log("debug", "Resource list changed");
+      this.resourceListChangedHandler?.();
+    });
+    client.setNotificationHandler(ResourceUpdatedNotificationSchema, (n) => {
+      const uri = n.params?.uri;
+      this.log("debug", `Resource updated: ${uri}`);
+      if (uri) this.resourceUpdatedHandler?.({ uri });
+    });
+    client.setNotificationHandler(PromptListChangedNotificationSchema, () => {
+      this.log("debug", "Prompt list changed");
+      this.promptListChangedHandler?.();
+    });
+    client.setNotificationHandler(ProgressNotificationSchema, (n) => {
+      const params = n.params;
+      this.log("debug", `Progress: ${JSON.stringify(params)}`);
+      if (this.progressHandler && params) {
+        const notification = {
+          progressToken: params.progressToken,
+          progress: params.progress,
+          total: params.total,
+          message: params.message
+        };
+        this.progressHandler(notification);
+      }
+    });
+    client.setNotificationHandler(LoggingMessageNotificationSchema, (n) => {
+      if (this.enableServerLogs && n.params) {
+        const { level, ...rest } = n.params;
+        this.log(level || "info", "[SERVER]", rest);
+      }
+    });
+    client.setNotificationHandler(CancelledNotificationSchema, (n) => {
+      this.log("debug", `Request cancelled: ${JSON.stringify(n.params)}`);
     });
   }
   /**
    * Disconnect from the MCP server.
+   *
+   * The SDK's `client.close()` closes the transport and rejects any pending
+   * requests — a clean teardown for both stdio (graceful subprocess shutdown)
+   * and HTTP (close the push channel / end the session).
    */
   async disconnect() {
-    if ("url" in this.config) {
+    if (!this.client) {
+      this.log("debug", "Disconnect called but not connected");
       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");
+      await this.client.close();
     } catch (error) {
       this.log("error", `Error during disconnect: ${error}`);
-      throw error;
+    } finally {
+      this.client = void 0;
+      this.transport = void 0;
+      this.isConnected = false;
+      this.log("debug", "Successfully disconnected");
     }
   }
   /**
@@ -279,7 +363,9 @@ var MCPClient = class {
    */
   async listTools() {
     this.ensureConnected();
-    const result = await this.sendRequest("tools/list", {});
+    const result = await this.client.listTools(void 0, {
+      timeout: this.timeout
+    });
     return result.tools;
   }
   /**
@@ -289,15 +375,16 @@ var MCPClient = class {
     this.ensureConnected();
     this.log("debug", `Calling tool: ${name}`);
     try {
-      const result = await this.sendRequest("tools/call", {
-        name,
-        arguments: args
-      });
+      const result = await this.client.callTool(
+        { name, arguments: args },
+        void 0,
+        { timeout: this.timeout }
+      );
       this.log("debug", `Tool ${name} executed successfully`);
       return result;
     } catch (error) {
       this.log("error", `Tool ${name} failed: ${error}`);
-      throw error;
+      throw this.wrapError(error);
     }
   }
   // ========================================================================
@@ -311,7 +398,9 @@ var MCPClient = class {
     if (!this.serverCapabilities?.resources) {
       return [];
     }
-    const result = await this.sendRequest("resources/list", {});
+    const result = await this.client.listResources(void 0, {
+      timeout: this.timeout
+    });
     return result.resources;
   }
   /**
@@ -319,21 +408,21 @@ var MCPClient = class {
    */
   async readResource(uri) {
     this.ensureConnected();
-    return await this.sendRequest("resources/read", { uri });
+    return await this.client.readResource({ uri }, { timeout: this.timeout });
   }
   /**
    * Subscribe to resource updates.
    */
   async subscribeResource(uri) {
     this.ensureConnected();
-    await this.sendRequest("resources/subscribe", { uri });
+    await this.client.subscribeResource({ uri }, { timeout: this.timeout });
   }
   /**
    * Unsubscribe from resource updates.
    */
   async unsubscribeResource(uri) {
     this.ensureConnected();
-    await this.sendRequest("resources/unsubscribe", { uri });
+    await this.client.unsubscribeResource({ uri }, { timeout: this.timeout });
   }
   // ========================================================================
   // Prompt Operations
@@ -346,7 +435,9 @@ var MCPClient = class {
     if (!this.serverCapabilities?.prompts) {
       return [];
     }
-    const result = await this.sendRequest("prompts/list", {});
+    const result = await this.client.listPrompts(void 0, {
+      timeout: this.timeout
+    });
     return result.prompts;
   }
   /**
@@ -354,7 +445,10 @@ var MCPClient = class {
    */
   async getPrompt(name, args) {
     this.ensureConnected();
-    return await this.sendRequest("prompts/get", { name, arguments: args });
+    return await this.client.getPrompt(
+      { name, arguments: args },
+      { timeout: this.timeout }
+    );
   }
   // ========================================================================
   // Roots Operations
@@ -371,49 +465,79 @@ var MCPClient = class {
   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", {});
+    if (this.isConnected && this.client) {
+      try {
+        await this.client.sendRootsListChanged();
+      } catch (error) {
+        this.log("debug", `Failed to send roots/list_changed: ${error}`);
+      }
     }
   }
   // ========================================================================
   // Handler Registration
+  //
+  // Setters STORE the host handler (and, for notifications, the SDK handler
+  // registered in `registerServerHandlers` delegates to the stored callback).
+  // This is the host-overridable layer at the core of bug #13.
   // ========================================================================
   /**
    * Set a handler for resource updated notifications.
    */
   setResourceUpdatedHandler(handler) {
+    this.resourceUpdatedHandler = handler;
     this.log("debug", "Resource updated handler registered");
   }
   /**
    * Set a handler for resource list changed notifications.
    */
   setResourceListChangedHandler(handler) {
+    this.resourceListChangedHandler = handler;
     this.log("debug", "Resource list changed handler registered");
   }
+  /**
+   * Set a handler for tool list changed notifications.
+   */
+  setToolListChangedHandler(handler) {
+    this.toolListChangedHandler = handler;
+    this.log("debug", "Tool list changed handler registered");
+  }
   /**
    * Set a handler for prompt list changed notifications.
    */
   setPromptListChangedHandler(handler) {
+    this.promptListChangedHandler = handler;
     this.log("debug", "Prompt list changed handler registered");
   }
   /**
-   * Set a handler for elicitation requests.
+   * Set a handler for elicitation requests. When set, the server's
+   * `elicitation/create` REQUEST is answered with the host's decision; when
+   * unset the request is declined ({action:"cancel"}).
    */
   setElicitationHandler(handler) {
+    this.elicitationHandler = handler;
     this.log("debug", "Elicitation handler registered");
   }
+  /**
+   * Set a handler for sampling (`sampling/createMessage`) requests. When set,
+   * the server request is answered with the host's result; when unset the
+   * request is rejected with "Method not found".
+   */
+  setSamplingHandler(handler) {
+    this.samplingHandler = handler;
+    this.log("debug", "Sampling handler registered");
+  }
   /**
    * Set a handler for progress notifications.
    */
   setProgressHandler(handler) {
+    this.progressHandler = handler;
     this.log("debug", "Progress handler registered");
   }
   // ========================================================================
   // Private Methods
   // ========================================================================
   ensureConnected() {
-    const isHttpTransport = "url" in this.config;
-    if (!this.isConnected || !isHttpTransport && !this.process) {
+    if (!this.isConnected || !this.client) {
       throw new MCPError(
         "Not connected to MCP server",
         "NOT_CONNECTED" /* NOT_CONNECTED */,
@@ -422,258 +546,24 @@ var MCPClient = class {
       );
     }
   }
-  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
+  /**
+   * Normalize an SDK/transport error into an MCPError. Session-expiry style
+   * failures (404 session / -32001) are surfaced as SESSION_ERROR so callers
+   * (the pool) can decide to reconnect; the SDK's StreamableHTTP transport
+   * already attempts a bounded reconnect re-using the session id before this.
+   */
+  wrapError(error) {
+    if (error instanceof MCPError) return error;
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error.code;
+    if (code === -32001 || /\b404\b|session/i.test(message)) {
+      return new MCPError(message, "SESSION_ERROR" /* SESSION_ERROR */, { code }, {
+        serverName: this.serverName
       });
-      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;
     }
+    return new MCPError(message, "SERVER_ERROR" /* SERVER_ERROR */, { code }, {
+      serverName: this.serverName
+    });
   }
   log(level, message, details) {
     const msg = `[${this.serverName}] ${message}`;
@@ -705,6 +595,22 @@ var MCPClient = class {
     }
   }
 };
+function mapToSdkElicitResult(result) {
+  if (result.action === "accept") {
+    return {
+      action: "accept",
+      content: result.content ?? {}
+    };
+  }
+  return { action: result.action };
+}
+function sanitizeEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
 
 // src/facade/mcp-core/client-pool.ts
 var MCPClientPool = class {
@@ -906,14 +812,14 @@ var MCPClientPool = class {
 };
 
 // src/facade/mcp-core/config.ts
-import { existsSync, readFileSync, mkdirSync } from "fs";
+import { existsSync, readFileSync, mkdirSync, statSync, writeFileSync } 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);
+      const stats = statSync(configPathOrCwd);
       if (stats.isFile()) {
         const fileConfigs = parseConfigFile(configPathOrCwd);
         configs.push(...fileConfigs);
@@ -991,7 +897,8 @@ function parseConfigFile(path) {
         name: server.name,
         config: {
           url: new URL(server.url),
-          headers: server.headers
+          headers: server.headers,
+          ...server.transport ? { transport: server.transport } : {}
         },
         timeout: server.timeout
       };
@@ -1041,7 +948,7 @@ function saveConfig(path, config) {
     mkdirSync(dir, { recursive: true });
   }
   const content = JSON.stringify(config, null, 2);
-  __require("fs").writeFileSync(path, content, "utf-8");
+  writeFileSync(path, content, "utf-8");
 }
 function saveUserConfig(config) {
   saveConfig(getUserConfigPath(), config);