integrate-sdk 0.6.6 → 0.6.7

package/dist/index.js

@@ -6152,7 +6152,7 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// src/integrations/vercel-ai.ts
+// src/integrations/utils.ts
 function getProviderForTool(client, toolName) {
   return client.getProviderForTool?.(toolName);
 }
@@ -6266,33 +6266,43 @@ function jsonSchemaToZod(schema) {
   }
   return exports_external.object({});
 }
+async function executeToolWithToken(client, toolName, args, options) {
+  if (options?.providerTokens) {
+    const provider = getProviderForTool(client, toolName);
+    if (provider && options.providerTokens[provider]) {
+      const transport = client.transport;
+      if (transport && typeof transport.setHeader === "function") {
+        const previousAuthHeader = transport.headers?.["Authorization"];
+        try {
+          transport.setHeader("Authorization", `Bearer ${options.providerTokens[provider]}`);
+          const result2 = await client._callToolByName(toolName, args);
+          return result2;
+        } finally {
+          if (previousAuthHeader) {
+            transport.setHeader("Authorization", previousAuthHeader);
+          } else if (transport.removeHeader) {
+            transport.removeHeader("Authorization");
+          }
+        }
+      }
+    }
+  }
+  const result = await client._callToolByName(toolName, args);
+  return result;
+}
+async function ensureClientConnected(client) {
+  if (!client.isConnected()) {
+    await client.connect();
+  }
+}
+
+// src/integrations/vercel-ai.ts
 function convertMCPToolToVercelAI(mcpTool, client, options) {
   return {
     description: mcpTool.description || `Execute ${mcpTool.name}`,
     inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
     execute: async (args) => {
-      if (options?.providerTokens) {
-        const provider = getProviderForTool(client, mcpTool.name);
-        if (provider && options.providerTokens[provider]) {
-          const transport = client.transport;
-          if (transport && typeof transport.setHeader === "function") {
-            const previousAuthHeader = transport.headers?.["Authorization"];
-            try {
-              transport.setHeader("Authorization", `Bearer ${options.providerTokens[provider]}`);
-              const result2 = await client._callToolByName(mcpTool.name, args);
-              return result2;
-            } finally {
-              if (previousAuthHeader) {
-                transport.setHeader("Authorization", previousAuthHeader);
-              } else if (transport.removeHeader) {
-                transport.removeHeader("Authorization");
-              }
-            }
-          }
-        }
-      }
-      const result = await client._callToolByName(mcpTool.name, args);
-      return result;
+      return await executeToolWithToken(client, mcpTool.name, args, options);
     }
   };
 }
