integrate-sdk 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,108 @@
+/**
+ * MCP Client
+ * Main client class that orchestrates transport, protocol, and plugins
+ */
+import type { MCPTool, MCPToolCallResponse } from "./protocol/messages.js";
+import type { MCPPlugin, OAuthConfig } from "./plugins/types.js";
+import type { MCPClientConfig } from "./config/types.js";
+/**
+ * Tool invocation options
+ */
+export interface ToolInvocationOptions {
+    /** Tool name */
+    name: string;
+    /** Tool arguments */
+    arguments?: Record<string, unknown>;
+}
+/**
+ * MCP Client Class
+ *
+ * Provides type-safe access to MCP server tools with plugin-based configuration
+ */
+export declare class MCPClient<TPlugins extends readonly MCPPlugin[] = readonly MCPPlugin[]> {
+    private transport;
+    private plugins;
+    private availableTools;
+    private enabledToolNames;
+    private initialized;
+    private clientInfo;
+    constructor(config: MCPClientConfig<TPlugins>);
+    /**
+     * Initialize all plugins
+     */
+    private initializePlugins;
+    /**
+     * Connect to the MCP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Initialize the MCP protocol
+     */
+    private initialize;
+    /**
+     * Discover available tools from the server
+     */
+    private discoverTools;
+    /**
+     * Call a tool by name
+     */
+    callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolCallResponse>;
+    /**
+     * Get a tool by name
+     */
+    getTool(name: string): MCPTool | undefined;
+    /**
+     * Get all available tools
+     */
+    getAvailableTools(): MCPTool[];
+    /**
+     * Get all enabled tools (filtered by plugins)
+     */
+    getEnabledTools(): MCPTool[];
+    /**
+     * Get OAuth configuration for a plugin
+     */
+    getOAuthConfig(pluginId: string): OAuthConfig | undefined;
+    /**
+     * Get all OAuth configurations
+     */
+    getAllOAuthConfigs(): Map<string, OAuthConfig>;
+    /**
+     * Register a message handler
+     */
+    onMessage(handler: (message: unknown) => void): () => void;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if client is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Check if client is initialized
+     */
+    isInitialized(): boolean;
+}
+/**
+ * Create a new MCP Client instance
+ *
+ * @example
+ * ```typescript
+ * const client = createMCPClient({
+ *   serverUrl: 'http://localhost:3000/mcp',
+ *   plugins: [
+ *     githubPlugin({ clientId: '...', clientSecret: '...' }),
+ *     gmailPlugin({ clientId: '...', clientSecret: '...' }),
+ *   ],
+ * });
+ *
+ * await client.connect();
+ * const result = await client.callTool('github/createIssue', {
+ *   repo: 'owner/repo',
+ *   title: 'Bug report',
+ * });
+ * ```
+ */
+export declare function createMCPClient<TPlugins extends readonly MCPPlugin[]>(config: MCPClientConfig<TPlugins>): MCPClient<TPlugins>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,OAAO,EAEP,mBAAmB,EAIpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;;;;GAIG;AACH,qBAAa,SAAS,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,GAAG,SAAS,SAAS,EAAE;IACjF,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAoC;gBAE1C,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IAwB7C;;OAEG;YACW,iBAAiB;IAQ/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB9B;;OAEG;YACW,UAAU;IAkBxB;;OAEG;YACW,aAAa;IAoB3B;;OAEG;IACG,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,mBAAmB,CAAC;IA8B/B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI1C;;OAEG;IACH,iBAAiB,IAAI,OAAO,EAAE;IAI9B;;OAEG;IACH,eAAe,IAAI,OAAO,EAAE;IAM5B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAKzD;;OAEG;IACH,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAU9C;;OAEG;IACH,SAAS,CACP,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAClC,MAAM,IAAI;IAIb;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,aAAa,IAAI,OAAO;CAGzB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,EACnE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,GAChC,SAAS,CAAC,QAAQ,CAAC,CAErB"}

