integrate-sdk 0.7.44 → 0.7.46

package/dist/adapters/index.js

@@ -1226,10 +1226,10 @@ class OAuthManager {
     this.providerTokens.delete(provider);
     this.clearProviderToken(provider);
   }
-  async getProviderToken(provider) {
+  async getProviderToken(provider, context) {
     if (this.getTokenCallback) {
       try {
-        const tokenData = await this.getTokenCallback(provider);
+        const tokenData = await this.getTokenCallback(provider, context);
         if (tokenData) {
           this.providerTokens.set(provider, tokenData);
         }
@@ -1244,9 +1244,9 @@ class OAuthManager {
   getAllProviderTokens() {
     return new Map(this.providerTokens);
   }
-  async setProviderToken(provider, tokenData) {
+  async setProviderToken(provider, tokenData, context) {
     this.providerTokens.set(provider, tokenData);
-    await this.saveProviderToken(provider, tokenData);
+    await this.saveProviderToken(provider, tokenData, context);
   }
   clearProviderToken(provider) {
     this.providerTokens.delete(provider);
@@ -1289,10 +1289,10 @@ class OAuthManager {
       }
     }
   }
-  async saveProviderToken(provider, tokenData) {
+  async saveProviderToken(provider, tokenData, context) {
     if (this.setTokenCallback) {
       try {
-        await this.setTokenCallback(provider, tokenData);
+        await this.setTokenCallback(provider, tokenData, context);
       } catch (error) {
         console.error(`Failed to save token for ${provider} via callback:`, error);
         throw error;
@@ -1579,9 +1579,9 @@ class MCPClientBase {
     }
     return new Proxy({}, {
       get: (_target, methodName) => {
-        return async (args) => {
+        return async (args, options) => {
           const toolName = methodToToolName(methodName, integrationId);
-          return await this.callToolWithRetry(toolName, args, 0);
+          return await this.callToolWithRetry(toolName, args, 0, options);
         };
       }
     });
@@ -1589,17 +1589,17 @@ class MCPClientBase {
   createServerProxy() {
     return new Proxy({}, {
       get: (_target, methodName) => {
-        return async (args) => {
+        return async (args, options) => {
           const toolName = methodToToolName(methodName, "");
           const finalToolName = toolName.startsWith("_") ? toolName.substring(1) : toolName;
-          return await this.callServerToolInternal(finalToolName, args);
+          return await this.callServerToolInternal(finalToolName, args, options);
         };
       }
     });
   }
-  async callServerToolInternal(name, args) {
+  async callServerToolInternal(name, args, options) {
     try {
-      const response = await this.callToolThroughHandler(name, args);
+      const response = await this.callToolThroughHandler(name, args, undefined, options);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
@@ -1648,8 +1648,8 @@ class MCPClientBase {
     const enabledTools = response.tools.filter((tool) => this.enabledToolNames.has(tool.name));
     console.log(`Discovered ${response.tools.length} tools, ${enabledTools.length} enabled by integrations`);
   }
-  async _callToolByName(name, args) {
-    return await this.callToolWithRetry(name, args, 0);
+  async _callToolByName(name, args, options) {
+    return await this.callToolWithRetry(name, args, 0, options);
   }
   async callServerTool(name, args) {
     try {
@@ -1660,12 +1660,12 @@ class MCPClientBase {
       throw parsedError;
     }
   }
-  async callToolThroughHandler(name, args, provider) {
+  async callToolThroughHandler(name, args, provider, options) {
     const transportHeaders = this.transport.headers || {};
     const hasApiKey = !!transportHeaders["X-API-KEY"];
     if (hasApiKey) {
       if (provider) {
-        const tokenData = await this.oauthManager.getProviderToken(provider);
+        const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
         if (tokenData && this.transport.setHeader) {
           const previousAuthHeader = transportHeaders["Authorization"];
           try {
@@ -1695,7 +1695,7 @@ class MCPClientBase {
       "Content-Type": "application/json"
     };
     if (provider) {
-      const tokenData = await this.oauthManager.getProviderToken(provider);
+      const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
       if (tokenData) {
         headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
       }
@@ -1733,13 +1733,13 @@ class MCPClientBase {
     const result = await response.json();
     return result;
   }
-  async callToolWithRetry(name, args, retryCount = 0) {
+  async callToolWithRetry(name, args, retryCount = 0, options) {
     if (!this.enabledToolNames.has(name)) {
       throw new Error(`Tool "${name}" is not enabled. Enable it by adding the appropriate integration.`);
     }
     const provider = this.getProviderForTool(name);
     try {
-      const response = await this.callToolThroughHandler(name, args, provider);
+      const response = await this.callToolThroughHandler(name, args, provider, options);
       if (provider) {
         this.authState.set(provider, { authenticated: true });
       }
@@ -1921,11 +1921,11 @@ class MCPClientBase {
       throw error;
     }
   }
-  async getProviderToken(provider) {
-    return await this.oauthManager.getProviderToken(provider);
+  async getProviderToken(provider, context) {
+    return await this.oauthManager.getProviderToken(provider, context);
   }
-  async setProviderToken(provider, tokenData) {
-    await this.oauthManager.setProviderToken(provider, tokenData);
+  async setProviderToken(provider, tokenData, context) {
+    await this.oauthManager.setProviderToken(provider, tokenData, context);
     this.authState.set(provider, { authenticated: true });
   }
   getAllProviderTokens() {

package/dist/adapters/solid-start.js

@@ -1091,10 +1091,10 @@ class OAuthManager {
     this.providerTokens.delete(provider);
     this.clearProviderToken(provider);
   }
-  async getProviderToken(provider) {
+  async getProviderToken(provider, context) {
     if (this.getTokenCallback) {
       try {
-        const tokenData = await this.getTokenCallback(provider);
+        const tokenData = await this.getTokenCallback(provider, context);
         if (tokenData) {
           this.providerTokens.set(provider, tokenData);
         }
@@ -1109,9 +1109,9 @@ class OAuthManager {
   getAllProviderTokens() {
     return new Map(this.providerTokens);
   }
-  async setProviderToken(provider, tokenData) {
+  async setProviderToken(provider, tokenData, context) {
     this.providerTokens.set(provider, tokenData);
-    await this.saveProviderToken(provider, tokenData);
+    await this.saveProviderToken(provider, tokenData, context);
   }
   clearProviderToken(provider) {
     this.providerTokens.delete(provider);
@@ -1154,10 +1154,10 @@ class OAuthManager {
       }
     }
   }
-  async saveProviderToken(provider, tokenData) {
+  async saveProviderToken(provider, tokenData, context) {
     if (this.setTokenCallback) {
       try {
-        await this.setTokenCallback(provider, tokenData);
+        await this.setTokenCallback(provider, tokenData, context);
       } catch (error) {
         console.error(`Failed to save token for ${provider} via callback:`, error);
         throw error;
@@ -1444,9 +1444,9 @@ class MCPClientBase {
     }
     return new Proxy({}, {
       get: (_target, methodName) => {
-        return async (args) => {
+        return async (args, options) => {
           const toolName = methodToToolName(methodName, integrationId);
-          return await this.callToolWithRetry(toolName, args, 0);
+          return await this.callToolWithRetry(toolName, args, 0, options);
         };
       }
     });
@@ -1454,17 +1454,17 @@ class MCPClientBase {
   createServerProxy() {
     return new Proxy({}, {
       get: (_target, methodName) => {
-        return async (args) => {
+        return async (args, options) => {
           const toolName = methodToToolName(methodName, "");
           const finalToolName = toolName.startsWith("_") ? toolName.substring(1) : toolName;
-          return await this.callServerToolInternal(finalToolName, args);
+          return await this.callServerToolInternal(finalToolName, args, options);
         };
       }
     });
   }
-  async callServerToolInternal(name, args) {
+  async callServerToolInternal(name, args, options) {
     try {
-      const response = await this.callToolThroughHandler(name, args);
+      const response = await this.callToolThroughHandler(name, args, undefined, options);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
@@ -1513,8 +1513,8 @@ class MCPClientBase {
     const enabledTools = response.tools.filter((tool) => this.enabledToolNames.has(tool.name));
     console.log(`Discovered ${response.tools.length} tools, ${enabledTools.length} enabled by integrations`);
   }
-  async _callToolByName(name, args) {
-    return await this.callToolWithRetry(name, args, 0);
+  async _callToolByName(name, args, options) {
+    return await this.callToolWithRetry(name, args, 0, options);
   }
   async callServerTool(name, args) {
     try {
@@ -1525,12 +1525,12 @@ class MCPClientBase {
       throw parsedError;
     }
   }
-  async callToolThroughHandler(name, args, provider) {
+  async callToolThroughHandler(name, args, provider, options) {
     const transportHeaders = this.transport.headers || {};
     const hasApiKey = !!transportHeaders["X-API-KEY"];
     if (hasApiKey) {
       if (provider) {
-        const tokenData = await this.oauthManager.getProviderToken(provider);
+        const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
         if (tokenData && this.transport.setHeader) {
           const previousAuthHeader = transportHeaders["Authorization"];
           try {
@@ -1560,7 +1560,7 @@ class MCPClientBase {
       "Content-Type": "application/json"
     };
     if (provider) {
-      const tokenData = await this.oauthManager.getProviderToken(provider);
+      const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
       if (tokenData) {
         headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
       }
@@ -1598,13 +1598,13 @@ class MCPClientBase {
     const result = await response.json();
     return result;
   }
-  async callToolWithRetry(name, args, retryCount = 0) {
+  async callToolWithRetry(name, args, retryCount = 0, options) {
     if (!this.enabledToolNames.has(name)) {
       throw new Error(`Tool "${name}" is not enabled. Enable it by adding the appropriate integration.`);
     }
     const provider = this.getProviderForTool(name);
     try {
-      const response = await this.callToolThroughHandler(name, args, provider);
+      const response = await this.callToolThroughHandler(name, args, provider, options);
       if (provider) {
         this.authState.set(provider, { authenticated: true });
       }
@@ -1786,11 +1786,11 @@ class MCPClientBase {
       throw error;
     }
   }
-  async getProviderToken(provider) {
-    return await this.oauthManager.getProviderToken(provider);
+  async getProviderToken(provider, context) {
+    return await this.oauthManager.getProviderToken(provider, context);
   }
-  async setProviderToken(provider, tokenData) {
-    await this.oauthManager.setProviderToken(provider, tokenData);
+  async setProviderToken(provider, tokenData, context) {
+    await this.oauthManager.setProviderToken(provider, tokenData, context);
     this.authState.set(provider, { authenticated: true });
   }
   getAllProviderTokens() {

package/dist/adapters/svelte-kit.js

@@ -1091,10 +1091,10 @@ class OAuthManager {
     this.providerTokens.delete(provider);
     this.clearProviderToken(provider);
   }
-  async getProviderToken(provider) {
+  async getProviderToken(provider, context) {
     if (this.getTokenCallback) {
       try {
-        const tokenData = await this.getTokenCallback(provider);
+        const tokenData = await this.getTokenCallback(provider, context);
         if (tokenData) {
           this.providerTokens.set(provider, tokenData);
         }
@@ -1109,9 +1109,9 @@ class OAuthManager {
   getAllProviderTokens() {
     return new Map(this.providerTokens);
   }
-  async setProviderToken(provider, tokenData) {
+  async setProviderToken(provider, tokenData, context) {
     this.providerTokens.set(provider, tokenData);
-    await this.saveProviderToken(provider, tokenData);
+    await this.saveProviderToken(provider, tokenData, context);
   }
   clearProviderToken(provider) {
     this.providerTokens.delete(provider);
@@ -1154,10 +1154,10 @@ class OAuthManager {
       }
     }
   }
-  async saveProviderToken(provider, tokenData) {
+  async saveProviderToken(provider, tokenData, context) {
     if (this.setTokenCallback) {
       try {
-        await this.setTokenCallback(provider, tokenData);
+        await this.setTokenCallback(provider, tokenData, context);
       } catch (error) {
         console.error(`Failed to save token for ${provider} via callback:`, error);
         throw error;
@@ -1444,9 +1444,9 @@ class MCPClientBase {
     }
     return new Proxy({}, {
       get: (_target, methodName) => {
-        return async (args) => {
+        return async (args, options) => {
           const toolName = methodToToolName(methodName, integrationId);
-          return await this.callToolWithRetry(toolName, args, 0);
+          return await this.callToolWithRetry(toolName, args, 0, options);
         };
       }
     });
@@ -1454,17 +1454,17 @@ class MCPClientBase {
   createServerProxy() {
     return new Proxy({}, {
       get: (_target, methodName) => {
-        return async (args) => {
+        return async (args, options) => {
           const toolName = methodToToolName(methodName, "");
           const finalToolName = toolName.startsWith("_") ? toolName.substring(1) : toolName;
-          return await this.callServerToolInternal(finalToolName, args);
+          return await this.callServerToolInternal(finalToolName, args, options);
         };
       }
     });
   }
-  async callServerToolInternal(name, args) {
+  async callServerToolInternal(name, args, options) {
     try {
-      const response = await this.callToolThroughHandler(name, args);
+      const response = await this.callToolThroughHandler(name, args, undefined, options);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
@@ -1513,8 +1513,8 @@ class MCPClientBase {
     const enabledTools = response.tools.filter((tool) => this.enabledToolNames.has(tool.name));
     console.log(`Discovered ${response.tools.length} tools, ${enabledTools.length} enabled by integrations`);
   }
-  async _callToolByName(name, args) {
-    return await this.callToolWithRetry(name, args, 0);
+  async _callToolByName(name, args, options) {
+    return await this.callToolWithRetry(name, args, 0, options);
   }
   async callServerTool(name, args) {
     try {
@@ -1525,12 +1525,12 @@ class MCPClientBase {
       throw parsedError;
     }
   }
-  async callToolThroughHandler(name, args, provider) {
+  async callToolThroughHandler(name, args, provider, options) {
     const transportHeaders = this.transport.headers || {};
     const hasApiKey = !!transportHeaders["X-API-KEY"];
     if (hasApiKey) {
       if (provider) {
-        const tokenData = await this.oauthManager.getProviderToken(provider);
+        const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
         if (tokenData && this.transport.setHeader) {
           const previousAuthHeader = transportHeaders["Authorization"];
           try {
@@ -1560,7 +1560,7 @@ class MCPClientBase {
       "Content-Type": "application/json"
     };
     if (provider) {
-      const tokenData = await this.oauthManager.getProviderToken(provider);
+      const tokenData = await this.oauthManager.getProviderToken(provider, options?.context);
       if (tokenData) {
         headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
       }
@@ -1598,13 +1598,13 @@ class MCPClientBase {
     const result = await response.json();
     return result;
   }
-  async callToolWithRetry(name, args, retryCount = 0) {
+  async callToolWithRetry(name, args, retryCount = 0, options) {
     if (!this.enabledToolNames.has(name)) {
       throw new Error(`Tool "${name}" is not enabled. Enable it by adding the appropriate integration.`);
     }
     const provider = this.getProviderForTool(name);
     try {
-      const response = await this.callToolThroughHandler(name, args, provider);
+      const response = await this.callToolThroughHandler(name, args, provider, options);
       if (provider) {
         this.authState.set(provider, { authenticated: true });
       }
@@ -1786,11 +1786,11 @@ class MCPClientBase {
       throw error;
     }
   }
-  async getProviderToken(provider) {
-    return await this.oauthManager.getProviderToken(provider);
+  async getProviderToken(provider, context) {
+    return await this.oauthManager.getProviderToken(provider, context);
   }
-  async setProviderToken(provider, tokenData) {
-    await this.oauthManager.setProviderToken(provider, tokenData);
+  async setProviderToken(provider, tokenData, context) {
+    await this.oauthManager.setProviderToken(provider, tokenData, context);
     this.authState.set(provider, { authenticated: true });
   }
   getAllProviderTokens() {

package/dist/ai/google.d.ts

@@ -6,8 +6,7 @@
 import type { MCPClient } from "../client.js";
 import type { MCPTool } from "../protocol/messages.js";
 import { type AIToolsOptions } from "./utils.js";
-import { Type } from "@google/genai";
-import type { Schema, FunctionDeclaration, FunctionCall } from "@google/genai";
+import type { Schema, FunctionDeclaration, FunctionCall, Type } from "@google/genai";
 export type GoogleTool = FunctionDeclaration;
 export type GoogleFunctionCall = FunctionCall;
 export type { Schema, Type };
@@ -26,10 +25,10 @@ export interface GoogleToolsOptions extends AIToolsOptions {
  *
  * @example
  * ```typescript
- * const googleTool = convertMCPToolToGoogle(mcpTool, client);
+ * const googleTool = await convertMCPToolToGoogle(mcpTool, client);
  * ```
  */
-export declare function convertMCPToolToGoogle(mcpTool: MCPTool, _client: MCPClient<any>, _options?: GoogleToolsOptions): GoogleTool;
+export declare function convertMCPToolToGoogle(mcpTool: MCPTool, _client: MCPClient<any>, _options?: GoogleToolsOptions): Promise<GoogleTool>;
 /**
  * Convert all enabled MCP tools to Google GenAI format
  *
@@ -40,15 +39,15 @@ export declare function convertMCPToolToGoogle(mcpTool: MCPTool, _client: MCPCli
  * @example
  * ```typescript
  * // Client-side usage
- * const tools = convertMCPToolsToGoogle(mcpClient);
+ * const tools = await convertMCPToolsToGoogle(mcpClient);
  *
  * // Server-side with provider tokens
- * const tools = convertMCPToolsToGoogle(serverClient, {
+ * const tools = await convertMCPToolsToGoogle(serverClient, {
  *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
  * });
  * ```
  */
-export declare function convertMCPToolsToGoogle(client: MCPClient<any>, options?: GoogleToolsOptions): GoogleTool[];
+export declare function convertMCPToolsToGoogle(client: MCPClient<any>, options?: GoogleToolsOptions): Promise<GoogleTool[]>;
 /**
  * Execute a function call from Google GenAI
  *

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;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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;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,CAsBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;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,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACZ,IAAI,EACL,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;AAW7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AA4D9D;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAqBrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAKvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,YAAY,EAAE,kBAAkB,EAChC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;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,CAsBnB;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,19 +4203,22 @@ async function ensureClientConnected(client) {
 }
 
 // google.ts
-import { Type } from "@google/genai";
-function convertJsonSchemaTypeToGoogleType(type) {
+async function getGoogleType() {
+  const { Type } = await import("@google/genai");
+  return Type;
+}
+function convertJsonSchemaTypeToGoogleType(type, TypeEnum) {
   const typeMap = {
-    string: Type.STRING,
-    number: Type.NUMBER,
-    integer: Type.INTEGER,
-    boolean: Type.BOOLEAN,
-    array: Type.ARRAY,
-    object: Type.OBJECT
+    string: TypeEnum.STRING,
+    number: TypeEnum.NUMBER,
+    integer: TypeEnum.INTEGER,
+    boolean: TypeEnum.BOOLEAN,
+    array: TypeEnum.ARRAY,
+    object: TypeEnum.OBJECT
   };
-  return typeMap[type.toLowerCase()] || Type.STRING;
+  return typeMap[type.toLowerCase()] || TypeEnum.STRING;
 }
-function convertPropertiesToSchema(properties) {
+function convertPropertiesToSchema(properties, TypeEnum) {
   const result = {};
   for (const [key, value] of Object.entries(properties)) {
     if (!value || typeof value !== "object") {
@@ -4227,13 +4230,13 @@ function convertPropertiesToSchema(properties) {
       enum: value.enum
     };
     if (value.type) {
-      schema.type = convertJsonSchemaTypeToGoogleType(value.type);
+      schema.type = convertJsonSchemaTypeToGoogleType(value.type, TypeEnum);
     }
     if (value.items) {
-      schema.items = convertPropertiesToSchema({ items: value.items }).items;
+      schema.items = convertPropertiesToSchema({ items: value.items }, TypeEnum).items;
     }
     if (value.properties) {
-      schema.properties = convertPropertiesToSchema(value.properties);
+      schema.properties = convertPropertiesToSchema(value.properties, TypeEnum);
     }
     for (const [k, v] of Object.entries(value)) {
       if (!["type", "description", "enum", "items", "properties"].includes(k)) {
@@ -4244,11 +4247,12 @@ function convertPropertiesToSchema(properties) {
   }
   return result;
 }
-function convertMCPToolToGoogle(mcpTool, _client, _options) {
+async function convertMCPToolToGoogle(mcpTool, _client, _options) {
+  const TypeEnum = await getGoogleType();
   const properties = mcpTool.inputSchema?.properties || {};
-  const convertedProperties = convertPropertiesToSchema(properties);
+  const convertedProperties = convertPropertiesToSchema(properties, TypeEnum);
   const parameters = {
-    type: Type.OBJECT,
+    type: TypeEnum.OBJECT,
     description: mcpTool.description || "",
     properties: convertedProperties
   };
@@ -4261,9 +4265,9 @@ function convertMCPToolToGoogle(mcpTool, _client, _options) {
     parameters
   };
 }
-function convertMCPToolsToGoogle(client, options) {
+async function convertMCPToolsToGoogle(client, options) {
   const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options));
+  return await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options)));
 }
 async function executeGoogleFunctionCall(client, functionCall, options) {
   if (!functionCall?.name) {

package/dist/ai/index.js

@@ -4317,19 +4317,22 @@ async function getCloudflareTools(client, options) {
 }
 
 // google.ts
-import { Type } from "@google/genai";
-function convertJsonSchemaTypeToGoogleType(type) {
+async function getGoogleType() {
+  const { Type } = await import("@google/genai");
+  return Type;
+}
+function convertJsonSchemaTypeToGoogleType(type, TypeEnum) {
   const typeMap = {
-    string: Type.STRING,
-    number: Type.NUMBER,
-    integer: Type.INTEGER,
-    boolean: Type.BOOLEAN,
-    array: Type.ARRAY,
-    object: Type.OBJECT
+    string: TypeEnum.STRING,
+    number: TypeEnum.NUMBER,
+    integer: TypeEnum.INTEGER,
+    boolean: TypeEnum.BOOLEAN,
+    array: TypeEnum.ARRAY,
+    object: TypeEnum.OBJECT
   };
-  return typeMap[type.toLowerCase()] || Type.STRING;
+  return typeMap[type.toLowerCase()] || TypeEnum.STRING;
 }
-function convertPropertiesToSchema(properties) {
+function convertPropertiesToSchema(properties, TypeEnum) {
   const result = {};
   for (const [key, value] of Object.entries(properties)) {
     if (!value || typeof value !== "object") {
@@ -4341,13 +4344,13 @@ function convertPropertiesToSchema(properties) {
       enum: value.enum
     };
     if (value.type) {
-      schema.type = convertJsonSchemaTypeToGoogleType(value.type);
+      schema.type = convertJsonSchemaTypeToGoogleType(value.type, TypeEnum);
     }
     if (value.items) {
-      schema.items = convertPropertiesToSchema({ items: value.items }).items;
+      schema.items = convertPropertiesToSchema({ items: value.items }, TypeEnum).items;
     }
     if (value.properties) {
-      schema.properties = convertPropertiesToSchema(value.properties);
+      schema.properties = convertPropertiesToSchema(value.properties, TypeEnum);
     }
     for (const [k, v] of Object.entries(value)) {
       if (!["type", "description", "enum", "items", "properties"].includes(k)) {
@@ -4358,11 +4361,12 @@ function convertPropertiesToSchema(properties) {
   }
   return result;
 }
-function convertMCPToolToGoogle(mcpTool, _client, _options) {
+async function convertMCPToolToGoogle(mcpTool, _client, _options) {
+  const TypeEnum = await getGoogleType();
   const properties = mcpTool.inputSchema?.properties || {};
-  const convertedProperties = convertPropertiesToSchema(properties);
+  const convertedProperties = convertPropertiesToSchema(properties, TypeEnum);
   const parameters = {
-    type: Type.OBJECT,
+    type: TypeEnum.OBJECT,
     description: mcpTool.description || "",
     properties: convertedProperties
   };
@@ -4375,9 +4379,9 @@ function convertMCPToolToGoogle(mcpTool, _client, _options) {
     parameters
   };
 }
-function convertMCPToolsToGoogle(client, options) {
+async function convertMCPToolsToGoogle(client, options) {
   const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options));
+  return await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, options)));
 }
 async function executeGoogleFunctionCall(client, functionCall, options) {
   if (!functionCall?.name) {
@@ -4426,7 +4430,10 @@ function convertMCPToolToVercelAI(mcpTool, client, options) {
     description: mcpTool.description || `Execute ${mcpTool.name}`,
     inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
     execute: async (args) => {
-      return await executeToolWithToken(client, mcpTool.name, args, options);
+      if (options?.providerTokens) {
+        return await executeToolWithToken(client, mcpTool.name, args, options);
+      }
+      return await client._callToolByName(mcpTool.name, args, options?.context ? { context: options.context } : undefined);
     }
   };
 }

package/dist/ai/vercel-ai.d.ts

@@ -6,6 +6,7 @@
 import { z } from "zod";
 import type { MCPClient } from "../client.js";
 import type { MCPTool } from "../protocol/messages.js";
+import type { MCPContext } from "../config/types.js";
 import { type AIToolsOptions } from "./utils.js";
 /**
  * Tool definition compatible with Vercel AI SDK v5
@@ -20,13 +21,15 @@ export interface VercelAITool {
  * Options for converting MCP tools to Vercel AI SDK format
  */
 export interface VercelAIToolsOptions extends AIToolsOptions {
+    /** User context for multi-tenant token storage */
+    context?: MCPContext;
 }
 /**
  * Convert a single MCP tool to Vercel AI SDK 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
+ * @param options - Optional configuration including provider tokens and context
  * @returns Vercel AI SDK compatible tool definition
  */
 export declare function convertMCPToolToVercelAI(mcpTool: MCPTool, client: MCPClient<any>, options?: VercelAIToolsOptions): VercelAITool;
@@ -109,11 +112,12 @@ export declare function convertMCPToolsToVercelAI(client: MCPClient<any>, option
  *
  * export async function POST(req: Request) {
  *   const { messages } = await req.json();
+ *   const userId = await getUserIdFromSession(req);
  *
  *   const result = streamText({
  *     model: "openai/gpt-4",
  *     messages,
- *     tools: await getVercelAITools(serverClient), // Tokens auto-extracted
+ *     tools: await getVercelAITools(serverClient, { context: { userId } }), // Pass user context
  *   });
  *
  *   return result.toUIMessageStreamResponse();