integrate-sdk 0.7.40 → 0.7.42

package/dist/ai/google.d.ts

@@ -6,28 +6,11 @@
 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>;
-}
+import { Type } from "@google/genai";
+import type { Schema, FunctionDeclaration, FunctionCall } from "@google/genai";
+export type GoogleTool = FunctionDeclaration;
+export type GoogleFunctionCall = FunctionCall;
+export type { Schema, Type };
 /**
  * Options for converting MCP tools to Google GenAI format
  */
@@ -83,6 +66,39 @@ export declare function convertMCPToolsToGoogle(client: MCPClient<any>, options?
  * ```
  */
 export declare function executeGoogleFunctionCall(client: MCPClient<any>, functionCall: GoogleFunctionCall, options?: GoogleToolsOptions): Promise<string>;
+/**
+ * Execute multiple function calls from Google GenAI response
+ *
+ * This function handles the transformation from Google's function call format
+ * to the format expected by the SDK, then executes each call.
+ *
+ * @param client - The MCP client instance
+ * @param functionCalls - Array of function calls from Google GenAI response
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of execution results
+ *
+ * @example
+ * ```typescript
+ * // In your API route
+ * const response = await ai.models.generateContent({
+ *   model: 'gemini-2.0-flash-001',
+ *   contents: messages,
+ *   config: {
+ *     tools: [{ functionDeclarations: await getGoogleTools(serverClient) }],
+ *   },
+ * });
+ *
+ * if (response.functionCalls && response.functionCalls.length > 0) {
+ *   const results = await executeGoogleFunctionCalls(
+ *     serverClient,
+ *     response.functionCalls,
+ *     { providerTokens }
+ *   );
+ *   return Response.json(results);
+ * }
+ * ```
+ */
+export declare function executeGoogleFunctionCalls(client: MCPClient<any>, functionCalls: GoogleFunctionCall[] | undefined | null, options?: GoogleToolsOptions): Promise<string[]>;
 /**
  * Get tools in a format compatible with Google GenAI
  *
@@ -97,21 +113,21 @@ export declare function executeGoogleFunctionCall(client: MCPClient<any>, functi
  * // Client-side usage
  * import { createMCPClient, githubIntegration } from 'integrate-sdk';
  * import { getGoogleTools } from 'integrate-sdk/ai/google';
- * import { GoogleGenerativeAI } from '@google/generative-ai';
+ * import { genai } from '@google/genai';
  *
  * const client = createMCPClient({
  *   integrations: [githubIntegration({ clientId: '...' })],
  * });
  *
  * const tools = await getGoogleTools(client);
- * const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
- * const model = genAI.getGenerativeModel({
- *   model: 'gemini-pro',
- *   tools: [{ functionDeclarations: tools }]
- * });
+ * const ai = genai({ apiKey: 'YOUR_API_KEY' });
  *
- * const result = await model.generateContent({
- *   contents: [{ role: 'user', parts: [{ text: 'Create a GitHub issue' }] }]
+ * const response = await ai.models.generateContent({
+ *   model: 'gemini-2.0-flash-001',
+ *   contents: messages,
+ *   config: {
+ *     tools: [{ functionDeclarations: tools }]
+ *   }
  * });
  * ```
  *
@@ -119,7 +135,8 @@ export declare function executeGoogleFunctionCall(client: MCPClient<any>, functi
  * ```typescript
  * // Server-side usage with tokens from client
  * import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
- * import { getGoogleTools, executeGoogleFunctionCall } from 'integrate-sdk/ai/google';
+ * import { getGoogleTools, executeGoogleFunctionCalls } from 'integrate-sdk/ai/google';
+ * import { genai } from '@google/genai';
  *
  * const { client: serverClient } = createMCPServer({
  *   integrations: [githubIntegration({
@@ -133,25 +150,26 @@ export declare function executeGoogleFunctionCall(client: MCPClient<any>, functi
  *   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' }] }]
+ *   const ai = genai({ apiKey: process.env.GOOGLE_API_KEY });
+ *   const response = await ai.models.generateContent({
+ *     model: 'gemini-2.0-flash-001',
+ *     contents: messages,
+ *     config: {
+ *       tools: [{ functionDeclarations: tools }]
+ *     }
  *   });
  *
  *   // Handle function calls if any
- *   const functionCalls = result.response.functionCalls();
- *   if (functionCalls) {
- *     for (const call of functionCalls) {
- *       await executeGoogleFunctionCall(serverClient, call, { providerTokens });
- *     }
+ *   if (response.functionCalls && response.functionCalls.length > 0) {
+ *     const results = await executeGoogleFunctionCalls(
+ *       serverClient,
+ *       response.functionCalls,
+ *       { providerTokens }
+ *     );
+ *     return Response.json(results);
  *   }
  *
- *   return Response.json(result.response);
+ *   return Response.json(response);
  * }
  * ```
  */

package/dist/ai/google.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjH;;;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,CAevB"}
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjH,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACb,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AA4D9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,UAAU,CAoBZ;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,CAejB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,aAAa,EAAE,kBAAkB,EAAE,GAAG,SAAS,GAAG,IAAI,EACtD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAevB"}

package/dist/ai/google.js

@@ -4203,16 +4203,62 @@ async function ensureClientConnected(client) {
 }
 
 // google.ts
+import { Type } from "@google/genai";
+function convertJsonSchemaTypeToGoogleType(type) {
+  const typeMap = {
+    string: Type.STRING,
+    number: Type.NUMBER,
+    integer: Type.INTEGER,
+    boolean: Type.BOOLEAN,
+    array: Type.ARRAY,
+    object: Type.OBJECT
+  };
+  return typeMap[type.toLowerCase()] || Type.STRING;
+}
+function convertPropertiesToSchema(properties) {
+  const result = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (!value || typeof value !== "object") {
+      result[key] = value;
+      continue;
+    }
+    const schema = {
+      description: value.description,
+      enum: value.enum
+    };
+    if (value.type) {
+      schema.type = convertJsonSchemaTypeToGoogleType(value.type);
+    }
+    if (value.items) {
+      schema.items = convertPropertiesToSchema({ items: value.items }).items;
+    }
+    if (value.properties) {
+      schema.properties = convertPropertiesToSchema(value.properties);
+    }
+    for (const [k, v] of Object.entries(value)) {
+      if (!["type", "description", "enum", "items", "properties"].includes(k)) {
+        schema[k] = v;
+      }
+    }
+    result[key] = schema;
+  }
+  return result;
+}
 function convertMCPToolToGoogle(mcpTool, _client, _options) {
+  const properties = mcpTool.inputSchema?.properties || {};
+  const convertedProperties = convertPropertiesToSchema(properties);
+  const parameters = {
+    type: Type.OBJECT,
+    description: mcpTool.description || "",
+    properties: convertedProperties
+  };
+  if (mcpTool.inputSchema?.required && mcpTool.inputSchema.required.length > 0) {
+    parameters.required = mcpTool.inputSchema.required;
+  }
   return {
     name: mcpTool.name,
     description: mcpTool.description || `Execute ${mcpTool.name}`,
-    parameters: {
-      type: "object",
-      description: mcpTool.description || "",
-      properties: mcpTool.inputSchema?.properties || {},
-      required: mcpTool.inputSchema?.required || []
-    }
+    parameters
   };
 }
 function convertMCPToolsToGoogle(client, options) {
@@ -4220,9 +4266,20 @@ function convertMCPToolsToGoogle(client, options) {
   return mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options));
 }
 async function executeGoogleFunctionCall(client, functionCall, options) {
-  const result = await executeToolWithToken(client, functionCall.name, functionCall.args, options);
+  if (!functionCall?.name) {
+    throw new Error("Function call must have a name");
+  }
+  const args = functionCall.args || {};
+  const result = await executeToolWithToken(client, functionCall.name, args, options);
   return JSON.stringify(result);
 }