package/dist/config/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Configuration Types
+ * Type-safe configuration with inference
+ */
+import type { MCPPlugin } from "../plugins/types.js";
+/**
+ * Main client configuration
+ */
+export interface MCPClientConfig<TPlugins extends readonly MCPPlugin[]> {
+    /** URL of the MCP server */
+    serverUrl: string;
+    /** Array of plugins to enable */
+    plugins: TPlugins;
+    /** Optional HTTP headers to include in requests */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Client information */
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+}
+/**
+ * Helper type to infer enabled tools from plugins
+ */
+export type InferEnabledTools<TPlugins extends readonly MCPPlugin[]> = TPlugins[number]["tools"][number];
+/**
+ * Helper type to create a tools object type from plugin array
+ */
+export type InferToolsObject<TPlugins extends readonly MCPPlugin[]> = {
+    [K in TPlugins[number] as K["id"]]: K["tools"];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE;IACpE,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;IAElB,iCAAiC;IACjC,OAAO,EAAE,QAAQ,CAAC;IAElB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,yBAAyB;IACzB,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,IACjE,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,IAAI;KACnE,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;CAC/C,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Integrate SDK
+ * Type-safe TypeScript SDK for MCP Client
+ */
+export { MCPClient, createMCPClient } from "./client.js";
+export type { ToolInvocationOptions } from "./client.js";
+export type { MCPClientConfig } from "./config/types.js";
+export type { MCPPlugin, OAuthConfig, ExtractPluginIds, ExtractPluginTools, } from "./plugins/types.js";
+export { githubPlugin } from "./plugins/github.js";
+export type { GitHubPluginConfig, GitHubTools } from "./plugins/github.js";
+export { gmailPlugin } from "./plugins/gmail.js";
+export type { GmailPluginConfig, GmailTools } from "./plugins/gmail.js";
+export { genericOAuthPlugin, createSimplePlugin, } from "./plugins/generic.js";
+export type { GenericOAuthPluginConfig } from "./plugins/generic.js";
+export type { JSONRPCRequest, JSONRPCResponse, JSONRPCSuccessResponse, JSONRPCErrorResponse, JSONRPCNotification, MCPTool, MCPToolsListResponse, MCPToolCallParams, MCPToolCallResponse, MCPInitializeParams, MCPInitializeResponse, } from "./protocol/messages.js";
+export { MCPMethod } from "./protocol/messages.js";
+export { HttpSessionTransport } from "./transport/http-session.js";
+export type { MessageHandler, HttpSessionTransportOptions, } from "./transport/http-session.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,YAAY,EACV,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,EACL,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,YAAY,EACV,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,OAAO,EACP,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EACV,cAAc,EACd,2BAA2B,GAC5B,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,440 @@
+// src/protocol/jsonrpc.ts
+function parseMessage(message) {
+  try {
+    return JSON.parse(message);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON-RPC message: ${error}`);
+  }
+}
+
+// src/transport/http-session.ts
+class HttpSessionTransport {
+  url;
+  headers;
+  timeout;
+  messageHandlers = new Set;
+  sessionId;
+  sseController;
+  connected = false;
+  constructor(options) {
+    this.url = options.url;
+    this.headers = options.headers || {};
+    this.timeout = options.timeout || 30000;
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    this.connected = true;
+  }
+  async sendRequest(method, params) {
+    if (!this.connected) {
+      throw new Error("Not connected to server");
+    }
+    const request = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method,
+      params
+    };
+    const headers = {
+      ...this.headers,
+      "Content-Type": "application/json"
+    };
+    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) {
+        throw new Error(`Request failed: ${response.statusText}`);
+      }
+      if (!this.sessionId) {
+        const sid = response.headers.get("mcp-session-id");
+        if (sid) {
+          this.sessionId = sid;
+          console.log("Session established:", sid);
+          this.startSSEListener();
+        }
+      }
+      const jsonResponse = await response.json();
+      if ("error" in jsonResponse) {
+        throw new Error(`JSON-RPC Error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
+      }
+      return jsonResponse.result;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async startSSEListener() {
+    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;
+      }
+      this.processSSEStream(response.body);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      console.error("SSE connection error:", error);
+    }
+  }
+  async processSSEStream(body) {
+    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(`
+`);
+        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();
+    }
+  }
+  handleNotification(data) {
+    try {
+      const message = parseMessage(data);
+      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);
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => {
+      this.messageHandlers.delete(handler);
+    };
+  }
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+    if (this.sseController) {
+      this.sseController.abort();
+      this.sseController = undefined;
+    }
+    this.messageHandlers.clear();
+    this.sessionId = undefined;
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+}
+
+// src/protocol/messages.ts
+var MCPMethod;
+((MCPMethod2) => {
+  MCPMethod2["INITIALIZE"] = "initialize";
+  MCPMethod2["TOOLS_LIST"] = "tools/list";
+  MCPMethod2["TOOLS_CALL"] = "tools/call";
+  MCPMethod2["RESOURCES_LIST"] = "resources/list";
+  MCPMethod2["RESOURCES_READ"] = "resources/read";
+  MCPMethod2["PROMPTS_LIST"] = "prompts/list";
+  MCPMethod2["PROMPTS_GET"] = "prompts/get";
+})(MCPMethod ||= {});
+
+// src/client.ts
+class MCPClient {
+  transport;
+  plugins;
+  availableTools = new Map;
+  enabledToolNames = new Set;
+  initialized = false;
+  clientInfo;
+  constructor(config) {
+    this.transport = new HttpSessionTransport({
+      url: config.serverUrl,
+      headers: config.headers,
+      timeout: config.timeout
+    });
+    this.plugins = config.plugins;
+    this.clientInfo = config.clientInfo || {
+      name: "integrate-sdk",
+      version: "0.1.0"
+    };
+    for (const plugin of this.plugins) {
+      for (const toolName of plugin.tools) {
+        this.enabledToolNames.add(toolName);
+      }
+    }
+    this.initializePlugins();
+  }
+  async initializePlugins() {
+    for (const plugin of this.plugins) {
+      if (plugin.onInit) {
+        await plugin.onInit(this);
+      }
+    }
+  }
+  async connect() {
+    for (const plugin of this.plugins) {
+      if (plugin.onBeforeConnect) {
+        await plugin.onBeforeConnect(this);
+      }
+    }
+    await this.transport.connect();
+    await this.initialize();
+    await this.discoverTools();
+    for (const plugin of this.plugins) {
+      if (plugin.onAfterConnect) {
+        await plugin.onAfterConnect(this);
+      }
+    }
+  }
+  async initialize() {
+    const params = {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        tools: {}
+      },
+      clientInfo: this.clientInfo
+    };
+    const response = await this.transport.sendRequest("initialize" /* INITIALIZE */, params);
+    this.initialized = true;
+    return response;
+  }
+  async discoverTools() {
+    const response = await this.transport.sendRequest("tools/list" /* TOOLS_LIST */);
+    for (const tool of response.tools) {
+      this.availableTools.set(tool.name, tool);
+    }
+    const enabledTools = response.tools.filter((tool) => this.enabledToolNames.has(tool.name));
+    console.log(`Discovered ${response.tools.length} tools, ${enabledTools.length} enabled by plugins`);
+  }
+  async callTool(name, args) {
+    if (!this.initialized) {
+      throw new Error("Client not initialized. Call connect() first.");
+    }
+    if (!this.enabledToolNames.has(name)) {
+      throw new Error(`Tool "${name}" is not enabled. Enable it by adding the appropriate plugin.`);
+    }
+    if (!this.availableTools.has(name)) {
+      throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
+    }
+    const params = {
+      name,
+      arguments: args
+    };
+    return await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+  }
+  getTool(name) {
+    return this.availableTools.get(name);
+  }
+  getAvailableTools() {
+    return Array.from(this.availableTools.values());
+  }
+  getEnabledTools() {
+    return Array.from(this.availableTools.values()).filter((tool) => this.enabledToolNames.has(tool.name));
+  }
+  getOAuthConfig(pluginId) {
+    const plugin = this.plugins.find((p) => p.id === pluginId);
+    return plugin?.oauth;
+  }
+  getAllOAuthConfigs() {
+    const configs = new Map;
+    for (const plugin of this.plugins) {
+      if (plugin.oauth) {
+        configs.set(plugin.id, plugin.oauth);
+      }
+    }
+    return configs;
+  }
+  onMessage(handler) {
+    return this.transport.onMessage(handler);
+  }
+  async disconnect() {
+    for (const plugin of this.plugins) {
+      if (plugin.onDisconnect) {
+        await plugin.onDisconnect(this);
+      }
+    }
+    await this.transport.disconnect();
+    this.initialized = false;
+  }
+  isConnected() {
+    return this.transport.isConnected();
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+}
+function createMCPClient(config) {
+  return new MCPClient(config);
+}
+// src/plugins/github.ts
+var GITHUB_TOOLS = [
+  "github/createIssue",
+  "github/listIssues",
+  "github/getIssue",
+  "github/updateIssue",
+  "github/closeIssue",
+  "github/createPullRequest",
+  "github/listPullRequests",
+  "github/getPullRequest",
+  "github/mergePullRequest",
+  "github/listRepositories",
+  "github/getRepository",
+  "github/createRepository",
+  "github/listBranches",
+  "github/createBranch",
+  "github/getUser",
+  "github/listCommits",
+  "github/getCommit"
+];
+function githubPlugin(config) {
+  const oauth = {
+    provider: "github",
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes || ["repo", "user"],
+    redirectUri: config.redirectUri,
+    config: {
+      apiBaseUrl: config.apiBaseUrl || "https://api.github.com",
+      ...config
+    }
+  };
+  return {
+    id: "github",
+    tools: [...GITHUB_TOOLS],
+    oauth,
+    async onInit(_client) {
+      console.log("GitHub plugin initialized");
+    },
+    async onAfterConnect(_client) {
+      console.log("GitHub plugin connected");
+    }
+  };
+}
+// src/plugins/gmail.ts
+var GMAIL_TOOLS = [
+  "gmail/sendEmail",
+  "gmail/listEmails",
+  "gmail/getEmail",
+  "gmail/deleteEmail",
+  "gmail/searchEmails",
+  "gmail/markAsRead",
+  "gmail/markAsUnread",
+  "gmail/addLabel",
+  "gmail/removeLabel",
+  "gmail/listLabels",
+  "gmail/createLabel",
+  "gmail/getDraft",
+  "gmail/createDraft",
+  "gmail/updateDraft",
+  "gmail/deleteDraft",
+  "gmail/sendDraft"
+];
+function gmailPlugin(config) {
+  const oauth = {
+    provider: "google",
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes || [
+      "https://www.googleapis.com/auth/gmail.send",
+      "https://www.googleapis.com/auth/gmail.readonly",
+      "https://www.googleapis.com/auth/gmail.modify",
+      "https://www.googleapis.com/auth/gmail.labels"
+    ],
+    redirectUri: config.redirectUri,
+    config
+  };
+  return {
+    id: "gmail",
+    tools: [...GMAIL_TOOLS],
+    oauth,
+    async onInit(_client) {
+      console.log("Gmail plugin initialized");
+    },
+    async onAfterConnect(_client) {
+      console.log("Gmail plugin connected");
+    }
+  };
+}
+// src/plugins/generic.ts
+function genericOAuthPlugin(config) {
+  const oauth = {
+    provider: config.provider,
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes,
+    redirectUri: config.redirectUri,
+    config
+  };
+  return {
+    id: config.id,
+    tools: config.tools,
+    oauth,
+    onInit: config.onInit,
+    onAfterConnect: config.onAfterConnect,
+    onDisconnect: config.onDisconnect
+  };
+}
+function createSimplePlugin(config) {
+  return {
+    id: config.id,
+    tools: config.tools,
+    onInit: config.onInit,
+    onAfterConnect: config.onAfterConnect,
+    onDisconnect: config.onDisconnect
+  };
+}
+export {
+  gmailPlugin,
+  githubPlugin,
+  genericOAuthPlugin,
+  createSimplePlugin,
+  createMCPClient,
+  MCPMethod,
+  MCPClient,
+  HttpSessionTransport
+};

