integrate-sdk 0.7.66 → 0.8.0

package/dist/index.js

@@ -1325,7 +1325,7 @@ class OAuthManager {
   }
   clearProviderToken(provider) {
     this.providerTokens.delete(provider);
-    if (!this.getTokenCallback && typeof window !== "undefined" && window.localStorage) {
+    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
       try {
         window.localStorage.removeItem(`integrate_token_${provider}`);
       } catch (error) {
@@ -1336,7 +1336,7 @@ class OAuthManager {
   clearAllProviderTokens() {
     const providers = Array.from(this.providerTokens.keys());
     this.providerTokens.clear();
-    if (!this.getTokenCallback && typeof window !== "undefined" && window.localStorage) {
+    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
       for (const provider of providers) {
         try {
           window.localStorage.removeItem(`integrate_token_${provider}`);
@@ -2017,7 +2017,28 @@ class MCPClientBase {
       await this.oauthCallbackPromise;
       this.oauthCallbackPromise = null;
     }
-    return this.authState.get(provider)?.authenticated ?? false;
+    try {
+      const tokenData = await this.oauthManager.getProviderToken(provider);
+      const isAuthenticated = !!tokenData;
+      const currentState = this.authState.get(provider);
+      if (currentState) {
+        currentState.authenticated = isAuthenticated;
+        if (isAuthenticated) {
+          currentState.lastError = undefined;
+        }
+      } else {
+        this.authState.set(provider, { authenticated: isAuthenticated });
+      }
+      return isAuthenticated;
+    } catch (error) {
+      const currentState = this.authState.get(provider);
+      if (currentState) {
+        currentState.authenticated = false;
+      } else {
+        this.authState.set(provider, { authenticated: false });
+      }
+      return false;
+    }
   }
   async authorizedProviders() {
     if (this.oauthCallbackPromise) {
@@ -2045,6 +2066,21 @@ class MCPClientBase {
       this.eventEmitter.emit("auth:error", { provider, error });
       throw error;
     }
+    if (options?.useExistingConnection) {
+      const authStatus = await this.oauthManager.checkAuthStatus(provider);
+      if (authStatus.authorized) {
+        const tokenData = await this.oauthManager.getProviderToken(provider);
+        if (tokenData) {
+          this.eventEmitter.emit("auth:complete", {
+            provider,
+            accessToken: tokenData.accessToken,
+            expiresAt: tokenData.expiresAt
+          });
+          this.authState.set(provider, { authenticated: true });
+        }
+        return;
+      }
+    }
     this.eventEmitter.emit("auth:started", { provider });
     try {
       await this.oauthManager.initiateFlow(provider, integration.oauth, options?.returnUrl);

package/dist/server.js

@@ -1318,7 +1318,7 @@ class OAuthManager {
   }
   clearProviderToken(provider) {
     this.providerTokens.delete(provider);
-    if (!this.getTokenCallback && typeof window !== "undefined" && window.localStorage) {
+    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
       try {
         window.localStorage.removeItem(`integrate_token_${provider}`);
       } catch (error) {
@@ -1329,7 +1329,7 @@ class OAuthManager {
   clearAllProviderTokens() {
     const providers = Array.from(this.providerTokens.keys());
     this.providerTokens.clear();
-    if (!this.getTokenCallback && typeof window !== "undefined" && window.localStorage) {
+    if (!this.skipLocalStorage && typeof window !== "undefined" && window.localStorage) {
       for (const provider of providers) {
         try {
           window.localStorage.removeItem(`integrate_token_${provider}`);
@@ -2008,7 +2008,28 @@ class MCPClientBase {
       await this.oauthCallbackPromise;
       this.oauthCallbackPromise = null;
     }
-    return this.authState.get(provider)?.authenticated ?? false;
+    try {
+      const tokenData = await this.oauthManager.getProviderToken(provider);
+      const isAuthenticated = !!tokenData;
+      const currentState = this.authState.get(provider);
+      if (currentState) {
+        currentState.authenticated = isAuthenticated;
+        if (isAuthenticated) {
+          currentState.lastError = undefined;
+        }
+      } else {
+        this.authState.set(provider, { authenticated: isAuthenticated });
+      }
+      return isAuthenticated;
+    } catch (error) {
+      const currentState = this.authState.get(provider);
+      if (currentState) {
+        currentState.authenticated = false;
+      } else {
+        this.authState.set(provider, { authenticated: false });
+      }
+      return false;
+    }
   }
   async authorizedProviders() {
     if (this.oauthCallbackPromise) {
@@ -2036,6 +2057,21 @@ class MCPClientBase {
       this.eventEmitter.emit("auth:error", { provider, error });
       throw error;
     }
+    if (options?.useExistingConnection) {
+      const authStatus = await this.oauthManager.checkAuthStatus(provider);
+      if (authStatus.authorized) {
+        const tokenData = await this.oauthManager.getProviderToken(provider);
+        if (tokenData) {
+          this.eventEmitter.emit("auth:complete", {
+            provider,
+            accessToken: tokenData.accessToken,
+            expiresAt: tokenData.expiresAt
+          });
+          this.authState.set(provider, { authenticated: true });
+        }
+        return;
+      }
+    }
     this.eventEmitter.emit("auth:started", { provider });
     try {
       await this.oauthManager.initiateFlow(provider, integration.oauth, options?.returnUrl);

package/dist/src/ai/cloudflare.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Cloudflare Workers AI Integration
+ *
+ * Helper functions to convert MCP tools to Cloudflare Workers AI format
+ */
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Cloudflare AI tool definition
+ * Compatible with Cloudflare Workers AI
+ */
+export interface CloudflareTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, {
+                type: string;
+                description?: string;
+            }>;
+            required: string[];
+        };
+    };
+}
+/**
+ * Options for converting MCP tools to Cloudflare format
+ */
+export interface CloudflareToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to Cloudflare Workers AI format
+ *
+ * @param mcpTool - The MCP tool definition
+ * @param client - The MCP client instance (used for executing the tool)
+ * @param options - Optional configuration including provider tokens
+ * @returns Cloudflare compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const cloudflareTool = convertMCPToolToCloudflare(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToCloudflare(mcpTool: MCPTool, _client: MCPClient<any>, _options?: CloudflareToolsOptions): CloudflareTool;
+/**
+ * Convert all enabled MCP tools to Cloudflare Workers AI format
+ * Returns a dictionary keyed by tool name
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Dictionary of Cloudflare compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToCloudflare(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToCloudflare(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToCloudflare(client: MCPClient<any>, options?: CloudflareToolsOptions): Record<string, CloudflareTool>;
+/**
+ * Execute a tool call from Cloudflare Workers AI
+ *
+ * @param client - The MCP client instance
+ * @param toolCall - The tool call with name and arguments
+ * @param options - Optional configuration including provider tokens
+ * @returns Tool execution result as JSON string
+ *
+ * @example
+ * ```typescript
+ * const result = await executeCloudflareToolCall(client, {
+ *   name: 'github_create_issue',
+ *   arguments: { owner: 'user', repo: 'repo', title: 'Bug' }
+ * }, { providerTokens });
+ * ```
+ */
+export declare function executeCloudflareToolCall(client: MCPClient<any>, toolCall: {
+    name: string;
+    arguments: Record<string, unknown> | string;
+}, options?: CloudflareToolsOptions): Promise<string>;
+/**
+ * Get tools in a format compatible with Cloudflare Workers AI
+ *
+ * Automatically connects the client if not already connected.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Dictionary of tools ready to use with Cloudflare Workers AI
+ *
+ * @example
+ * ```typescript
+ * // Cloudflare Worker usage
+ * import { createMCPClient, githubIntegration } from 'integrate-sdk';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/ai/cloudflare';
+ *
+ * export default {
+ *   async fetch(request: Request, env: Env): Promise<Response> {
+ *     const client = createMCPClient({
+ *       integrations: [githubIntegration({ clientId: env.GITHUB_CLIENT_ID })],
+ *     });
+ *
+ *     const tools = await getCloudflareTools(client);
+ *     const ai = new Ai(env.AI);
+ *
+ *     const response = await ai.run('@cf/meta/llama-3-8b-instruct', {
+ *       messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ *       tools: Object.values(tools)
+ *     });
+ *
+ *     return Response.json(response);
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/ai/cloudflare';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   integrations: [githubIntegration({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const tools = await getCloudflareTools(serverClient, { providerTokens });
+ *
+ *   // Use with Cloudflare AI
+ *   const ai = new Ai(env.AI);
+ *   const response = await ai.run('@cf/meta/llama-3-8b-instruct', {
+ *     messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ *     tools: Object.values(tools)
+ *   });
+ *
+ *   // Handle tool calls
+ *   if (response.tool_calls) {
+ *     for (const toolCall of response.tool_calls) {
+ *       await executeCloudflareToolCall(serverClient, toolCall, { providerTokens });
+ *     }
+ *   }
+ *
+ *   return Response.json(response);
+ * }
+ * ```
+ */
+export declare function getCloudflareTools(client: MCPClient<any>, options?: CloudflareToolsOptions): Promise<Record<string, CloudflareTool>>;
+//# sourceMappingURL=cloudflare.d.ts.map

package/dist/src/ai/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/ai/cloudflare.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjH;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ,CAAC;YACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;gBACzB,IAAI,EAAE,MAAM,CAAC;gBACb,WAAW,CAAC,EAAE,MAAM,CAAC;aACtB,CAAC,CAAC;YACH,QAAQ,EAAE,MAAM,EAAE,CAAC;SACpB,CAAC;KACH,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;CAAI;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,sBAAsB,GAChC,cAAc,CAahB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAShC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IACR,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;CAC7C,EACD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAezC"}

package/dist/src/ai/langchain.d.ts

@@ -0,0 +1,139 @@
+/**
+ * LangChain Integration
+ *
+ * Helper functions to convert MCP tools to LangChain DynamicStructuredTool format
+ */
+import { z } from "zod";
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * LangChain DynamicStructuredTool definition
+ * Compatible with @langchain/core/tools
+ */
+export interface LangChainTool {
+    name: string;
+    description: string;
+    schema: z.ZodType<any>;
+    func: (...args: any[]) => Promise<string>;
+}
+/**
+ * Options for converting MCP tools to LangChain format
+ */
+export interface LangChainToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to LangChain DynamicStructuredTool format
+ *
+ * @param mcpTool - The MCP tool definition
+ * @param client - The MCP client instance (used for executing the tool)
+ * @param options - Optional configuration including provider tokens
+ * @returns LangChain compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const langchainTool = convertMCPToolToLangChain(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToLangChain(mcpTool: MCPTool, client: MCPClient<any>, options?: LangChainToolsOptions): LangChainTool;
+/**
+ * Convert all enabled MCP tools to LangChain DynamicStructuredTool format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of LangChain compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToLangChain(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToLangChain(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToLangChain(client: MCPClient<any>, options?: LangChainToolsOptions): LangChainTool[];
+/**
+ * Get tools in a format compatible with LangChain
+ *
+ * Automatically connects the client if not already connected.
+ * Returns tool definitions that can be used with DynamicStructuredTool.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Array of tools ready to use with LangChain
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubIntegration } from 'integrate-sdk';
+ * import { getLangChainTools } from 'integrate-sdk/ai/langchain';
+ * import { DynamicStructuredTool } from '@langchain/core/tools';
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
+ *
+ * const client = createMCPClient({
+ *   integrations: [githubIntegration({ clientId: '...' })],
+ * });
+ *
+ * const toolConfigs = await getLangChainTools(client);
+ *
+ * // Create DynamicStructuredTools from configs
+ * const tools = toolConfigs.map(config =>
+ *   new DynamicStructuredTool(config)
+ * );
+ *
+ * const model = new ChatOpenAI({ temperature: 0 });
+ * const agent = await createOpenAIFunctionsAgent({
+ *   llm: model,
+ *   tools
+ * });
+ *
+ * const executor = new AgentExecutor({ agent, tools });
+ * const result = await executor.invoke({
+ *   input: "Create a GitHub issue"
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
+ * import { getLangChainTools } from 'integrate-sdk/ai/langchain';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   integrations: [githubIntegration({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const toolConfigs = await getLangChainTools(serverClient, { providerTokens });
+ *
+ *   // Create DynamicStructuredTools
+ *   const tools = toolConfigs.map(config =>
+ *     new DynamicStructuredTool(config)
+ *   );
+ *
+ *   const model = new ChatOpenAI({ temperature: 0 });
+ *   const agent = await createOpenAIFunctionsAgent({
+ *     llm: model,
+ *     tools
+ *   });
+ *
+ *   const executor = new AgentExecutor({ agent, tools });
+ *   const result = await executor.invoke({
+ *     input: "Create a GitHub issue"
+ *   });
+ *
+ *   return Response.json(result);
+ * }
+ * ```
+ */
+export declare function getLangChainTools(client: MCPClient<any>, options?: LangChainToolsOptions): Promise<LangChainTool[]>;
+//# sourceMappingURL=langchain.d.ts.map

package/dist/src/ai/langchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.ts","sourceRoot":"","sources":["../../../src/ai/langchain.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACvB,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,cAAc;CAAI;AAEjE;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAYf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,aAAa,EAAE,CAAC,CAe1B"}

package/dist/src/ai/llamaindex.d.ts

@@ -0,0 +1,125 @@
+/**
+ * LlamaIndex Integration
+ *
+ * Helper functions to convert MCP tools to LlamaIndex tool format
+ */
+import { z } from "zod";
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * LlamaIndex tool definition
+ * Compatible with llamaindex package
+ */
+export interface LlamaIndexTool {
+    name: string;
+    description: string;
+    parameters: z.ZodType<any>;
+    execute: (input: Record<string, unknown>) => Promise<string>;
+}
+/**
+ * Options for converting MCP tools to LlamaIndex format
+ */
+export interface LlamaIndexToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to LlamaIndex format
+ *
+ * @param mcpTool - The MCP tool definition
+ * @param client - The MCP client instance (used for executing the tool)
+ * @param options - Optional configuration including provider tokens
+ * @returns LlamaIndex compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const llamaIndexTool = convertMCPToolToLlamaIndex(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToLlamaIndex(mcpTool: MCPTool, client: MCPClient<any>, options?: LlamaIndexToolsOptions): LlamaIndexTool;
+/**
+ * Convert all enabled MCP tools to LlamaIndex format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of LlamaIndex compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToLlamaIndex(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToLlamaIndex(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToLlamaIndex(client: MCPClient<any>, options?: LlamaIndexToolsOptions): LlamaIndexTool[];
+/**
+ * Get tools in a format compatible with LlamaIndex
+ *
+ * Automatically connects the client if not already connected.
+ * Returns tool configurations that can be used with LlamaIndex's tool system.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Array of tools ready to use with LlamaIndex
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubIntegration } from 'integrate-sdk';
+ * import { getLlamaIndexTools } from 'integrate-sdk/ai/llamaindex';
+ * import { OpenAIAgent, tool } from 'llamaindex';
+ *
+ * const client = createMCPClient({
+ *   integrations: [githubIntegration({ clientId: '...' })],
+ * });
+ *
+ * const toolConfigs = await getLlamaIndexTools(client);
+ *
+ * // Create LlamaIndex tools
+ * const tools = toolConfigs.map(config =>
+ *   tool(config)
+ * );
+ *
+ * const agent = new OpenAIAgent({ tools });
+ * const response = await agent.chat({
+ *   message: "Create a GitHub issue"
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
+ * import { getLlamaIndexTools } from 'integrate-sdk/ai/llamaindex';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   integrations: [githubIntegration({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const toolConfigs = await getLlamaIndexTools(serverClient, { providerTokens });
+ *
+ *   // Create LlamaIndex tools
+ *   const tools = toolConfigs.map(config =>
+ *     tool(config)
+ *   );
+ *
+ *   const agent = new OpenAIAgent({ tools });
+ *   const response = await agent.chat({
+ *     message: "Create a GitHub issue"
+ *   });
+ *
+ *   return Response.json(response);
+ * }
+ * ```
+ */
+export declare function getLlamaIndexTools(client: MCPClient<any>, options?: LlamaIndexToolsOptions): Promise<LlamaIndexTool[]>;
+//# sourceMappingURL=llamaindex.d.ts.map

package/dist/src/ai/llamaindex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llamaindex.d.ts","sourceRoot":"","sources":["../../../src/ai/llamaindex.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC9D;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;CAAI;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,CAUhB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,EAAE,CAGlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,cAAc,EAAE,CAAC,CAe3B"}