+async function executeGoogleFunctionCalls(client, functionCalls, options) {
+  if (!functionCalls || functionCalls.length === 0) {
+    return [];
+  }
+  const results = await Promise.all(functionCalls.map((call) => executeGoogleFunctionCall(client, call, options)));
+  return results;
+}
 async function getGoogleTools(client, options) {
   await ensureClientConnected(client);
   let providerTokens = options?.providerTokens;
@@ -4236,6 +4293,7 @@ async function getGoogleTools(client, options) {
 }
 export {
   getGoogleTools,
+  executeGoogleFunctionCalls,
   executeGoogleFunctionCall,
   convertMCPToolsToGoogle,
   convertMCPToolToGoogle

package/dist/ai/index.js

@@ -4317,16 +4317,62 @@ async function getCloudflareTools(client, options) {
 }
 
 // google.ts
+import { Type } from "@google/genai";
+function convertJsonSchemaTypeToGoogleType(type) {
+  const typeMap = {
+    string: Type.STRING,
+    number: Type.NUMBER,
+    integer: Type.INTEGER,
+    boolean: Type.BOOLEAN,
+    array: Type.ARRAY,
+    object: Type.OBJECT
+  };
+  return typeMap[type.toLowerCase()] || Type.STRING;
+}
+function convertPropertiesToSchema(properties) {
+  const result = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (!value || typeof value !== "object") {
+      result[key] = value;
+      continue;
+    }
+    const schema = {
+      description: value.description,
+      enum: value.enum
+    };
+    if (value.type) {
+      schema.type = convertJsonSchemaTypeToGoogleType(value.type);
+    }
+    if (value.items) {
+      schema.items = convertPropertiesToSchema({ items: value.items }).items;
+    }
+    if (value.properties) {
+      schema.properties = convertPropertiesToSchema(value.properties);
+    }
+    for (const [k, v] of Object.entries(value)) {
+      if (!["type", "description", "enum", "items", "properties"].includes(k)) {
+        schema[k] = v;
+      }
+    }
+    result[key] = schema;
+  }
+  return result;
+}
 function convertMCPToolToGoogle(mcpTool, _client, _options) {
+  const properties = mcpTool.inputSchema?.properties || {};
+  const convertedProperties = convertPropertiesToSchema(properties);
+  const parameters = {
+    type: Type.OBJECT,
+    description: mcpTool.description || "",
+    properties: convertedProperties
+  };
+  if (mcpTool.inputSchema?.required && mcpTool.inputSchema.required.length > 0) {
+    parameters.required = mcpTool.inputSchema.required;
+  }
   return {
     name: mcpTool.name,
     description: mcpTool.description || `Execute ${mcpTool.name}`,
-    parameters: {
-      type: "object",
-      description: mcpTool.description || "",
-      properties: mcpTool.inputSchema?.properties || {},
-      required: mcpTool.inputSchema?.required || []
-    }
+    parameters
   };
 }
 function convertMCPToolsToGoogle(client, options) {
@@ -4334,9 +4380,20 @@ function convertMCPToolsToGoogle(client, options) {
   return mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options));
 }
 async function executeGoogleFunctionCall(client, functionCall, options) {
-  const result = await executeToolWithToken(client, functionCall.name, functionCall.args, options);
+  if (!functionCall?.name) {
+    throw new Error("Function call must have a name");
+  }
+  const args = functionCall.args || {};
+  const result = await executeToolWithToken(client, functionCall.name, args, options);
   return JSON.stringify(result);
 }