package/dist/plugins/generic.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Generic OAuth Plugin
+ * Template for creating custom OAuth provider plugins
+ */
+import type { MCPPlugin } from "./types.js";
+/**
+ * Generic OAuth plugin configuration
+ */
+export interface GenericOAuthPluginConfig {
+    /** Plugin unique identifier */
+    id: string;
+    /** OAuth provider name */
+    provider: string;
+    /** OAuth client ID */
+    clientId: string;
+    /** OAuth client secret */
+    clientSecret: string;
+    /** OAuth scopes */
+    scopes: string[];
+    /** Tool names to enable */
+    tools: string[];
+    /** OAuth redirect URI */
+    redirectUri?: string;
+    /** Additional provider-specific configuration */
+    config?: Record<string, unknown>;
+    /** Optional initialization callback */
+    onInit?: (client: any) => Promise<void> | void;
+    /** Optional after connect callback */
+    onAfterConnect?: (client: any) => Promise<void> | void;
+    /** Optional disconnect callback */
+    onDisconnect?: (client: any) => Promise<void> | void;
+}
+/**
+ * Generic OAuth Plugin
+ *
+ * Use this to create custom plugins for any OAuth provider
+ *
+ * @example
+ * ```typescript
+ * const slackPlugin = genericOAuthPlugin({
+ *   id: 'slack',
+ *   provider: 'slack',
+ *   clientId: process.env.SLACK_CLIENT_ID!,
+ *   clientSecret: process.env.SLACK_CLIENT_SECRET!,
+ *   scopes: ['chat:write', 'channels:read'],
+ *   tools: [
+ *     'slack/sendMessage',
+ *     'slack/listChannels',
+ *     'slack/getChannel',
+ *   ],
+ * });
+ *
+ * const client = createMCPClient({
+ *   serverUrl: 'http://localhost:3000/mcp',
+ *   plugins: [slackPlugin],
+ * });
+ * ```
+ */
+export declare function genericOAuthPlugin(config: GenericOAuthPluginConfig): MCPPlugin<GenericOAuthPluginConfig>;
+/**
+ * Create a simple plugin without OAuth
+ * Useful for plugins that just enable certain tools without authentication
+ *
+ * @example
+ * ```typescript
+ * const mathPlugin = createSimplePlugin({
+ *   id: 'math',
+ *   tools: ['math/add', 'math/subtract', 'math/multiply', 'math/divide'],
+ * });
+ * ```
+ */
+export declare function createSimplePlugin(config: {
+    id: string;
+    tools: string[];
+    onInit?: (client: any) => Promise<void> | void;
+    onAfterConnect?: (client: any) => Promise<void> | void;
+    onDisconnect?: (client: any) => Promise<void> | void;
+}): MCPPlugin;
+//# sourceMappingURL=generic.d.ts.map

package/dist/plugins/generic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/plugins/generic.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,+BAA+B;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,yBAAyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,uCAAuC;IACvC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/C,sCAAsC;IACtC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvD,mCAAmC;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,wBAAwB,GAC/B,SAAS,CAAC,wBAAwB,CAAC,CAmBrC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvD,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtD,GAAG,SAAS,CAQZ"}