@yourgpt/copilot-sdk 2.0.1 → 2.0.2-beta.2

package/dist/mcp/index.cjs

@@ -0,0 +1,670 @@
+'use strict';
+
+var chunkJO4BHPAD_cjs = require('../chunk-JO4BHPAD.cjs');
+var chunk7K7HZMP4_cjs = require('../chunk-7K7HZMP4.cjs');
+var chunkJEQ2X3Z6_cjs = require('../chunk-JEQ2X3Z6.cjs');
+
+// src/mcp/client/MCPClientManager.ts
+var MCPClientManager = class {
+  constructor(configs, events) {
+    this.clients = /* @__PURE__ */ new Map();
+    this.configs = configs;
+    this.events = events ?? {};
+  }
+  /**
+   * Get the current aggregated state
+   */
+  getState() {
+    const clientStates = {};
+    const allTools = [];
+    let allConnected = true;
+    let anyConnecting = false;
+    let anyError = false;
+    for (const config of this.configs) {
+      if (config.enabled === false) continue;
+      const client = this.clients.get(config.name);
+      if (client) {
+        const state = client.getState();
+        clientStates[config.name] = state;
+        allTools.push(...state.tools);
+        if (state.connectionState !== "connected") {
+          allConnected = false;
+        }
+        if (state.connectionState === "connecting") {
+          anyConnecting = true;
+        }
+        if (state.connectionState === "error") {
+          anyError = true;
+        }
+      } else {
+        allConnected = false;
+      }
+    }
+    return {
+      clients: clientStates,
+      allTools,
+      allConnected,
+      anyConnecting,
+      anyError,
+      totalToolCount: allTools.length
+    };
+  }
+  /**
+   * Connect all enabled clients
+   */
+  async connectAll() {
+    const connectPromises = [];
+    for (const config of this.configs) {
+      if (config.enabled === false) continue;
+      const promise = this.connect(config.name).catch((error) => {
+        console.error(`Failed to connect ${config.name}:`, error);
+        this.events.onError?.(
+          config.name,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      });
+      connectPromises.push(promise);
+    }
+    await Promise.all(connectPromises);
+    const state = this.getState();
+    if (state.allConnected) {
+      this.events.onAllConnected?.();
+    }
+  }
+  /**
+   * Connect a specific client
+   */
+  async connect(name) {
+    const config = this.configs.find((c) => c.name === name);
+    if (!config) {
+      throw new Error(`Client "${name}" not found in configuration`);
+    }
+    if (config.enabled === false) {
+      throw new Error(`Client "${name}" is disabled`);
+    }
+    let client = this.clients.get(name);
+    if (!client) {
+      client = this.createClient(config);
+      this.clients.set(name, client);
+    }
+    await client.connect();
+  }
+  /**
+   * Disconnect all clients
+   */
+  async disconnectAll() {
+    const disconnectPromises = [];
+    for (const client of this.clients.values()) {
+      disconnectPromises.push(
+        client.disconnect().catch((error) => {
+          console.error("Error disconnecting client:", error);
+        })
+      );
+    }
+    await Promise.all(disconnectPromises);
+    this.events.onAllDisconnected?.();
+  }
+  /**
+   * Disconnect a specific client
+   */
+  async disconnect(name) {
+    const client = this.clients.get(name);
+    if (client) {
+      await client.disconnect();
+    }
+  }
+  /**
+   * Get a specific client
+   */
+  getClient(name) {
+    return this.clients.get(name);
+  }
+  /**
+   * Get all connected clients
+   */
+  getConnectedClients() {
+    return Array.from(this.clients.values()).filter((c) => c.isConnected());
+  }
+  /**
+   * Get all tool definitions from all connected clients
+   */
+  getAllToolDefinitions(options) {
+    const tools = [];
+    for (const client of this.getConnectedClients()) {
+      const clientTools = client.toToolDefinitions({
+        prefixToolNames: options?.prefixToolNames ?? true
+      });
+      tools.push(...clientTools);
+    }
+    return tools;
+  }
+  /**
+   * Get tool definitions from a specific client
+   */
+  getToolDefinitions(name, options) {
+    const client = this.clients.get(name);
+    if (!client || !client.isConnected()) {
+      return [];
+    }
+    return client.toToolDefinitions({
+      prefixToolNames: options?.prefixToolNames ?? true
+    });
+  }
+  /**
+   * Call a tool on a specific client
+   */
+  async callTool(clientName, toolName, args) {
+    const client = this.clients.get(clientName);
+    if (!client) {
+      throw new Error(`Client "${clientName}" not found`);
+    }
+    if (!client.isConnected()) {
+      throw new Error(`Client "${clientName}" is not connected`);
+    }
+    return client.callTool(toolName, args);
+  }
+  /**
+   * Refresh tools for all connected clients
+   */
+  async refreshAllTools() {
+    const refreshPromises = [];
+    for (const client of this.getConnectedClients()) {
+      refreshPromises.push(
+        client.refreshTools().then(() => void 0).catch((error) => {
+          console.error("Error refreshing tools:", error);
+        })
+      );
+    }
+    await Promise.all(refreshPromises);
+  }
+  /**
+   * Check if a specific client is connected
+   */
+  isConnected(name) {
+    const client = this.clients.get(name);
+    return client?.isConnected() ?? false;
+  }
+  /**
+   * Create a client with event forwarding
+   */
+  createClient(config) {
+    const clientEvents = {
+      onConnectionStateChange: (state) => {
+        this.events.onConnectionStateChange?.(config.name, state);
+        const managerState = this.getState();
+        if (state === "connected" && managerState.allConnected) {
+          this.events.onAllConnected?.();
+        }
+      },
+      onToolsChange: (tools) => {
+        this.events.onToolsChange?.(config.name, tools);
+      },
+      onError: (error) => {
+        this.events.onError?.(config.name, error);
+      }
+    };
+    return chunk7K7HZMP4_cjs.createMCPClient(config, clientEvents);
+  }
+};
+function createMCPClientManager(configs, events) {
+  return new MCPClientManager(configs, events);
+}
+
+// src/mcp/transports/SSETransport.ts
+var SSETransport = class extends chunk7K7HZMP4_cjs.BaseTransport {
+  constructor(options) {
+    super();
+    this.url = options.url;
+    this.headers = options.headers ?? {};
+    this.timeout = options.timeout ?? 3e4;
+  }
+  /**
+   * Connect to the SSE endpoint
+   */
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        const sseUrl = new URL(this.url);
+        if (this.sessionId) {
+          sseUrl.searchParams.set("sessionId", this.sessionId);
+        }
+        this.eventSource = new EventSource(sseUrl.toString());
+        this.eventSource.onopen = () => {
+          this.connected = true;
+          resolve();
+        };
+        this.eventSource.onmessage = (event) => {
+          this.handleSSEMessage(event.data);
+        };
+        this.eventSource.addEventListener("message", (event) => {
+          this.handleSSEMessage(event.data);
+        });
+        this.eventSource.addEventListener("endpoint", (event) => {
+          try {
+            const data = JSON.parse(event.data);
+            if (data.endpoint) {
+              this.messageEndpoint = data.endpoint;
+            }
+            if (data.sessionId) {
+              this.sessionId = data.sessionId;
+            }
+          } catch {
+          }
+        });
+        this.eventSource.onerror = (error) => {
+          if (!this.connected) {
+            reject(new chunk7K7HZMP4_cjs.MCPError("SSE connection failed"));
+          } else {
+            this.emitError(new chunk7K7HZMP4_cjs.MCPError("SSE connection error"));
+          }
+        };
+        setTimeout(() => {
+          if (!this.connected) {
+            this.eventSource?.close();
+            reject(new chunk7K7HZMP4_cjs.MCPError("SSE connection timeout"));
+          }
+        }, this.timeout);
+      } catch (error) {
+        reject(
+          error instanceof Error ? error : new chunk7K7HZMP4_cjs.MCPError("Failed to create SSE connection")
+        );
+      }
+    });
+  }
+  /**
+   * Disconnect from the SSE endpoint
+   */
+  async disconnect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = void 0;
+    }
+    this.messageEndpoint = void 0;
+    this.sessionId = void 0;
+    this.connected = false;
+    this.emitClose();
+  }
+  /**
+   * Send a JSON-RPC message via HTTP POST
+   */
+  async send(message) {
+    if (!this.connected) {
+      throw new chunk7K7HZMP4_cjs.MCPError(
+        "Transport not connected",
+        chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    const endpoint = this.messageEndpoint || this.url;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...this.headers
+    };
+    if (this.sessionId) {
+      headers["Mcp-Session-Id"] = this.sessionId;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new chunk7K7HZMP4_cjs.MCPError(
+          `HTTP error: ${response.status} ${response.statusText}`,
+          chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        const text = await response.text();
+        if (text.trim()) {
+          const messages = this.parseResponseText(text);
+          for (const msg of messages) {
+            this.emitMessage(msg);
+          }
+        }
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof chunk7K7HZMP4_cjs.MCPError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new chunk7K7HZMP4_cjs.MCPError(
+          "Request timed out",
+          chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+      throw new chunk7K7HZMP4_cjs.MCPError(
+        `Send failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+  }
+  /**
+   * Handle an SSE message
+   */
+  handleSSEMessage(data) {
+    try {
+      const messages = this.parseResponseText(data);
+      for (const msg of messages) {
+        this.emitMessage(msg);
+      }
+    } catch (error) {
+      console.warn("Failed to parse SSE message:", error);
+    }
+  }
+  /**
+   * Parse response text into JSON-RPC messages
+   */
+  parseResponseText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+      return [];
+    }
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      return parsed.filter(
+        (msg) => this.isValidJsonRpcMessage(msg)
+      );
+    }
+    if (this.isValidJsonRpcMessage(parsed)) {
+      return [parsed];
+    }
+    return [];
+  }
+  /**
+   * Validate a JSON-RPC message
+   */
+  isValidJsonRpcMessage(msg) {
+    if (!msg || typeof msg !== "object") {
+      return false;
+    }
+    const m = msg;
+    if (m.jsonrpc !== "2.0") {
+      return false;
+    }
+    if ("method" in m && typeof m.method === "string") {
+      return true;
+    }
+    if ("id" in m && ("result" in m || "error" in m)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+};
+
+// src/mcp/transports/StdioTransport.ts
+var StdioTransport = class extends chunk7K7HZMP4_cjs.BaseTransport {
+  constructor(options) {
+    super();
+    this.buffer = "";
+    this.command = options.command;
+    this.args = options.args ?? [];
+    this.env = options.env;
+    this.cwd = options.cwd;
+  }
+  /**
+   * Connect by spawning the MCP server process
+   */
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    if (typeof process === "undefined" || typeof chunkJEQ2X3Z6_cjs.__require === "undefined") {
+      throw new chunk7K7HZMP4_cjs.MCPError(
+        "Stdio transport is only available in Node.js environments",
+        chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    try {
+      const childProcess = chunkJEQ2X3Z6_cjs.__require("child_process");
+      this.spawn = childProcess.spawn;
+      const env = {};
+      for (const [key, value] of Object.entries(process.env)) {
+        if (value !== void 0) {
+          env[key] = value;
+        }
+      }
+      if (this.env) {
+        Object.assign(env, this.env);
+      }
+      this.process = this.spawn(this.command, this.args, {
+        env,
+        cwd: this.cwd,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (!this.process.stdin || !this.process.stdout) {
+        throw new chunk7K7HZMP4_cjs.MCPError(
+          "Failed to create stdio pipes",
+          chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+      this.process.stdout.on("data", (data) => {
+        this.handleData(data.toString());
+      });
+      this.process.stderr?.on("data", (data) => {
+        console.error(`[MCP ${this.command}] ${data.toString()}`);
+      });
+      this.process.on("error", (err) => {
+        const error = err;
+        this.emitError(new chunk7K7HZMP4_cjs.MCPError(`Process error: ${error.message}`));
+      });
+      this.process.on("exit", (...args) => {
+        const code = args[0];
+        if (this.connected) {
+          this.connected = false;
+          if (code !== 0 && code !== null) {
+            this.emitError(new chunk7K7HZMP4_cjs.MCPError(`Process exited with code ${code}`));
+          }
+          this.emitClose();
+        }
+      });
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new chunk7K7HZMP4_cjs.MCPError("Process startup timeout"));
+        }, 1e4);
+        setTimeout(() => {
+          clearTimeout(timeout);
+          this.connected = true;
+          resolve();
+        }, 100);
+      });
+    } catch (error) {
+      throw error instanceof chunk7K7HZMP4_cjs.MCPError ? error : new chunk7K7HZMP4_cjs.MCPError(
+        `Failed to spawn process: ${error instanceof Error ? error.message : "Unknown error"}`,
+        chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+  }
+  /**
+   * Disconnect by killing the process
+   */
+  async disconnect() {
+    if (this.process) {
+      this.process.kill("SIGTERM");
+      this.process = void 0;
+    }
+    this.buffer = "";
+    this.connected = false;
+    this.emitClose();
+  }
+  /**
+   * Send a JSON-RPC message via stdin
+   */
+  async send(message) {
+    if (!this.connected || !this.process?.stdin) {
+      throw new chunk7K7HZMP4_cjs.MCPError(
+        "Transport not connected",
+        chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    const data = JSON.stringify(message) + "\n";
+    return new Promise((resolve, reject) => {
+      const stdin = this.process.stdin;
+      stdin.write(data, (error) => {
+        if (error) {
+          reject(
+            new chunk7K7HZMP4_cjs.MCPError(
+              `Write error: ${error.message}`,
+              chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+            )
+          );
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Handle incoming data from stdout
+   */
+  handleData(data) {
+    this.buffer += data;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        if (this.isValidJsonRpcMessage(message)) {
+          this.emitMessage(message);
+        }
+      } catch (error) {
+        console.warn("Failed to parse stdio message:", error);
+      }
+    }
+  }
+  /**
+   * Validate a JSON-RPC message
+   */
+  isValidJsonRpcMessage(msg) {
+    if (!msg || typeof msg !== "object") {
+      return false;
+    }
+    const m = msg;
+    if (m.jsonrpc !== "2.0") {
+      return false;
+    }
+    if ("method" in m && typeof m.method === "string") {
+      return true;
+    }
+    if ("id" in m && ("result" in m || "error" in m)) {
+      return true;
+    }
+    return false;
+  }
+};
+
+Object.defineProperty(exports, "DEFAULT_MCP_UI_SANDBOX", {
+  enumerable: true,
+  get: function () { return chunkJO4BHPAD_cjs.DEFAULT_MCP_UI_SANDBOX; }
+});
+Object.defineProperty(exports, "RESTRICTED_MCP_UI_SANDBOX", {
+  enumerable: true,
+  get: function () { return chunkJO4BHPAD_cjs.RESTRICTED_MCP_UI_SANDBOX; }
+});
+Object.defineProperty(exports, "isMCPUIIntent", {
+  enumerable: true,
+  get: function () { return chunkJO4BHPAD_cjs.isMCPUIIntent; }
+});
+Object.defineProperty(exports, "isMCPUIMessage", {
+  enumerable: true,
+  get: function () { return chunkJO4BHPAD_cjs.isMCPUIMessage; }
+});
+Object.defineProperty(exports, "isMCPUIResourceContent", {
+  enumerable: true,
+  get: function () { return chunkJO4BHPAD_cjs.isMCPUIResourceContent; }
+});
+Object.defineProperty(exports, "parseMCPUIMessage", {
+  enumerable: true,
+  get: function () { return chunkJO4BHPAD_cjs.parseMCPUIMessage; }
+});
+Object.defineProperty(exports, "BaseTransport", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.BaseTransport; }
+});
+Object.defineProperty(exports, "DEFAULT_CLIENT_CAPABILITIES", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.DEFAULT_CLIENT_CAPABILITIES; }
+});
+Object.defineProperty(exports, "DEFAULT_CLIENT_INFO", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.DEFAULT_CLIENT_INFO; }
+});
+Object.defineProperty(exports, "HttpTransport", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.HttpTransport; }
+});
+Object.defineProperty(exports, "JSON_RPC_ERROR_CODES", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.JSON_RPC_ERROR_CODES; }
+});
+Object.defineProperty(exports, "JsonRpcHandler", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.JsonRpcHandler; }
+});
+Object.defineProperty(exports, "MCPClient", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.MCPClient; }
+});
+Object.defineProperty(exports, "MCPError", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.MCPError; }
+});
+Object.defineProperty(exports, "MCPToolAdapter", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.MCPToolAdapter; }
+});
+Object.defineProperty(exports, "MCP_METHODS", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.MCP_METHODS; }
+});
+Object.defineProperty(exports, "MCP_PROTOCOL_VERSION", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.MCP_PROTOCOL_VERSION; }
+});
+Object.defineProperty(exports, "createInitializeParams", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.createInitializeParams; }
+});
+Object.defineProperty(exports, "createMCPClient", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.createMCPClient; }
+});
+Object.defineProperty(exports, "createToolCallParams", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.createToolCallParams; }
+});
+Object.defineProperty(exports, "createToolsListParams", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.createToolsListParams; }
+});
+Object.defineProperty(exports, "mcpToolToDefinition", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.mcpToolToDefinition; }
+});
+Object.defineProperty(exports, "mcpToolsToDefinitions", {
+  enumerable: true,
+  get: function () { return chunk7K7HZMP4_cjs.mcpToolsToDefinitions; }
+});
+exports.MCPClientManager = MCPClientManager;
+exports.SSETransport = SSETransport;
+exports.StdioTransport = StdioTransport;
+exports.createMCPClientManager = createMCPClientManager;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map