+async function executeGoogleFunctionCalls(client, functionCalls, options) {
+  if (!functionCalls || functionCalls.length === 0) {
+    return [];
+  }
+  const results = await Promise.all(functionCalls.map((call) => executeGoogleFunctionCall(client, call, options)));
+  return results;
+}
 async function getGoogleTools(client, options) {
   await ensureClientConnected(client);
   let providerTokens = options?.providerTokens;
@@ -4616,6 +4673,7 @@ export {
   getAITools,
   executeToolWithToken,
   executeOpenAIToolCall,
+  executeGoogleFunctionCalls,
   executeGoogleFunctionCall,
   executeCloudflareToolCall,
   executeAnthropicToolCall,

package/dist/server.js

@@ -6675,16 +6675,62 @@ async function handleAnthropicMessage(client, message, options) {
   ];
 }
 // src/ai/google.ts
+import { Type } from "@google/genai";
+function convertJsonSchemaTypeToGoogleType(type) {
+  const typeMap = {
+    string: Type.STRING,
+    number: Type.NUMBER,
+    integer: Type.INTEGER,
+    boolean: Type.BOOLEAN,
+    array: Type.ARRAY,
+    object: Type.OBJECT
+  };
+  return typeMap[type.toLowerCase()] || Type.STRING;
+}
+function convertPropertiesToSchema(properties) {
+  const result = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (!value || typeof value !== "object") {
+      result[key] = value;
+      continue;
+    }
+    const schema = {
+      description: value.description,
+      enum: value.enum
+    };
+    if (value.type) {
+      schema.type = convertJsonSchemaTypeToGoogleType(value.type);
+    }
+    if (value.items) {
+      schema.items = convertPropertiesToSchema({ items: value.items }).items;
+    }
+    if (value.properties) {
+      schema.properties = convertPropertiesToSchema(value.properties);
+    }
+    for (const [k, v] of Object.entries(value)) {
+      if (!["type", "description", "enum", "items", "properties"].includes(k)) {
+        schema[k] = v;
+      }
+    }
+    result[key] = schema;
+  }
+  return result;
+}
 function convertMCPToolToGoogle(mcpTool, _client, _options) {
+  const properties = mcpTool.inputSchema?.properties || {};
+  const convertedProperties = convertPropertiesToSchema(properties);
+  const parameters = {
+    type: Type.OBJECT,
+    description: mcpTool.description || "",
+    properties: convertedProperties
+  };
+  if (mcpTool.inputSchema?.required && mcpTool.inputSchema.required.length > 0) {
+    parameters.required = mcpTool.inputSchema.required;
+  }
   return {
     name: mcpTool.name,
     description: mcpTool.description || `Execute ${mcpTool.name}`,
-    parameters: {
-      type: "object",
-      description: mcpTool.description || "",
-      properties: mcpTool.inputSchema?.properties || {},
-      required: mcpTool.inputSchema?.required || []
-    }
+    parameters
   };
 }
 function convertMCPToolsToGoogle(client, options) {
@@ -6692,9 +6738,20 @@ function convertMCPToolsToGoogle(client, options) {
   return mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options));
 }
 async function executeGoogleFunctionCall(client, functionCall, options) {
-  const result = await executeToolWithToken(client, functionCall.name, functionCall.args, options);
+  if (!functionCall?.name) {
+    throw new Error("Function call must have a name");
+  }
+  const args = functionCall.args || {};
+  const result = await executeToolWithToken(client, functionCall.name, args, options);
   return JSON.stringify(result);
 }
