integrate-sdk 0.3.7 → 0.3.9

package/src/transport/http-session.ts

@@ -1,322 +0,0 @@
-/**
- * HTTP Session-Based Transport for MCP
- * Uses POST for request/response and optional SSE for notifications
- * Compatible with MCP StreamableHTTPServer with sessions
- */
-
-import type {
-  JSONRPCRequest,
-  JSONRPCResponse,
-  JSONRPCNotification,
-} from "../protocol/messages.js";
-import { parseMessage } from "../protocol/jsonrpc.js";
-
-export type MessageHandler = (
-  message: JSONRPCResponse | JSONRPCNotification
-) => void;
-
-export interface HttpSessionTransportOptions {
-  url: string;
-  headers?: Record<string, string>;
-  /** Timeout for requests in milliseconds */
-  timeout?: number;
-}
-
-/**
- * HTTP Session Transport
- * Maintains a session with the MCP server
- * - Sends requests via POST
- * - Receives responses in POST response body
- * - Optionally listens for notifications via SSE
- */
-export class HttpSessionTransport {
-  private url: string;
-  private headers: Record<string, string>;
-  private timeout: number;
-  private messageHandlers: Set<MessageHandler> = new Set();
-  private sessionId?: string;
-  private sseController?: AbortController;
-  private connected = false;
-
-  constructor(options: HttpSessionTransportOptions) {
-    this.url = options.url;
-    this.headers = options.headers || {};
-    this.timeout = options.timeout || 30000;
-  }
-
-  /**
-   * Initialize session (no persistent connection needed)
-   */
-  async connect(): Promise<void> {
-    if (this.connected) {
-      return;
-    }
-
-    // Session will be established on first request
-    this.connected = true;
-  }
-
-  /**
-   * Send a request to the server and get immediate response
-   */
-  async sendRequest<T = unknown>(
-    method: string,
-    params?: unknown
-  ): Promise<T> {
-    if (!this.connected) {
-      throw new Error("Not connected to server");
-    }
-
-    const request: JSONRPCRequest = {
-      jsonrpc: "2.0",
-      id: Date.now() + Math.random(),
-      method,
-      params: params as Record<string, unknown> | unknown[] | undefined,
-    };
-
-    const headers: Record<string, string> = {
-      ...this.headers,
-      "Content-Type": "application/json",
-    };
-
-    // Include session ID if we have one
-    if (this.sessionId) {
-      headers["mcp-session-id"] = this.sessionId;
-    }
-
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-
-      const response = await fetch(this.url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(request),
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        // Preserve HTTP status code for auth error detection
-        const error = new Error(`Request failed: ${response.statusText}`) as Error & { statusCode?: number };
-        error.statusCode = response.status;
-        throw error;
-      }
-
-      // Capture session ID from first response
-      if (!this.sessionId) {
-        const sid = response.headers.get("mcp-session-id");
-        if (sid) {
-          this.sessionId = sid;
-          console.log("Session established:", sid);
-          
-          // Start SSE listener for notifications
-          this.startSSEListener();
-        }
-      }
-
-      const jsonResponse = (await response.json()) as JSONRPCResponse<T>;
-
-      if ("error" in jsonResponse) {
-        // Preserve the full error object for the client to parse
-        const error = new Error(
-          `JSON-RPC Error ${jsonResponse.error.code}: ${jsonResponse.error.message}`
-        ) as Error & { code?: number; data?: unknown };
-        error.code = jsonResponse.error.code;
-        if (jsonResponse.error.data) {
-          error.data = jsonResponse.error.data;
-        }
-        // Attach the original JSON-RPC error for detailed parsing
-        (error as any).jsonrpcError = jsonResponse.error;
-        throw error;
-      }
-
-      return jsonResponse.result as T;
-    } catch (error) {
-      // If it's a fetch error (network, timeout, etc.), wrap it appropriately
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          const timeoutError = new Error("Request timeout") as Error & { code?: number };
-          timeoutError.code = -32000; // Custom timeout code
-          throw timeoutError;
-        }
-        // Re-throw errors with preserved information
-        throw error;
-      }
-      throw new Error(String(error));
-    }
-  }
-
-  /**
-   * Start SSE listener for server-initiated notifications
-   */
-  private async startSSEListener(): Promise<void> {
-    if (!this.sessionId || this.sseController) {
-      return;
-    }
-
-    this.sseController = new AbortController();
-
-    try {
-      const response = await fetch(this.url, {
-        method: "GET",
-        headers: {
-          ...this.headers,
-          "Accept": "text/event-stream",
-          "mcp-session-id": this.sessionId,
-        },
-        signal: this.sseController.signal,
-      });
-
-      if (!response.ok || !response.body) {
-        return;
-      }
-
-      // Process SSE stream for notifications
-      this.processSSEStream(response.body);
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        // Connection was intentionally closed
-        return;
-      }
-      console.error("SSE connection error:", error);
-    }
-  }
-
-  /**
-   * Process SSE stream for server notifications
-   */
-  private async processSSEStream(body: ReadableStream<Uint8Array>): Promise<void> {
-    const reader = body.getReader();
-    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 lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6).trim();
-            if (data) {
-              this.handleNotification(data);
-            }
-          }
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        return;
-      }
-      console.error("SSE stream error:", error);
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  /**
-   * Handle incoming notification from SSE
-   */
-  private handleNotification(data: string): void {
-    try {
-      const message = parseMessage(data);
-      
-      // Notify all message handlers
-      this.messageHandlers.forEach((handler) => {
-        try {
-          handler(message);
-        } catch (error) {
-          console.error("Error in message handler:", error);
-        }
-      });
-    } catch (error) {
-      console.error("Failed to parse notification:", error);
-    }
-  }
-
-  /**
-   * Register a message handler for notifications
-   */
-  onMessage(handler: MessageHandler): () => void {
-    this.messageHandlers.add(handler);
-    
-    // Return unsubscribe function
-    return () => {
-      this.messageHandlers.delete(handler);
-    };
-  }
-
-  /**
-   * Disconnect from the server
-   */
-  async disconnect(): Promise<void> {
-    if (!this.connected) {
-      return;
-    }
-
-    // Close SSE connection if open
-    if (this.sseController) {
-      this.sseController.abort();
-      this.sseController = undefined;
-    }
-
-    // Clear handlers
-    this.messageHandlers.clear();
-
-    this.sessionId = undefined;
-    this.connected = false;
-  }
-
-  /**
-   * Check if transport is connected
-   */
-  isConnected(): boolean {
-    return this.connected;
-  }
-
-  /**
-   * Get current session ID
-   */
-  getSessionId(): string | undefined {
-    return this.sessionId;
-  }
-
-  /**
-   * Set a custom header for all requests
-   * Used for session tokens and other auth headers
-   * 
-   * @param key - Header name
-   * @param value - Header value
-   * 
-   * @example
-   * ```typescript
-   * transport.setHeader('X-Session-Token', 'abc123');
-   * ```
-   */
-  setHeader(key: string, value: string): void {
-    this.headers[key] = value;
-  }
-
-  /**
-   * Remove a custom header
-   * 
-   * @param key - Header name to remove
-   */
-  removeHeader(key: string): void {
-    delete this.headers[key];
-  }
-
-  /**
-   * Get all current headers
-   */
-  getHeaders(): Record<string, string> {
-    return { ...this.headers };
-  }
-}
-

