indusagi 0.13.7 → 0.13.8

package/dist/sarvam-mcp.js

@@ -0,0 +1,960 @@
+// src/facade/mcp-core/client.ts
+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 {
+  UnauthorizedError
+} from "@modelcontextprotocol/sdk/client/auth.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 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 createServerError(message, serverName, details) {
+  return new MCPError(message, "SERVER_ERROR" /* SERVER_ERROR */, 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;
+    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;
+  client;
+  transport;
+  isConnected = false;
+  connectionPromise = null;
+  serverCapabilities;
+  logHandler;
+  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 */
+  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() {
+    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.client = client;
+    this.registerServerHandlers(client);
+    const prevOnClose = transport.onclose;
+    transport.onclose = () => {
+      this.isConnected = false;
+      this.log("debug", "Transport closed");
+      prevOnClose?.();
+    };
+    try {
+      await client.connect(transport, { timeout: DEFAULT_CONNECT_TIMEOUT });
+    } catch (err) {
+      const recovered = await this.tryFinishOAuthAndReconnect(client, transport, err);
+      if (!recovered) {
+        throw this.wrapConnectError(err);
+      }
+    }
+    this.serverCapabilities = client.getServerCapabilities();
+    this.isConnected = true;
+    this.log("info", `Connected to MCP server`);
+  }
+  /**
+   * If `err` is an OAuth challenge and we have a provider + finishAuth-capable
+   * transport, wait for the browser code, exchange tokens, then reconnect on a
+   * **fresh** transport (the first transport is already `start()`ed and cannot
+   * be reused — see StreamableHTTPClientTransport.start).
+   *
+   * Matches the official SDK CLI example (`simpleOAuthClient`):
+   *   finishAuth(code) → new StreamableHTTPClientTransport → client.connect again
+   *
+   * Client.connect already called `close()` on init failure, so the Client is
+   * free to attach a new transport.
+   */
+  async tryFinishOAuthAndReconnect(client, transport, err) {
+    if (!isAuthRequiredError(err)) return false;
+    const provider = this.options.authProvider;
+    if (!provider) return false;
+    const finishAuth = transport.finishAuth;
+    const waitForCode = provider.waitForAuthorizationCode;
+    if (typeof finishAuth !== "function" || typeof waitForCode !== "function") {
+      this.log(
+        "error",
+        "MCP server requires authentication but OAuth finish path is incomplete (need authProvider.waitForAuthorizationCode + transport.finishAuth)."
+      );
+      return false;
+    }
+    this.log("info", "MCP server requires OAuth \u2014 complete login in the browser\u2026");
+    try {
+      const code = await waitForCode.call(provider);
+      this.log("info", "OAuth authorization code received \u2014 exchanging tokens\u2026");
+      await finishAuth.call(transport, code);
+      try {
+        await transport.close?.();
+      } catch {
+      }
+      const fresh = this.createTransport(this.config);
+      this.transport = fresh;
+      const prevOnClose = fresh.onclose;
+      fresh.onclose = () => {
+        this.isConnected = false;
+        this.log("debug", "Transport closed");
+        prevOnClose?.();
+      };
+      this.log("info", "Reconnecting MCP session with OAuth tokens\u2026");
+      await client.connect(fresh, { timeout: DEFAULT_CONNECT_TIMEOUT });
+      return true;
+    } catch (oauthErr) {
+      this.log(
+        "error",
+        `OAuth finish failed: ${oauthErr instanceof Error ? oauthErr.message : String(oauthErr)}`
+      );
+      throw this.wrapConnectError(oauthErr);
+    }
+  }
+  /** Turn raw SDK / network errors into a clearer MCPError for callers. */
+  wrapConnectError(err) {
+    if (err instanceof MCPError) return err;
+    const message = err instanceof Error ? err.message : String(err);
+    if (isAuthRequiredError(err)) {
+      return new MCPError(
+        `Authentication required for MCP server "${this.serverName}". Pass auth: "auto" (default) to run the OAuth browser flow, or set a Bearer token via headers. Original: ${message}`,
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        err,
+        { serverName: this.serverName, cause: err instanceof Error ? err : void 0 }
+      );
+    }
+    return new MCPError(
+      `Failed to connect to MCP server "${this.serverName}": ${message}`,
+      "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+      err,
+      { serverName: this.serverName, cause: err instanceof Error ? err : void 0 }
+    );
+  }
+  /**
+   * 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,
+        stderr: "pipe"
+      });
+    }
+    if ("url" in config) {
+      const requestInit = config.headers ? { headers: config.headers } : void 0;
+      if (config.transport === "sse") {
+        return new SSEClientTransport(config.url, {
+          requestInit,
+          ...this.options.authProvider ? { authProvider: this.options.authProvider } : {}
+        });
+      }
+      return new StreamableHTTPClientTransport(config.url, {
+        requestInit,
+        ...this.options.authProvider ? { authProvider: this.options.authProvider } : {}
+      });
+    }
+    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 }
+        );
+      }
+      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 (!this.client) {
+      this.log("debug", "Disconnect called but not connected");
+      this.isConnected = false;
+      return;
+    }
+    this.log("debug", "Disconnecting from MCP server");
+    try {
+      await this.client.close();
+    } catch (error) {
+      this.log("error", `Error during disconnect: ${error}`);
+    } finally {
+      this.client = void 0;
+      this.transport = void 0;
+      this.isConnected = false;
+      this.log("debug", "Successfully disconnected");
+    }
+  }
+  /**
+   * 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.client.listTools(void 0, {
+      timeout: this.timeout
+    });
+    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.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 this.wrapError(error);
+    }
+  }
+  // ========================================================================
+  // Resource Operations
+  // ========================================================================
+  /**
+   * List all resources available from the server.
+   */
+  async listResources() {
+    this.ensureConnected();
+    if (!this.serverCapabilities?.resources) {
+      return [];
+    }
+    const result = await this.client.listResources(void 0, {
+      timeout: this.timeout
+    });
+    return result.resources;
+  }
+  /**
+   * Read a resource from the server.
+   */
+  async readResource(uri) {
+    this.ensureConnected();
+    return await this.client.readResource({ uri }, { timeout: this.timeout });
+  }
+  /**
+   * Subscribe to resource updates.
+   */
+  async subscribeResource(uri) {
+    this.ensureConnected();
+    await this.client.subscribeResource({ uri }, { timeout: this.timeout });
+  }
+  /**
+   * Unsubscribe from resource updates.
+   */
+  async unsubscribeResource(uri) {
+    this.ensureConnected();
+    await this.client.unsubscribeResource({ uri }, { timeout: this.timeout });
+  }
+  // ========================================================================
+  // Prompt Operations
+  // ========================================================================
+  /**
+   * List all prompts available from the server.
+   */
+  async listPrompts() {
+    this.ensureConnected();
+    if (!this.serverCapabilities?.prompts) {
+      return [];
+    }
+    const result = await this.client.listPrompts(void 0, {
+      timeout: this.timeout
+    });
+    return result.prompts;
+  }
+  /**
+   * Get a prompt from the server.
+   */
+  async getPrompt(name, args) {
+    this.ensureConnected();
+    return await this.client.getPrompt(
+      { name, arguments: args },
+      { timeout: this.timeout }
+    );
+  }
+  // ========================================================================
+  // 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 && 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. 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() {
+    if (!this.isConnected || !this.client) {
+      throw new MCPError(
+        "Not connected to MCP server",
+        "NOT_CONNECTED" /* NOT_CONNECTED */,
+        void 0,
+        { serverName: this.serverName }
+      );
+    }
+  }
+  /**
+   * 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
+      });
+    }
+    return new MCPError(message, "SERVER_ERROR" /* SERVER_ERROR */, { code }, {
+      serverName: this.serverName
+    });
+  }
+  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);
+          }
+        }
+      }
+    }
+  }
+};
+function mapToSdkElicitResult(result) {
+  if (result.action === "accept") {
+    return {
+      action: "accept",
+      content: result.content ?? {}
+    };
+  }
+  return { action: result.action };
+}
+function isAuthRequiredError(err) {
+  if (err == null) return false;
+  if (err instanceof UnauthorizedError) return true;
+  if (typeof err === "object") {
+    const code = err.code;
+    if (code === 401 || code === "401") return true;
+  }
+  if (err instanceof Error) {
+    const msg = err.message;
+    if (/unauthorized/i.test(msg)) return true;
+    if (/authentication required/i.test(msg)) return true;
+    if (/auth required/i.test(msg)) return true;
+    if (err.name === "UnauthorizedError") return true;
+  }
+  return false;
+}
+function sanitizeEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+
+// src/capabilities/kernel/spec.ts
+function coerceInput(raw) {
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+      }
+    }
+    return raw;
+  }
+  if (raw === null || raw === void 0) {
+    return {};
+  }
+  return raw;
+}
+function describeThrow(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function projectOutcome(id, result) {
+  const blocks = result.content;
+  let output;
+  if (blocks.length === 1) {
+    const only = blocks[0];
+    output = only.kind === "text" ? only.text : only.value;
+  } else {
+    output = blocks;
+  }
+  return { id, output, isError: result.isError === true };
+}
+function defineTool(spec) {
+  return {
+    name: spec.name,
+    // Facade `AgentTool` surface: top-level schema fields + an `execute` adapter
+    // so the tool is usable by the high-level `Agent` as well as the kernel.
+    label: spec.name,
+    description: spec.description,
+    parameters: spec.parameters,
+    async execute(_toolCallId, params, signal) {
+      const ctx = {
+        cwd: process.cwd(),
+        signal: signal ?? new AbortController().signal
+      };
+      try {
+        const result = await spec.run(coerceInput(params), ctx);
+        return {
+          content: result.content.map(
+            (block) => block.kind === "text" ? { type: "text", text: block.text } : { type: "text", text: JSON.stringify(block.value) }
+          ),
+          details: {},
+          isError: result.isError ?? false
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `${spec.name} did not finish: ${describeThrow(err)}` }],
+          details: {},
+          isError: true
+        };
+      }
+    },
+    descriptor() {
+      return {
+        name: spec.name,
+        description: spec.description,
+        parameters: spec.parameters
+      };
+    },
+    async invoke(call, ctx) {
+      if (ctx.signal.aborted) {
+        return {
+          id: call.id,
+          output: `Cancelled before ${spec.name} could begin.`,
+          isError: true
+        };
+      }
+      try {
+        const input = coerceInput(call.input);
+        const result = await spec.run(input, ctx);
+        return projectOutcome(call.id, result);
+      } catch (err) {
+        return {
+          id: call.id,
+          output: `${spec.name} did not finish: ${describeThrow(err)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+
+// src/facade/mcp-core/toolbox-bridge.ts
+var NOOP_FS_NOT_SUPPORTED = "not supported in MCP-wrapped tools";
+var noopFs = {
+  readFile: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  },
+  writeFile: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  },
+  stat: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  },
+  readdir: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  },
+  mkdir: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  },
+  rm: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  },
+  exists: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  }
+};
+var noopShell = {
+  exec: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  },
+  spawn: () => {
+    throw new MCPError(NOOP_FS_NOT_SUPPORTED, "CONFIG_ERROR");
+  }
+};
+function makeToolContext(signal) {
+  return {
+    cwd: process.cwd(),
+    fs: noopFs,
+    shell: noopShell,
+    signal,
+    budget: { kind: "tail", maxBytes: 5e4 }
+  };
+}
+function describeThrow2(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function projectMcpResult(result, logger) {
+  const blocks = [];
+  if (result.content && result.content.length > 0) {
+    for (const block of result.content) {
+      if (block.type === "text") {
+        blocks.push({ kind: "text", text: block.text });
+      } else if (block.type === "image") {
+        const len = typeof block.data === "string" ? block.data.length : 0;
+        blocks.push({ kind: "text", text: `[image ${block.mimeType}, ${len} chars base64]` });
+        logger?.debug(`mcp bridge: image block collapsed to text mention (${block.mimeType})`);
+      } else if (block.type === "resource") {
+        blocks.push({ kind: "text", text: `[resource ${block.resource.uri}]` });
+      } else {
+        blocks.push({ kind: "text", text: "[unknown content block]" });
+      }
+    }
+  }
+  if (result.structuredContent !== void 0) {
+    blocks.push({ kind: "json", value: result.structuredContent });
+  }
+  const content = blocks.length > 0 ? blocks : [{ kind: "text", text: "(no content)" }];
+  return {
+    content,
+    ...result.isError === true ? { isError: true } : {}
+  };
+}
+function makeRunner(client, remoteName, logger) {
+  return async (input, ctx) => {
+    if (ctx.signal.aborted) {
+      return {
+        content: [{ kind: "text", text: "Cancelled before tool could start." }],
+        isError: true
+      };
+    }
+    try {
+      const args = input ?? {};
+      const result = await client.callTool(remoteName, args);
+      return projectMcpResult(result, logger);
+    } catch (err) {
+      const wrapped = err instanceof MCPError ? err : createServerError(describeThrow2(err), client.serverName);
+      logger?.error(`mcp bridge: tool "${remoteName}" failed: ${wrapped.message}`, wrapped);
+      return {
+        content: [{ kind: "text", text: `MCP tool failed: ${wrapped.message}` }],
+        isError: true
+      };
+    }
+  };
+}
+async function mcpClientToToolBox(client, options = {}) {
+  const prefix = options.namePrefix ?? "mcp";
+  const logger = options.logger;
+  const tools = await client.listTools();
+  const filtered = typeof options.filter === "function" ? tools.filter((t) => options.filter(t)) : tools;
+  const byName = /* @__PURE__ */ new Map();
+  for (const tool of filtered) {
+    const remoteName = tool.name;
+    const prefixed = `${prefix}__${remoteName}`;
+    const description = tool.description && tool.description.length > 0 ? tool.description : `<tool "${remoteName}" from MCP server "${client.serverName}">`;
+    const parameters = tool.inputSchema;
+    const def = defineTool({
+      name: prefixed,
+      description,
+      parameters,
+      run: makeRunner(client, remoteName, logger)
+    });
+    byName.set(prefixed, def);
+  }
+  const runner = {
+    async run(call, signal) {
+      const def = byName.get(call.name);
+      if (!def) {
+        return {
+          id: call.id,
+          output: `No tool "${call.name}" on MCP server "${client.serverName}".`,
+          isError: true
+        };
+      }
+      return def.invoke(call, makeToolContext(signal));
+    }
+  };
+  return {
+    descriptors() {
+      return Array.from(byName.values()).map((d) => d.descriptor());
+    },
+    runner
+  };
+}
+
+// src/connectors-sarvam/connect.ts
+function resolveHome(p) {
+  if (!p.startsWith("~")) return p;
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return home.length > 0 ? p.replace(/^~/, home) : p;
+}
+async function connectSarvamMcp(options) {
+  const id = options.id ?? "sarvam";
+  const apiKey = (options.apiKey?.trim() || process.env.SARVAM_API_KEY?.trim() || "").trim();
+  if (!apiKey) {
+    throw new Error(
+      "connectSarvamMcp: SARVAM_API_KEY missing (pass apiKey or set the env var)."
+    );
+  }
+  const baseUrl = options.baseUrl ?? process.env.SARVAM_API_BASE_URL ?? "https://api.sarvam.ai";
+  const basePath = resolveHome(options.basePath ?? process.env.SARVAM_MCP_BASE_PATH ?? "~/Desktop");
+  const command = options.command ?? "uvx";
+  const args = [...options.args ?? ["sarvam-mcp"]];
+  const env = {
+    ...options.env ? { ...options.env } : {},
+    SARVAM_API_KEY: apiKey,
+    SARVAM_API_BASE_URL: baseUrl,
+    SARVAM_MCP_BASE_PATH: basePath
+  };
+  const client = new MCPClient({
+    name: id,
+    config: { command, args, env },
+    timeout: options.timeoutMs ?? 6e4
+  });
+  await client.connect();
+  const toolBox = await mcpClientToToolBox(client, {
+    namePrefix: id,
+    logger: options.logger
+  });
+  const tools = await client.listTools();
+  const prefixed = tools.map((t) => `${id}__${t.name}`);
+  let closed = false;
+  return {
+    id,
+    toolBox,
+    toolNames: prefixed,
+    client,
+    async close() {
+      if (closed) return;
+      closed = true;
+      try {
+        await client.disconnect();
+      } catch (e) {
+        options.logger?.error(`sarvam close failed: ${e.message}`, e);
+      }
+    }
+  };
+}
+
+// src/connectors-sarvam/toolbox.ts
+async function sarvamToolBoxFromClient(client, options) {
+  return mcpClientToToolBox(client, {
+    ...options,
+    namePrefix: options?.id ?? "sarvam"
+  });
+}
+export {
+  connectSarvamMcp,
+  sarvamToolBoxFromClient
+};