+async function executeGoogleFunctionCalls(client, functionCalls, options) {
+  if (!functionCalls || functionCalls.length === 0) {
+    return [];
+  }
+  const results = await Promise.all(functionCalls.map((call) => executeGoogleFunctionCall(client, call, options)));
+  return results;
+}
 async function getGoogleTools(client, options) {
   await ensureClientConnected(client);
   let providerTokens = options?.providerTokens;
@@ -7047,6 +7104,7 @@ export {
   fromNodeHeaders,
   executeToolWithToken,
   executeOpenAIToolCall,
+  executeGoogleFunctionCalls,
   executeGoogleFunctionCall,
   executeCloudflareToolCall,
   executeAnthropicToolCall,

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

@@ -6,28 +6,11 @@
 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>;
-}
+import { Type } from "@google/genai";
+import type { Schema, FunctionDeclaration, FunctionCall } from "@google/genai";
+export type GoogleTool = FunctionDeclaration;
+export type GoogleFunctionCall = FunctionCall;
+export type { Schema, Type };
 /**
  * Options for converting MCP tools to Google GenAI format
  */
@@ -83,6 +66,39 @@ export declare function convertMCPToolsToGoogle(client: MCPClient<any>, options?
  * ```
  */
 export declare function executeGoogleFunctionCall(client: MCPClient<any>, functionCall: GoogleFunctionCall, options?: GoogleToolsOptions): Promise<string>;
+/**
+ * Execute multiple function calls from Google GenAI response
+ *
+ * This function handles the transformation from Google's function call format
+ * to the format expected by the SDK, then executes each call.
+ *
+ * @param client - The MCP client instance
+ * @param functionCalls - Array of function calls from Google GenAI response
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of execution results
+ *
+ * @example
+ * ```typescript
+ * // In your API route
+ * const response = await ai.models.generateContent({
+ *   model: 'gemini-2.0-flash-001',
+ *   contents: messages,
+ *   config: {
+ *     tools: [{ functionDeclarations: await getGoogleTools(serverClient) }],
+ *   },
+ * });
+ *
+ * if (response.functionCalls && response.functionCalls.length > 0) {
+ *   const results = await executeGoogleFunctionCalls(
+ *     serverClient,
+ *     response.functionCalls,
+ *     { providerTokens }
+ *   );
+ *   return Response.json(results);
+ * }
+ * ```
+ */
+export declare function executeGoogleFunctionCalls(client: MCPClient<any>, functionCalls: GoogleFunctionCall[] | undefined | null, options?: GoogleToolsOptions): Promise<string[]>;
 /**
  * Get tools in a format compatible with Google GenAI
  *
@@ -97,21 +113,21 @@ export declare function executeGoogleFunctionCall(client: MCPClient<any>, functi
  * // Client-side usage
  * import { createMCPClient, githubIntegration } from 'integrate-sdk';
  * import { getGoogleTools } from 'integrate-sdk/ai/google';
- * import { GoogleGenerativeAI } from '@google/generative-ai';
+ * import { genai } from '@google/genai';
  *
  * const client = createMCPClient({
  *   integrations: [githubIntegration({ clientId: '...' })],
  * });
  *
  * const tools = await getGoogleTools(client);
- * const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
- * const model = genAI.getGenerativeModel({
- *   model: 'gemini-pro',
- *   tools: [{ functionDeclarations: tools }]
- * });
+ * const ai = genai({ apiKey: 'YOUR_API_KEY' });
  *
- * const result = await model.generateContent({
- *   contents: [{ role: 'user', parts: [{ text: 'Create a GitHub issue' }] }]
+ * const response = await ai.models.generateContent({
+ *   model: 'gemini-2.0-flash-001',
+ *   contents: messages,
+ *   config: {
+ *     tools: [{ functionDeclarations: tools }]
+ *   }
  * });
  * ```
  *
@@ -119,7 +135,8 @@ export declare function executeGoogleFunctionCall(client: MCPClient<any>, functi
  * ```typescript
  * // Server-side usage with tokens from client
  * import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
- * import { getGoogleTools, executeGoogleFunctionCall } from 'integrate-sdk/ai/google';
+ * import { getGoogleTools, executeGoogleFunctionCalls } from 'integrate-sdk/ai/google';
+ * import { genai } from '@google/genai';
  *
  * const { client: serverClient } = createMCPServer({
  *   integrations: [githubIntegration({
@@ -133,25 +150,26 @@ export declare function executeGoogleFunctionCall(client: MCPClient<any>, functi
  *   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' }] }]
+ *   const ai = genai({ apiKey: process.env.GOOGLE_API_KEY });
+ *   const response = await ai.models.generateContent({
+ *     model: 'gemini-2.0-flash-001',
+ *     contents: messages,
+ *     config: {
+ *       tools: [{ functionDeclarations: tools }]
+ *     }
  *   });
  *
  *   // Handle function calls if any
- *   const functionCalls = result.response.functionCalls();
- *   if (functionCalls) {
- *     for (const call of functionCalls) {
- *       await executeGoogleFunctionCall(serverClient, call, { providerTokens });
- *     }
+ *   if (response.functionCalls && response.functionCalls.length > 0) {
+ *     const results = await executeGoogleFunctionCalls(
+ *       serverClient,
+ *       response.functionCalls,
+ *       { providerTokens }
+ *     );
+ *     return Response.json(results);
  *   }
  *
- *   return Response.json(result.response);
+ *   return Response.json(response);
  * }
  * ```
  */

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

@@ -1 +1 @@
-{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjH;;;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,CAevB"}
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/ai/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,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjH,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACb,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AA4D9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,UAAU,CAoBZ;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,CAejB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,aAAa,EAAE,kBAAkB,EAAE,GAAG,SAAS,GAAG,IAAI,EACtD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAevB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integrate-sdk",
-  "version": "0.7.40",
+  "version": "0.7.42",
   "description": "Type-safe 3rd party integration SDK for the Integrate MCP server",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,9 +44,9 @@
     "prep": "bun run type-check && bun run build",
     "build": "bun run build:client && bun run build:server && bun run build:adapters && bun run build:ai && bun run build:types && bun run build:copy-types",
     "build:client": "bun build index.ts react.ts --outdir dist --target browser --format esm --external react",
-    "build:server": "bun build server.ts oauth.ts --outdir dist --target node --format esm",
+    "build:server": "bun build server.ts oauth.ts --outdir dist --target node --format esm --external @google/genai --external @anthropic-ai/sdk --external openai --external ai --external @langchain/core --external llamaindex --external @mastra/core --external @cloudflare/workers-types --external @openai/agents",
     "build:adapters": "cd src/adapters && bun build *.ts --outdir ../../dist/adapters --target node --format esm && cd ../..",
-    "build:ai": "cd src/ai && bun build *.ts --outdir ../../dist/ai --target node --format esm && cd ../..",
+    "build:ai": "cd src/ai && bun build *.ts --outdir ../../dist/ai --target node --format esm --external @google/genai --external @anthropic-ai/sdk --external openai --external ai --external @langchain/core --external llamaindex --external @mastra/core --external @cloudflare/workers-types --external @openai/agents && cd ../..",
     "build:types": "tsc --emitDeclarationOnly --declaration --declarationMap",
     "build:copy-types": "cp dist/src/ai/*.d.ts dist/ai/ && cp dist/src/ai/*.d.ts.map dist/ai/ && cp dist/src/adapters/*.d.ts dist/adapters/ && cp dist/src/adapters/*.d.ts.map dist/adapters/",
     "dev": "bun --watch src/index.ts",
@@ -72,6 +72,7 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.32.1",
+    "@google/genai": "^1.29.0",
     "@types/bun": "latest",
     "@types/react": "^18.3.0",
     "openai": "^4.77.3",
@@ -86,7 +87,7 @@
     "openai": ">=4.0.0",
     "@openai/agents": ">=0.1.0",
     "@anthropic-ai/sdk": ">=0.20.0",
-    "@google/generative-ai": ">=0.1.0",
+    "@google/genai": "",
     "@cloudflare/workers-types": ">=4.0.0",
     "@langchain/core": ">=0.1.0",
     "llamaindex": ">=0.1.0",
@@ -108,7 +109,7 @@
     "@anthropic-ai/sdk": {
       "optional": true
     },
-    "@google/generative-ai": {
+    "@google/genai": {
       "optional": true
     },
     "@cloudflare/workers-types": {