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

package/dist/chunk-7K7HZMP4.cjs

@@ -0,0 +1,1170 @@
+'use strict';
+
+// src/mcp/types.ts
+var JSON_RPC_ERROR_CODES = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+var MCPError = class _MCPError extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "MCPError";
+  }
+  static fromJsonRpcError(error) {
+    return new _MCPError(error.message, error.code, error.data);
+  }
+};
+
+// src/mcp/protocol/JsonRpcHandler.ts
+var JsonRpcHandler = class {
+  constructor(options) {
+    this.requestId = 0;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.defaultTimeout = options?.timeout ?? 3e4;
+  }
+  /**
+   * Generate a unique request ID
+   */
+  generateId() {
+    return `req_${++this.requestId}_${Date.now()}`;
+  }
+  /**
+   * Create a JSON-RPC request
+   */
+  createRequest(method, params) {
+    const request = {
+      jsonrpc: "2.0",
+      id: this.generateId(),
+      method
+    };
+    if (params !== void 0) {
+      request.params = params;
+    }
+    return request;
+  }
+  /**
+   * Create a JSON-RPC notification (no response expected)
+   */
+  createNotification(method, params) {
+    const notification = {
+      jsonrpc: "2.0",
+      method
+    };
+    if (params !== void 0) {
+      notification.params = params;
+    }
+    return notification;
+  }
+  /**
+   * Register a pending request and return a promise that resolves when response is received
+   */
+  registerRequest(request, timeout) {
+    return new Promise((resolve, reject) => {
+      const timeoutMs = timeout ?? this.defaultTimeout;
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(request.id);
+        reject(
+          new MCPError(
+            `Request timed out after ${timeoutMs}ms: ${request.method}`,
+            JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+          )
+        );
+      }, timeoutMs);
+      this.pendingRequests.set(request.id, {
+        resolve,
+        reject,
+        timeout: timeoutHandle
+      });
+    });
+  }
+  /**
+   * Handle an incoming JSON-RPC response
+   */
+  handleResponse(response) {
+    if (response.id === null) {
+      return false;
+    }
+    const pending = this.pendingRequests.get(response.id);
+    if (!pending) {
+      return false;
+    }
+    this.pendingRequests.delete(response.id);
+    clearTimeout(pending.timeout);
+    if (isErrorResponse(response)) {
+      pending.reject(MCPError.fromJsonRpcError(response.error));
+    } else {
+      pending.resolve(response.result);
+    }
+    return true;
+  }
+  /**
+   * Parse a JSON-RPC message from string
+   */
+  parse(data) {
+    try {
+      const parsed = JSON.parse(data);
+      if (!this.isValidMessage(parsed)) {
+        throw new MCPError(
+          "Invalid JSON-RPC message",
+          JSON_RPC_ERROR_CODES.INVALID_REQUEST
+        );
+      }
+      return parsed;
+    } catch (error) {
+      if (error instanceof MCPError) {
+        throw error;
+      }
+      throw new MCPError(
+        "Failed to parse JSON-RPC message",
+        JSON_RPC_ERROR_CODES.PARSE_ERROR,
+        error
+      );
+    }
+  }
+  /**
+   * Serialize a JSON-RPC message to string
+   */
+  serialize(message) {
+    return JSON.stringify(message);
+  }
+  /**
+   * Validate a JSON-RPC message
+   */
+  isValidMessage(message) {
+    if (!message || typeof message !== "object") {
+      return false;
+    }
+    const msg = message;
+    if (msg.jsonrpc !== "2.0") {
+      return false;
+    }
+    if ("method" in msg && typeof msg.method === "string") {
+      return true;
+    }
+    if ("id" in msg) {
+      return "result" in msg || "error" in msg;
+    }
+    return false;
+  }
+  /**
+   * Check if message is a request
+   */
+  isRequest(message) {
+    return "method" in message && "id" in message;
+  }
+  /**
+   * Check if message is a notification
+   */
+  isNotification(message) {
+    return "method" in message && !("id" in message);
+  }
+  /**
+   * Check if message is a response
+   */
+  isResponse(message) {
+    return "id" in message && ("result" in message || "error" in message);
+  }
+  /**
+   * Cancel all pending requests
+   */
+  cancelAllPending(reason) {
+    const error = new MCPError(
+      reason ?? "All pending requests cancelled",
+      JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+    );
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+  /**
+   * Get number of pending requests
+   */
+  getPendingCount() {
+    return this.pendingRequests.size;
+  }
+  /**
+   * Check if a specific request is pending
+   */
+  isPending(id) {
+    return this.pendingRequests.has(id);
+  }
+};
+function isErrorResponse(response) {
+  return "error" in response;
+}
+
+// src/mcp/protocol/messages.ts
+var MCP_METHODS = {
+  // Lifecycle
+  INITIALIZE: "initialize",
+  INITIALIZED: "notifications/initialized",
+  PING: "ping",
+  // Tools
+  TOOLS_LIST: "tools/list",
+  TOOLS_CALL: "tools/call",
+  // Resources (for future use)
+  RESOURCES_LIST: "resources/list",
+  RESOURCES_READ: "resources/read",
+  RESOURCES_SUBSCRIBE: "resources/subscribe",
+  RESOURCES_UNSUBSCRIBE: "resources/unsubscribe",
+  // Prompts (for future use)
+  PROMPTS_LIST: "prompts/list",
+  PROMPTS_GET: "prompts/get",
+  // Notifications
+  TOOLS_LIST_CHANGED: "notifications/tools/list_changed",
+  RESOURCES_LIST_CHANGED: "notifications/resources/list_changed",
+  RESOURCES_UPDATED: "notifications/resources/updated",
+  PROMPTS_LIST_CHANGED: "notifications/prompts/list_changed",
+  // Elicitation
+  ELICITATION_REQUEST: "elicitation/request",
+  ELICITATION_RESPONSE: "elicitation/response",
+  // Logging
+  LOGGING_SET_LEVEL: "logging/setLevel",
+  LOGGING_MESSAGE: "notifications/message",
+  // Cancellation
+  CANCEL: "notifications/cancelled"
+};
+var DEFAULT_CLIENT_INFO = {
+  name: "yourgpt-copilot-sdk",
+  version: "2.2.0"
+};
+var DEFAULT_CLIENT_CAPABILITIES = {
+  roots: {
+    listChanged: true
+  },
+  sampling: {}
+};
+function createInitializeParams(clientInfo, capabilities) {
+  return {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    clientInfo: {
+      ...DEFAULT_CLIENT_INFO,
+      ...clientInfo
+    },
+    capabilities: capabilities ?? DEFAULT_CLIENT_CAPABILITIES
+  };
+}
+function createToolsListParams(cursor) {
+  if (cursor) {
+    return { cursor };
+  }
+  return {};
+}
+function createToolCallParams(name, args) {
+  return {
+    name,
+    arguments: args
+  };
+}
+function createPingParams() {
+  return {};
+}
+function isInitializeResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.protocolVersion === "string" && v.capabilities !== null && typeof v.capabilities === "object" && v.serverInfo !== null && typeof v.serverInfo === "object";
+}
+function isToolsListResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return Array.isArray(v.tools);
+}
+function isToolCallResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return Array.isArray(v.content);
+}
+
+// src/mcp/transports/types.ts
+var BaseTransport = class {
+  constructor() {
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Emit a message to the handler
+   */
+  emitMessage(message) {
+    if (this.messageHandler) {
+      this.messageHandler(message);
+    }
+  }
+  /**
+   * Emit an error to the handler
+   */
+  emitError(error) {
+    if (this.errorHandler) {
+      this.errorHandler(error);
+    }
+  }
+  /**
+   * Emit close event
+   */
+  emitClose() {
+    this.connected = false;
+    if (this.closeHandler) {
+      this.closeHandler();
+    }
+  }
+};
+
+// src/mcp/transports/HttpTransport.ts
+var HttpTransport = class extends BaseTransport {
+  constructor(options) {
+    super();
+    this.url = options.url;
+    this.headers = options.headers ?? {};
+    this.timeout = options.timeout ?? 3e4;
+    this.sessionId = options.sessionId;
+  }
+  /**
+   * Connect the HTTP transport
+   *
+   * For HTTP transport, "connecting" means verifying the endpoint is reachable.
+   * The actual session is established during the initialize handshake.
+   */
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    this.abortController = new AbortController();
+    this.connected = true;
+  }
+  /**
+   * Disconnect the HTTP transport
+   */
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = void 0;
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = void 0;
+    }
+    this.sessionId = void 0;
+    this.connected = false;
+    this.emitClose();
+  }
+  /**
+   * Send a JSON-RPC message and handle the response
+   */
+  async send(message) {
+    if (!this.connected) {
+      throw new MCPError(
+        "Transport not connected",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    try {
+      const response = await this.sendRequest(message);
+      const contentType = response.headers.get("content-type") || "";
+      const newSessionId = response.headers.get("mcp-session-id");
+      if (newSessionId) {
+        this.sessionId = newSessionId;
+      }
+      if (contentType.includes("text/event-stream")) {
+        await this.handleSSEResponse(response);
+      } else 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);
+          }
+        }
+      } else if (!response.ok) {
+        throw new MCPError(
+          `HTTP error: ${response.status} ${response.statusText}`,
+          JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+    } catch (error) {
+      if (error instanceof MCPError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new MCPError(
+            "Request aborted",
+            JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+          );
+        }
+        throw new MCPError(
+          `Transport error: ${error.message}`,
+          JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+          error
+        );
+      }
+      throw new MCPError(
+        "Unknown transport error",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+  }
+  /**
+   * Send an HTTP request
+   */
+  async sendRequest(message) {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      ...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(this.url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Handle an SSE response stream
+   */
+  async handleSSEResponse(response) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new MCPError(
+        "No response body for SSE stream",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const events = buffer.split("\n\n");
+        buffer = events.pop() || "";
+        for (const event of events) {
+          if (!event.trim()) continue;
+          const lines = event.split("\n");
+          let data = "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              data += line.slice(6);
+            }
+          }
+          if (data) {
+            try {
+              const messages = this.parseResponseText(data);
+              for (const msg of messages) {
+                this.emitMessage(msg);
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Parse response text into JSON-RPC messages
+   */
+  parseResponseText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) {
+        return parsed.filter(
+          (msg) => this.isValidJsonRpcMessage(msg)
+        );
+      }
+      if (this.isValidJsonRpcMessage(parsed)) {
+        return [parsed];
+      }
+      return [];
+    } catch {
+      throw new MCPError(
+        "Failed to parse JSON-RPC response",
+        JSON_RPC_ERROR_CODES.PARSE_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;
+  }
+  /**
+   * Start listening for server-initiated events via SSE
+   *
+   * This is optional and used when the server supports server-initiated
+   * notifications (e.g., tools/list_changed).
+   */
+  startEventStream() {
+    if (this.eventSource || typeof EventSource === "undefined") {
+      return;
+    }
+    const url = new URL(this.url);
+    if (this.sessionId) {
+      url.searchParams.set("sessionId", this.sessionId);
+    }
+    this.eventSource = new EventSource(url.toString());
+    this.eventSource.onmessage = (event) => {
+      try {
+        const messages = this.parseResponseText(event.data);
+        for (const msg of messages) {
+          this.emitMessage(msg);
+        }
+      } catch {
+      }
+    };
+    this.eventSource.onerror = () => {
+      this.emitError(new MCPError("SSE connection error"));
+    };
+  }
+  /**
+   * Stop the event stream
+   */
+  stopEventStream() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = void 0;
+    }
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Set the session ID (used after initialization)
+   */
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+};
+
+// src/mcp/tools/MCPToolAdapter.ts
+var MCPToolAdapter = class {
+  constructor(clientName) {
+    this.clientName = clientName;
+  }
+  /**
+   * Convert an MCP tool to a ToolDefinition
+   */
+  toToolDefinition(mcpTool, options) {
+    const { prefix = true, asServerTool = true, callTool } = options;
+    const toolName = prefix ? `${this.clientName}_${mcpTool.name}` : mcpTool.name;
+    const originalName = mcpTool.name;
+    return {
+      name: toolName,
+      description: mcpTool.description ?? `MCP tool: ${mcpTool.name}`,
+      location: asServerTool ? "server" : "client",
+      inputSchema: this.convertInputSchema(mcpTool.inputSchema),
+      handler: async (params, context) => {
+        try {
+          if (context?.signal?.aborted) {
+            return {
+              success: false,
+              error: "Tool execution cancelled"
+            };
+          }
+          const result = await callTool(originalName, params);
+          return this.convertResult(result);
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error calling MCP tool"
+          };
+        }
+      },
+      // MCP tools display their name as title
+      title: this.formatToolTitle(mcpTool.name),
+      executingTitle: `Calling ${this.formatToolTitle(mcpTool.name)}...`,
+      completedTitle: `${this.formatToolTitle(mcpTool.name)} completed`
+    };
+  }
+  /**
+   * Convert multiple MCP tools to ToolDefinitions
+   */
+  toToolDefinitions(mcpTools, options) {
+    return mcpTools.map((tool) => this.toToolDefinition(tool, options));
+  }
+  /**
+   * Convert MCP input schema to SDK ToolInputSchema
+   */
+  convertInputSchema(mcpSchema) {
+    return {
+      type: "object",
+      properties: mcpSchema.properties ? this.convertProperties(mcpSchema.properties) : {},
+      required: mcpSchema.required,
+      additionalProperties: mcpSchema.additionalProperties
+    };
+  }
+  /**
+   * Convert MCP schema properties to SDK JSONSchemaProperty format
+   */
+  convertProperties(properties) {
+    const converted = {};
+    for (const [key, prop] of Object.entries(properties)) {
+      converted[key] = this.convertProperty(prop);
+    }
+    return converted;
+  }
+  /**
+   * Convert a single MCP property to SDK format
+   */
+  convertProperty(prop) {
+    let type = "string";
+    if (prop.type) {
+      if (Array.isArray(prop.type)) {
+        const nonNull = prop.type.find((t) => t !== "null");
+        type = nonNull || "string";
+      } else {
+        type = prop.type;
+      }
+    }
+    const converted = {
+      type,
+      description: prop.description
+    };
+    if (prop.enum) {
+      converted.enum = prop.enum;
+    }
+    if (prop.default !== void 0) {
+      converted.default = prop.default;
+    }
+    if (prop.minLength !== void 0) {
+      converted.minLength = prop.minLength;
+    }
+    if (prop.maxLength !== void 0) {
+      converted.maxLength = prop.maxLength;
+    }
+    if (prop.minimum !== void 0) {
+      converted.minimum = prop.minimum;
+    }
+    if (prop.maximum !== void 0) {
+      converted.maximum = prop.maximum;
+    }
+    if (prop.pattern !== void 0) {
+      converted.pattern = prop.pattern;
+    }
+    if (prop.properties) {
+      converted.properties = this.convertProperties(prop.properties);
+    }
+    if (prop.required) {
+      converted.required = prop.required;
+    }
+    if (prop.items) {
+      converted.items = this.convertProperty(prop.items);
+    }
+    return converted;
+  }
+  /**
+   * Convert MCP tool result to SDK ToolResponse
+   */
+  convertResult(result) {
+    const response = {
+      success: !result.isError
+    };
+    const textParts = [];
+    const aiContent = [];
+    const uiResources = [];
+    for (const content of result.content) {
+      switch (content.type) {
+        case "text":
+          textParts.push(content.text);
+          break;
+        case "image": {
+          const img = content;
+          aiContent.push({
+            type: "image",
+            data: img.data,
+            mediaType: img.mimeType
+          });
+          break;
+        }
+        case "resource": {
+          const res = content.resource;
+          if (res.uri?.startsWith("ui://")) {
+            uiResources.push({
+              uri: res.uri,
+              mimeType: res.mimeType || "text/html",
+              content: res.text,
+              // MCP uses "text" field, normalize to "content"
+              blob: res.blob
+            });
+          } else if (res.text) {
+            textParts.push(res.text);
+          }
+          break;
+        }
+        case "ui": {
+          const uiContent = content;
+          uiResources.push({
+            uri: uiContent.resource.uri,
+            mimeType: uiContent.resource.mimeType,
+            content: uiContent.resource.content,
+            blob: uiContent.resource.blob,
+            metadata: uiContent.resource.metadata
+          });
+          break;
+        }
+      }
+    }
+    if (textParts.length > 0) {
+      response.message = textParts.join("\n");
+      if (textParts.length === 1) {
+        try {
+          response.data = JSON.parse(textParts[0]);
+        } catch {
+          response.data = textParts[0];
+        }
+      } else {
+        response.data = textParts;
+      }
+    }
+    if (aiContent.length > 0) {
+      response._aiContent = aiContent;
+    }
+    if (uiResources.length > 0) {
+      response._uiResources = uiResources;
+    }
+    if (result.isError) {
+      response.error = textParts.join("\n") || "Tool execution failed";
+    }
+    return response;
+  }
+  /**
+   * Format tool name as a readable title
+   */
+  formatToolTitle(name) {
+    return name.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  }
+};
+function mcpToolToDefinition(clientName, mcpTool, options) {
+  const adapter = new MCPToolAdapter(clientName);
+  return adapter.toToolDefinition(mcpTool, options);
+}
+function mcpToolsToDefinitions(clientName, mcpTools, options) {
+  const adapter = new MCPToolAdapter(clientName);
+  return adapter.toToolDefinitions(mcpTools, options);
+}
+
+// src/mcp/client/MCPClient.ts
+var MCPClient = class {
+  constructor(config, events) {
+    this.config = config;
+    this.events = events ?? {};
+    this.rpcHandler = new JsonRpcHandler({ timeout: config.timeout ?? 3e4 });
+    this.toolAdapter = new MCPToolAdapter(config.name);
+    this.state = {
+      connectionState: "disconnected",
+      tools: []
+    };
+  }
+  /**
+   * Get the current client state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get the client name
+   */
+  getName() {
+    return this.config.name;
+  }
+  /**
+   * Check if client is connected
+   */
+  isConnected() {
+    return this.state.connectionState === "connected";
+  }
+  /**
+   * Connect to the MCP server
+   */
+  async connect() {
+    if (this.state.connectionState === "connected") {
+      return;
+    }
+    if (this.state.connectionState === "connecting") {
+      throw new MCPError("Connection already in progress");
+    }
+    this.setConnectionState("connecting");
+    try {
+      this.transport = this.createTransport();
+      this.transport.onMessage(this.handleMessage.bind(this));
+      this.transport.onError(this.handleError.bind(this));
+      this.transport.onClose(this.handleClose.bind(this));
+      await this.transport.connect();
+      await this.initialize();
+      this.setConnectionState("connected");
+      await this.refreshTools();
+    } catch (error) {
+      this.setConnectionState(
+        "error",
+        error instanceof Error ? error.message : "Connection failed"
+      );
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from the MCP server
+   */
+  async disconnect() {
+    if (this.state.connectionState === "disconnected") {
+      return;
+    }
+    this.rpcHandler.cancelAllPending("Client disconnecting");
+    if (this.transport) {
+      await this.transport.disconnect();
+      this.transport = void 0;
+    }
+    this.state = {
+      connectionState: "disconnected",
+      tools: []
+    };
+  }
+  /**
+   * Call an MCP tool
+   */
+  async callTool(name, args) {
+    this.ensureConnected();
+    const result = await this.request(
+      MCP_METHODS.TOOLS_CALL,
+      createToolCallParams(name, args)
+    );
+    if (!isToolCallResult(result)) {
+      throw new MCPError(
+        "Invalid tool call result from server",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    return result;
+  }
+  /**
+   * Refresh the list of available tools
+   */
+  async refreshTools() {
+    this.ensureConnected();
+    const allTools = [];
+    let cursor;
+    do {
+      const result = await this.request(
+        MCP_METHODS.TOOLS_LIST,
+        createToolsListParams(cursor)
+      );
+      if (!isToolsListResult(result)) {
+        throw new MCPError(
+          "Invalid tools list result from server",
+          JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+      allTools.push(...result.tools);
+      cursor = result.nextCursor;
+    } while (cursor);
+    this.state.tools = allTools;
+    this.state.lastActivity = Date.now();
+    this.events.onToolsChange?.(allTools);
+    return allTools;
+  }
+  /**
+   * Convert MCP tools to ToolDefinition format for use with CopilotProvider
+   */
+  toToolDefinitions(options) {
+    const prefix = options?.prefixToolNames !== false;
+    const asServer = options?.serverLocation ?? false;
+    return this.state.tools.map(
+      (tool) => this.toolAdapter.toToolDefinition(tool, {
+        prefix,
+        asServerTool: asServer,
+        callTool: this.callTool.bind(this)
+      })
+    );
+  }
+  /**
+   * Get the list of MCP tools
+   */
+  getTools() {
+    return [...this.state.tools];
+  }
+  /**
+   * Get server info
+   */
+  getServerInfo() {
+    return this.state.serverInfo;
+  }
+  /**
+   * Get server capabilities
+   */
+  getServerCapabilities() {
+    return this.state.serverCapabilities;
+  }
+  /**
+   * Ping the server to check connectivity
+   */
+  async ping() {
+    try {
+      await this.request(MCP_METHODS.PING, createPingParams());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  /**
+   * Create transport based on config
+   */
+  createTransport() {
+    switch (this.config.transport) {
+      case "http":
+        if (!this.config.url) {
+          throw new MCPError(
+            "URL is required for HTTP transport",
+            JSON_RPC_ERROR_CODES.INVALID_PARAMS
+          );
+        }
+        return new HttpTransport({
+          url: this.config.url,
+          headers: this.config.headers,
+          timeout: this.config.timeout
+        });
+      case "sse":
+        if (!this.config.url) {
+          throw new MCPError(
+            "URL is required for SSE transport",
+            JSON_RPC_ERROR_CODES.INVALID_PARAMS
+          );
+        }
+        return new HttpTransport({
+          url: this.config.url,
+          headers: this.config.headers,
+          timeout: this.config.timeout
+        });
+      case "stdio":
+        throw new MCPError(
+          "Stdio transport not yet implemented. Use HTTP or SSE transport.",
+          JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+        );
+      default:
+        throw new MCPError(
+          `Unknown transport type: ${this.config.transport}`,
+          JSON_RPC_ERROR_CODES.INVALID_PARAMS
+        );
+    }
+  }
+  /**
+   * Perform MCP initialization handshake
+   */
+  async initialize() {
+    const params = createInitializeParams(
+      this.config.clientInfo,
+      this.config.capabilities
+    );
+    const result = await this.request(
+      MCP_METHODS.INITIALIZE,
+      params
+    );
+    if (!isInitializeResult(result)) {
+      throw new MCPError(
+        "Invalid initialization result from server",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    this.state.serverInfo = result.serverInfo;
+    this.state.serverCapabilities = result.capabilities;
+    await this.notify(MCP_METHODS.INITIALIZED);
+  }
+  /**
+   * Send a JSON-RPC request and wait for response
+   */
+  async request(method, params) {
+    if (!this.transport) {
+      throw new MCPError(
+        "Transport not initialized",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    const request = this.rpcHandler.createRequest(method, params);
+    const responsePromise = this.rpcHandler.registerRequest(
+      request,
+      this.config.timeout
+    );
+    await this.transport.send(request);
+    return responsePromise;
+  }
+  /**
+   * Send a JSON-RPC notification (no response expected)
+   */
+  async notify(method, params) {
+    if (!this.transport) {
+      throw new MCPError(
+        "Transport not initialized",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    const notification = this.rpcHandler.createNotification(method, params);
+    await this.transport.send(notification);
+  }
+  /**
+   * Handle incoming JSON-RPC message
+   */
+  handleMessage(message) {
+    if (this.rpcHandler.isResponse(message)) {
+      this.rpcHandler.handleResponse(message);
+      return;
+    }
+    if (this.rpcHandler.isNotification(message)) {
+      const notification = message;
+      this.handleNotification(notification.method, notification.params);
+      return;
+    }
+    if (this.rpcHandler.isRequest(message)) {
+      const request = message;
+      this.handleServerRequest(request.id, request.method, request.params);
+    }
+  }
+  /**
+   * Handle server notification
+   */
+  handleNotification(method, params) {
+    switch (method) {
+      case MCP_METHODS.TOOLS_LIST_CHANGED:
+        this.refreshTools().catch((error) => {
+          this.events.onError?.(error);
+        });
+        break;
+      default:
+        this.events.onNotification?.(method, params);
+    }
+  }
+  /**
+   * Handle server-initiated request (e.g., elicitation)
+   */
+  async handleServerRequest(_id, method, params) {
+    if (method === MCP_METHODS.ELICITATION_REQUEST && this.events.onElicitationRequest) {
+      try {
+        const elicitationRequest = params;
+        const response = await this.events.onElicitationRequest(elicitationRequest);
+        await this.notify(
+          MCP_METHODS.ELICITATION_RESPONSE,
+          response
+        );
+      } catch (error) {
+        await this.notify(MCP_METHODS.ELICITATION_RESPONSE, {
+          requestId: params?.requestId,
+          accepted: false,
+          reason: error instanceof Error ? error.message : "User rejected"
+        });
+      }
+    }
+  }
+  /**
+   * Handle transport error
+   */
+  handleError(error) {
+    this.setConnectionState("error", error.message);
+    this.events.onError?.(error);
+  }
+  /**
+   * Handle transport close
+   */
+  handleClose() {
+    if (this.state.connectionState === "connected") {
+      this.setConnectionState("disconnected");
+    }
+  }
+  /**
+   * Update connection state
+   */
+  setConnectionState(state, error) {
+    this.state.connectionState = state;
+    this.state.error = error;
+    this.events.onConnectionStateChange?.(state);
+  }
+  /**
+   * Ensure client is connected
+   */
+  ensureConnected() {
+    if (!this.isConnected()) {
+      throw new MCPError(
+        "Client not connected. Call connect() first.",
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+  }
+};
+function createMCPClient(config, events) {
+  return new MCPClient(config, events);
+}
+
+exports.BaseTransport = BaseTransport;
+exports.DEFAULT_CLIENT_CAPABILITIES = DEFAULT_CLIENT_CAPABILITIES;
+exports.DEFAULT_CLIENT_INFO = DEFAULT_CLIENT_INFO;
+exports.HttpTransport = HttpTransport;
+exports.JSON_RPC_ERROR_CODES = JSON_RPC_ERROR_CODES;
+exports.JsonRpcHandler = JsonRpcHandler;
+exports.MCPClient = MCPClient;
+exports.MCPError = MCPError;
+exports.MCPToolAdapter = MCPToolAdapter;
+exports.MCP_METHODS = MCP_METHODS;
+exports.MCP_PROTOCOL_VERSION = MCP_PROTOCOL_VERSION;
+exports.createInitializeParams = createInitializeParams;
+exports.createMCPClient = createMCPClient;
+exports.createToolCallParams = createToolCallParams;
+exports.createToolsListParams = createToolsListParams;
+exports.mcpToolToDefinition = mcpToolToDefinition;
+exports.mcpToolsToDefinitions = mcpToolsToDefinitions;
+//# sourceMappingURL=chunk-7K7HZMP4.cjs.map
+//# sourceMappingURL=chunk-7K7HZMP4.cjs.map