@@ -6305,9 +6315,7 @@ function convertMCPToolsToVercelAI(client, options) {
   return vercelTools;
 }
 async function getVercelAITools(client, options) {
-  if (!client.isConnected()) {
-    await client.connect();
-  }
+  await ensureClientConnected(client);
   return convertMCPToolsToVercelAI(client, options);
 }
 export {

package/dist/src/integrations/anthropic.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Anthropic Claude Integration
+ *
+ * Helper functions to convert MCP tools to Anthropic Claude API format
+ */
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Anthropic tool definition
+ * Compatible with Anthropic's Claude API
+ */
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Options for converting MCP tools to Anthropic format
+ */
+export interface AnthropicToolsOptions extends AIToolsOptions {
+}
+/**
+ * Anthropic tool use block from message content
+ */
+export interface AnthropicToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Anthropic tool result block for responses
+ */
+export interface AnthropicToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+}
+/**
+ * Convert a single MCP tool to Anthropic Claude API 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 Anthropic compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const anthropicTool = convertMCPToolToAnthropic(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToAnthropic(mcpTool: MCPTool, _client: MCPClient<any>, _options?: AnthropicToolsOptions): AnthropicTool;
+/**
+ * Convert all enabled MCP tools to Anthropic Claude API format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of Anthropic compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToAnthropic(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToAnthropic(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToAnthropic(client: MCPClient<any>, options?: AnthropicToolsOptions): AnthropicTool[];
+/**
+ * Execute a tool call from Anthropic's response
+ *
+ * @param client - The MCP client instance
+ * @param toolUse - The tool use block from Anthropic response
+ * @param options - Optional configuration including provider tokens
+ * @returns Tool execution result as JSON string
+ *
+ * @example
+ * ```typescript
+ * const result = await executeAnthropicToolCall(client, {
+ *   type: 'tool_use',
+ *   id: 'toolu_123',
+ *   name: 'github_create_issue',
+ *   input: { owner: 'user', repo: 'repo', title: 'Bug' }
+ * }, { providerTokens });
+ * ```
+ */
+export declare function executeAnthropicToolCall(client: MCPClient<any>, toolUse: AnthropicToolUseBlock, options?: AnthropicToolsOptions): Promise<string>;
+/**
+ * Handle all tool calls from Anthropic's message response
+ * Executes all tool use blocks and returns tool result blocks
+ *
+ * @param client - The MCP client instance
+ * @param messageContent - Array of content blocks from Anthropic message
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of tool result blocks ready to send back to Claude
+ *
+ * @example
+ * ```typescript
+ * const response = await anthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   tools,
+ *   messages: [{ role: 'user', content: 'Create a GitHub issue' }]
+ * });
+ *
+ * // Handle tool calls
+ * const toolResults = await handleAnthropicToolCalls(
+ *   client,
+ *   response.content,
+ *   { providerTokens }
+ * );
+ *
+ * // Continue conversation with tool results
+ * const finalResponse = await anthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   tools,
+ *   messages: [
+ *     { role: 'user', content: 'Create a GitHub issue' },
+ *     { role: 'assistant', content: response.content },
+ *     { role: 'user', content: toolResults }
+ *   ]
+ * });
+ * ```
+ */
+export declare function handleAnthropicToolCalls(client: MCPClient<any>, messageContent: Array<{
+    type: string;
+    [key: string]: any;
+}>, options?: AnthropicToolsOptions): Promise<AnthropicToolResultBlock[]>;
+/**
+ * Get tools in a format compatible with Anthropic Claude API
+ *
+ * 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 Array of tools ready to pass to Claude API
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getAnthropicTools } from 'integrate-sdk/integrations/anthropic';
+ * import Anthropic from '@anthropic-ai/sdk';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const tools = await getAnthropicTools(client);
+ * const anthropic = new Anthropic({ apiKey: '...' });
+ *
+ * const message = await anthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   tools,
+ *   messages: [{ role: 'user', content: 'Create a GitHub issue' }]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getAnthropicTools, handleAnthropicToolCalls } from 'integrate-sdk/integrations/anthropic';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     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 getAnthropicTools(serverClient, { providerTokens });
+ *
+ *   const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+ *   const message = await anthropic.messages.create({
+ *     model: 'claude-3-5-sonnet-20241022',
+ *     max_tokens: 1024,
+ *     tools,
+ *     messages: [{ role: 'user', content: 'Create a GitHub issue' }]
+ *   });
+ *
+ *   // Handle any tool calls
+ *   const toolResults = await handleAnthropicToolCalls(
+ *     serverClient,
+ *     message.content,
+ *     { providerTokens }
+ *   );
+ *
+ *   return Response.json({ message, toolResults });
+ * }
+ * ```
+ */
+export declare function getAnthropicTools(client: MCPClient<any>, options?: AnthropicToolsOptions): Promise<AnthropicTool[]>;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/src/integrations/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/integrations/anthropic.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,EAA+C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,cAAc;CAAI;AAEjE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,qBAAqB,GAC/B,aAAa,CAUf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAGjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,cAAc,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAC,EAC1D,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAkCrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,aAAa,EAAE,CAAC,CAG1B"}