package/src/transport/http-stream.ts

@@ -1,331 +0,0 @@
-/**
- * HTTP Streaming Transport for MCP
- * Implements HTTP streaming with newline-delimited JSON (NDJSON)
- * Compatible with MCP's StreamableHTTPServer
- */
-
-import type {
-  JSONRPCRequest,
-  JSONRPCResponse,
-  JSONRPCNotification,
-} from "../protocol/messages.js";
-import { parseMessage } from "../protocol/jsonrpc.js";
-
-export type MessageHandler = (
-  message: JSONRPCResponse | JSONRPCNotification
-) => void;
-
-export interface HttpStreamTransportOptions {
-  url: string;
-  headers?: Record<string, string>;
-  /** Timeout for requests in milliseconds */
-  timeout?: number;
-  /** Heartbeat interval in milliseconds (default: 30000) */
-  heartbeatInterval?: number;
-}
-
-/**
- * HTTP Streaming Transport
- * Handles bidirectional communication with MCP server via HTTP streaming
- * Uses newline-delimited JSON (NDJSON) over a single persistent connection
- */
-export class HttpStreamTransport {
-  private url: string;
-  private headers: Record<string, string>;
-  private timeout: number;
-  private heartbeatInterval: number;
-  private messageHandlers: Set<MessageHandler> = new Set();
-  private pendingRequests: Map<
-    string | number,
-    {
-      resolve: (value: JSONRPCResponse) => void;
-      reject: (error: Error) => void;
-      timeoutId?: ReturnType<typeof setTimeout>;
-    }
-  > = new Map();
-  private streamController?: AbortController;
-  private connected = false;
-  private heartbeatTimer?: ReturnType<typeof setInterval>;
-
-  constructor(options: HttpStreamTransportOptions) {
-    this.url = options.url;
-    this.headers = options.headers || {};
-    this.timeout = options.timeout || 30000;
-    this.heartbeatInterval = options.heartbeatInterval || 30000;
-  }
-
-  /**
-   * Connect to the MCP server and establish SSE connection
-   */
-  async connect(): Promise<void> {
-    if (this.connected) {
-      return;
-    }
-
-    this.streamController = new AbortController();
-
-    try {
-      // Establish SSE connection for receiving messages
-      const response = await fetch(this.url, {
-        method: "GET",
-        headers: {
-          ...this.headers,
-          "Accept": "text/event-stream",
-          "Cache-Control": "no-cache",
-        },
-        signal: this.streamController.signal,
-      });
-
-      if (!response.ok) {
-        throw new Error(`Failed to connect: ${response.statusText}`);
-      }
-
-      if (!response.body) {
-        throw new Error("Response body is null");
-      }
-
-      this.connected = true;
-
-      // Process incoming SSE stream
-      this.processStream(response.body);
-
-      // Start heartbeat
-      this.startHeartbeat();
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        // Connection was intentionally closed
-        return;
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Process incoming SSE stream
-   */
-  private async processStream(body: ReadableStream<Uint8Array>): Promise<void> {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        
-        if (done) {
-          break;
-        }
-
-        // Decode and add to buffer
-        buffer += decoder.decode(value, { stream: true });
-        
-        // Split by newlines
-        const lines = buffer.split("\n");
-        
-        // Keep the last incomplete line in the buffer
-        buffer = lines.pop() || "";
-
-        // Process SSE format: "data: {json}\n\n"
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6).trim();
-            if (data) {
-              this.handleMessage(data);
-            }
-          } else if (line.trim() === "") {
-            // Empty line separates events
-            continue;
-          } else if (line.startsWith(":")) {
-            // SSE comment, ignore
-            continue;
-          }
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        // Stream was intentionally closed
-        return;
-      }
-      console.error("Stream error:", error);
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  /**
-   * Start sending periodic heartbeats to keep connection alive
-   */
-  private startHeartbeat(): void {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-    }
-
-    this.heartbeatTimer = setInterval(() => {
-      if (this.connected) {
-        // Send a ping/heartbeat (you can customize this based on your server's expectations)
-        this.sendRawMessage({ jsonrpc: "2.0", method: "ping" }).catch((error) => {
-          console.error("Heartbeat failed:", error);
-        });
-      }
-    }, this.heartbeatInterval);
-  }
-
-  /**
-   * Handle incoming message from server
-   */
-  private handleMessage(data: string): void {
-    try {
-      const message = parseMessage(data);
-
-      // Check if this is a response to a pending request
-      if ("id" in message && message.id !== undefined) {
-        const pending = this.pendingRequests.get(message.id);
-        if (pending) {
-          if (pending.timeoutId) {
-            clearTimeout(pending.timeoutId);
-          }
-          this.pendingRequests.delete(message.id);
-          pending.resolve(message as JSONRPCResponse);
-          return;
-        }
-      }
-
-      // Otherwise, notify all message handlers (notifications, etc.)
-      this.messageHandlers.forEach((handler) => {
-        try {
-          handler(message);
-        } catch (error) {
-          console.error("Error in message handler:", error);
-        }
-      });
-    } catch (error) {
-      console.error("Failed to parse message:", error);
-    }
-  }
-
-  /**
-   * Send a raw message to the server via POST (internal use)
-   */
-  private async sendRawMessage(message: unknown): Promise<void> {
-    // Send each message as a separate POST request
-    const response = await fetch(this.url, {
-      method: "POST",
-      headers: {
-        ...this.headers,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(message),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to send message: ${response.statusText}`);
-    }
-  }
-
-  /**
-   * Send a request to the server
-   */
-  async sendRequest<T = unknown>(
-    method: string,
-    params?: unknown
-  ): Promise<T> {
-    if (!this.connected) {
-      throw new Error("Not connected to server");
-    }
-
-    const request: JSONRPCRequest = {
-      jsonrpc: "2.0",
-      id: Date.now() + Math.random(),
-      method,
-      params: params as Record<string, unknown> | unknown[] | undefined,
-    };
-
-    // Create promise for response
-    const responsePromise = new Promise<JSONRPCResponse>((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        this.pendingRequests.delete(request.id);
-        reject(new Error(`Request timeout: ${method}`));
-      }, this.timeout);
-
-      this.pendingRequests.set(request.id, {
-        resolve,
-        reject,
-        timeoutId,
-      });
-    });
-
-    // Send request over the stream
-    try {
-      await this.sendRawMessage(request);
-    } catch (error) {
-      this.pendingRequests.delete(request.id);
-      throw error;
-    }
-
-    // Wait for response over the same stream
-    const response = await responsePromise;
-
-    if ("error" in response) {
-      throw new Error(
-        `JSON-RPC Error ${response.error.code}: ${response.error.message}`
-      );
-    }
-
-    return response.result as T;
-  }
-
-  /**
-   * Register a message handler for notifications and other messages
-   */
-  onMessage(handler: MessageHandler): () => void {
-    this.messageHandlers.add(handler);
-    
-    // Return unsubscribe function
-    return () => {
-      this.messageHandlers.delete(handler);
-    };
-  }
-
-  /**
-   * Disconnect from the server
-   */
-  async disconnect(): Promise<void> {
-    if (!this.connected) {
-      return;
-    }
-
-    // Stop heartbeat
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = undefined;
-    }
-
-    // Cancel SSE stream connection
-    if (this.streamController) {
-      this.streamController.abort();
-      this.streamController = undefined;
-    }
-
-    // Reject all pending requests
-    this.pendingRequests.forEach(({ reject, timeoutId }) => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      reject(new Error("Connection closed"));
-    });
-    this.pendingRequests.clear();
-
-    // Clear handlers
-    this.messageHandlers.clear();
-
-    this.connected = false;
-  }
-
-  /**
-   * Check if transport is connected
-   */
-  isConnected(): boolean {
-    return this.connected;
-  }
-}
-

package/src/utils/naming.ts

@@ -1,52 +0,0 @@
-/**
- * Naming conversion utilities
- * Helpers for converting between camelCase and snake_case
- */
-
-/**
- * Convert camelCase to snake_case
- * 
- * @example
- * camelToSnake('getRepo') // 'get_repo'
- * camelToSnake('listOwnRepos') // 'list_own_repos'
- */
-export function camelToSnake(str: string): string {
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-
-/**
- * Convert snake_case to camelCase
- * 
- * @example
- * snakeToCamel('get_repo') // 'getRepo'
- * snakeToCamel('list_own_repos') // 'listOwnRepos'
- */
-export function snakeToCamel(str: string): string {
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-
-/**
- * Convert a method name to a full tool name with plugin prefix
- * 
- * @example
- * methodToToolName('getRepo', 'github') // 'github_get_repo'
- * methodToToolName('sendEmail', 'gmail') // 'gmail_send_email'
- */
-export function methodToToolName(methodName: string, pluginId: string): string {
-  const snakeCaseMethod = camelToSnake(methodName);
-  return `${pluginId}_${snakeCaseMethod}`;
-}
-
-/**
- * Convert a tool name to a method name (removes plugin prefix and converts to camelCase)
- * 
- * @example
- * toolNameToMethod('github_get_repo') // 'getRepo'
- * toolNameToMethod('gmail_send_email') // 'sendEmail'
- */
-export function toolNameToMethod(toolName: string): string {
-  // Remove the plugin prefix (everything before the first underscore)
-  const withoutPrefix = toolName.replace(/^[^_]+_/, '');
-  return snakeToCamel(withoutPrefix);
-}
-