package/dist/src/integrations/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, githubPlugin } from 'integrate-sdk';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/integrations/cloudflare';
+ *
+ * export default {
+ *   async fetch(request: Request, env: Env): Promise<Response> {
+ *     const client = createMCPClient({
+ *       plugins: [githubPlugin({ 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, githubPlugin } from 'integrate-sdk/server';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/integrations/cloudflare';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     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/integrations/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/integrations/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,EAA+C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9F;;;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,CAGzC"}

package/dist/src/integrations/google.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Google GenAI Integration
+ *
+ * Helper functions to convert MCP tools to Google GenAI format
+ */
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Google GenAI function declaration
+ * Compatible with @google/genai SDK
+ */
+export interface GoogleTool {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        description?: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Google GenAI function call
+ */
+export interface GoogleFunctionCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+/**
+ * Options for converting MCP tools to Google GenAI format
+ */
+export interface GoogleToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to Google GenAI 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 Google GenAI compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const googleTool = convertMCPToolToGoogle(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToGoogle(mcpTool: MCPTool, _client: MCPClient<any>, _options?: GoogleToolsOptions): GoogleTool;
+/**
+ * Convert all enabled MCP tools to Google GenAI format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of Google GenAI compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToGoogle(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToGoogle(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToGoogle(client: MCPClient<any>, options?: GoogleToolsOptions): GoogleTool[];
+/**
+ * Execute a function call from Google GenAI
+ *
+ * @param client - The MCP client instance
+ * @param functionCall - The function call from Google GenAI response
+ * @param options - Optional configuration including provider tokens
+ * @returns Tool execution result as JSON string
+ *
+ * @example
+ * ```typescript
+ * const result = await executeGoogleFunctionCall(client, {
+ *   name: 'github_create_issue',
+ *   args: { owner: 'user', repo: 'repo', title: 'Bug' }
+ * }, { providerTokens });
+ * ```
+ */
+export declare function executeGoogleFunctionCall(client: MCPClient<any>, functionCall: GoogleFunctionCall, options?: GoogleToolsOptions): Promise<string>;
+/**
+ * Get tools in a format compatible with Google GenAI
+ *
+ * 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 Array of tools ready to use with Google GenAI
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getGoogleTools } from 'integrate-sdk/integrations/google';
+ * import { GoogleGenerativeAI } from '@google/generative-ai';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const tools = await getGoogleTools(client);
+ * const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
+ * const model = genAI.getGenerativeModel({
+ *   model: 'gemini-pro',
+ *   tools: [{ functionDeclarations: tools }]
+ * });
+ *
+ * const result = await model.generateContent({
+ *   contents: [{ role: 'user', parts: [{ text: 'Create a GitHub issue' }] }]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getGoogleTools, executeGoogleFunctionCall } from 'integrate-sdk/integrations/google';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     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 getGoogleTools(serverClient, { providerTokens });
+ *
+ *   const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
+ *   const model = genAI.getGenerativeModel({
+ *     model: 'gemini-pro',
+ *     tools: [{ functionDeclarations: tools }]
+ *   });
+ *
+ *   const result = await model.generateContent({
+ *     contents: [{ role: 'user', parts: [{ text: 'Create a GitHub issue' }] }]
+ *   });
+ *
+ *   // Handle function calls if any
+ *   const functionCalls = result.response.functionCalls();
+ *   if (functionCalls) {
+ *     for (const call of functionCalls) {
+ *       await executeGoogleFunctionCall(serverClient, call, { providerTokens });
+ *     }
+ *   }
+ *
+ *   return Response.json(result.response);
+ * }
+ * ```
+ */
+export declare function getGoogleTools(client: MCPClient<any>, options?: GoogleToolsOptions): Promise<GoogleTool[]>;
+//# sourceMappingURL=google.d.ts.map

package/dist/src/integrations/google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/integrations/google.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,EAA+C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE;QACV,IAAI,EAAE,QAAQ,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AAE9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,UAAU,CAWZ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,EAAE,CAGd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAGvB"}