integrate-sdk 0.8.36 → 0.8.37

package/dist/ai/anthropic.js

@@ -4189,6 +4189,218 @@ async function ensureClientConnected(client) {
   }
 }
 
+// ../../node_modules/nanoid/index.js
+import crypto from "crypto";
+
+// ../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+var fillPool = (bytes) => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.randomFillSync(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.randomFillSync(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+};
+var nanoid = (size = 21) => {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+};
+
+// ../triggers/utils.ts
+function generateTriggerId() {
+  return `trig_${nanoid(12)}`;
+}
+function extractProviderFromToolName(toolName) {
+  const parts = toolName.split("_");
+  return parts[0] || toolName;
+}
+function validateStatusTransition(currentStatus, targetStatus) {
+  if (targetStatus === "paused" && currentStatus !== "active") {
+    return {
+      valid: false,
+      error: `Cannot pause trigger with status '${currentStatus}'. Only 'active' triggers can be paused.`
+    };
+  }
+  if (targetStatus === "active" && currentStatus !== "paused") {
+    return {
+      valid: false,
+      error: `Cannot resume trigger with status '${currentStatus}'. Only 'paused' triggers can be resumed.`
+    };
+  }
+  return { valid: true };
+}
+function calculateHasMore(offset, returnedCount, total) {
+  return offset + returnedCount < total;
+}
+
+// trigger-tools.ts
+function createTriggerTools(config, context) {
+  const { callbacks } = config;
+  return {
+    create_trigger: {
+      description: "Schedule a tool to run at a specific time or on a recurring schedule. Use this when the user wants to do something later.",
+      inputSchema: exports_external.object({
+        name: exports_external.string().optional().describe("Human-readable trigger name"),
+        description: exports_external.string().optional().describe("Trigger description"),
+        toolName: exports_external.string().describe("MCP tool name to execute (e.g., gmail_send_email, github_create_issue)"),
+        toolArguments: exports_external.record(exports_external.unknown()).describe("Arguments to pass to the tool when it executes"),
+        schedule: exports_external.union([
+          exports_external.object({
+            type: exports_external.literal("once"),
+            runAt: exports_external.string().describe("ISO datetime string (e.g., 2024-12-13T22:00:00Z)")
+          }),
+          exports_external.object({
+            type: exports_external.literal("cron"),
+            expression: exports_external.string().describe("Cron expression (e.g., '0 9 * * *' for daily at 9 AM)")
+          })
+        ]).describe("When to execute the tool")
+      }),
+      execute: async (args) => {
+        const triggerId = generateTriggerId();
+        const provider = extractProviderFromToolName(args.toolName);
+        const now = new Date().toISOString();
+        const trigger = {
+          id: triggerId,
+          ...args,
+          provider,
+          status: "active",
+          createdAt: now,
+          updatedAt: now,
+          runCount: 0
+        };
+        return callbacks.create(trigger, context);
+      }
+    },
+    list_triggers: {
+      description: "List all scheduled triggers with optional filtering by status or tool name",
+      inputSchema: exports_external.object({
+        status: exports_external.enum(["active", "paused", "completed", "failed"]).optional().describe("Filter by trigger status"),
+        toolName: exports_external.string().optional().describe("Filter by tool name"),
+        limit: exports_external.number().optional().describe("Maximum number of results (default: 20)"),
+        offset: exports_external.number().optional().describe("Number of results to skip for pagination (default: 0)")
+      }),
+      execute: async (args) => {
+        const params = {
+          status: args.status,
+          toolName: args.toolName,
+          limit: args.limit || 20,
+          offset: args.offset || 0
+        };
+        const result = await callbacks.list(params, context);
+        const hasMore = calculateHasMore(params.offset, result.triggers.length, result.total);
+        return {
+          triggers: result.triggers,
+          total: result.total,
+          hasMore
+        };
+      }
+    },
+    get_trigger: {
+      description: "Get details of a specific trigger by its ID",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to retrieve")
+      }),
+      execute: async (args) => {
+        const trigger = await callbacks.get(args.triggerId, context);
+        if (!trigger) {
+          throw new Error(`Trigger ${args.triggerId} not found`);
+        }
+        return trigger;
+      }
+    },
+    update_trigger: {
+      description: "Update a trigger's properties like name, description, arguments, or schedule",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to update"),
+        name: exports_external.string().optional().describe("New trigger name"),
+        description: exports_external.string().optional().describe("New trigger description"),
+        toolArguments: exports_external.record(exports_external.unknown()).optional().describe("New tool arguments"),
+        schedule: exports_external.union([
+          exports_external.object({
+            type: exports_external.literal("once"),
+            runAt: exports_external.string().describe("ISO datetime string")
+          }),
+          exports_external.object({
+            type: exports_external.literal("cron"),
+            expression: exports_external.string().describe("Cron expression")
+          })
+        ]).optional().describe("New schedule")
+      }),
+      execute: async (args) => {
+        const { triggerId, ...updates } = args;
+        const updatesWithTimestamp = {
+          ...updates,
+          updatedAt: new Date().toISOString()
+        };
+        return callbacks.update(triggerId, updatesWithTimestamp, context);
+      }
+    },
+    delete_trigger: {
+      description: "Delete a trigger permanently. This cannot be undone.",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to delete")
+      }),
+      execute: async (args) => {
+        await callbacks.delete(args.triggerId, context);
+        return { success: true, message: `Trigger ${args.triggerId} deleted` };
+      }
+    },
+    pause_trigger: {
+      description: "Pause a trigger to temporarily stop it from executing. Can be resumed later.",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to pause")
+      }),
+      execute: async (args) => {
+        const trigger = await callbacks.get(args.triggerId, context);
+        if (!trigger) {
+          throw new Error(`Trigger ${args.triggerId} not found`);
+        }
+        const validation = validateStatusTransition(trigger.status, "paused");
+        if (!validation.valid) {
+          throw new Error(validation.error);
+        }
+        return callbacks.update(args.triggerId, {
+          status: "paused",
+          updatedAt: new Date().toISOString()
+        }, context);
+      }
+    },
+    resume_trigger: {
+      description: "Resume a paused trigger to start executing it again on schedule",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to resume")
+      }),
+      execute: async (args) => {
+        const trigger = await callbacks.get(args.triggerId, context);
+        if (!trigger) {
+          throw new Error(`Trigger ${args.triggerId} not found`);
+        }
+        const validation = validateStatusTransition(trigger.status, "active");
+        if (!validation.valid) {
+          throw new Error(validation.error);
+        }
+        return callbacks.update(args.triggerId, {
+          status: "active",
+          updatedAt: new Date().toISOString()
+        }, context);
+      }
+    }
+  };
+}
+
 // anthropic.ts
 function convertMCPToolToAnthropic(mcpTool, _client, _options) {
   return {
@@ -4203,10 +4415,17 @@ function convertMCPToolToAnthropic(mcpTool, _client, _options) {
 }
 async function handleAnthropicToolCalls(client, messageContent, options) {
   const toolResults = [];
+  const triggerConfig = client.__triggerConfig;
+  const triggerTools = triggerConfig ? createTriggerTools(triggerConfig, options?.context) : null;
   const toolUseBlocks = messageContent.filter((block) => block.type === "tool_use" && ("id" in block) && ("name" in block) && ("input" in block));
   for (const toolUse of toolUseBlocks) {
     try {
-      const result = await executeToolWithToken(client, toolUse.name, toolUse.input, options);
+      let result;
+      if (triggerTools && triggerTools[toolUse.name]) {
+        result = await triggerTools[toolUse.name].execute(toolUse.input);
+      } else {
+        result = await executeToolWithToken(client, toolUse.name, toolUse.input, options);
+      }
       const resultString = JSON.stringify(result);
       toolResults.push({
         type: "tool_result",
@@ -4235,7 +4454,41 @@ async function getAnthropicTools(client, options) {
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToAnthropic(mcpTool, client, finalOptions));
+  const anthropicTools = mcpTools.map((mcpTool) => convertMCPToolToAnthropic(mcpTool, client, finalOptions));
+  const triggerConfig = client.__triggerConfig;
+  if (triggerConfig) {
+    const triggerTools = createTriggerTools(triggerConfig, options?.context);
+    for (const [name, tool] of Object.entries(triggerTools)) {
+      const zodSchema = tool.inputSchema;
+      const jsonSchema = zodToAnthropicSchema(zodSchema);
+      anthropicTools.push({
+        name,
+        description: tool.description || `Execute ${name}`,
+        input_schema: jsonSchema
+      });
+    }
+  }
+  return anthropicTools;
+}
+function zodToAnthropicSchema(schema) {
+  if (schema._def?.typeName === "ZodObject") {
+    const shape = schema._def.shape();
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      const fieldSchema = value;
+      properties[key] = { type: "string" };
+      if (fieldSchema._def?.typeName !== "ZodOptional") {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    };
+  }
+  return { type: "object", properties: {}, required: [] };
 }
 async function handleAnthropicMessage(client, message, options) {
   let providerTokens = options?.providerTokens;

package/dist/ai/google.d.ts

@@ -4,6 +4,7 @@
  * Helper functions to convert MCP tools to Google GenAI format
  */
 import type { MCPClient } from "../client.js";
+import type { MCPContext } from "../config/types.js";
 import { type AIToolsOptions } from "./utils.js";
 import type { Schema, FunctionDeclaration, FunctionCall, Type } from "@google/genai";
 export type GoogleTool = FunctionDeclaration;
@@ -13,6 +14,8 @@ export type { Schema, Type };
  * Options for converting MCP tools to Google GenAI format
  */
 export interface GoogleToolsOptions extends AIToolsOptions {
+    /** User context for multi-tenant token storage */
+    context?: MCPContext;
 }
 /**
  * Execute multiple function calls from Google GenAI 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;AAE9C,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;AAuB7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;CAAI;AAsG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CAqCnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAkBvB"}
+{"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;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAKjH,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;AAuB7B;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AAsGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CA2CnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAwCvB"}

package/dist/ai/google.js

@@ -4189,6 +4189,218 @@ async function ensureClientConnected(client) {
   }
 }
 
+// ../../node_modules/nanoid/index.js
+import crypto from "crypto";
+
+// ../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+var fillPool = (bytes) => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.randomFillSync(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.randomFillSync(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+};
+var nanoid = (size = 21) => {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+};
+
+// ../triggers/utils.ts
+function generateTriggerId() {
+  return `trig_${nanoid(12)}`;
+}
+function extractProviderFromToolName(toolName) {
+  const parts = toolName.split("_");
+  return parts[0] || toolName;
+}
+function validateStatusTransition(currentStatus, targetStatus) {
+  if (targetStatus === "paused" && currentStatus !== "active") {
+    return {
+      valid: false,
+      error: `Cannot pause trigger with status '${currentStatus}'. Only 'active' triggers can be paused.`
+    };
+  }
+  if (targetStatus === "active" && currentStatus !== "paused") {
+    return {
+      valid: false,
+      error: `Cannot resume trigger with status '${currentStatus}'. Only 'paused' triggers can be resumed.`
+    };
+  }
+  return { valid: true };
+}
+function calculateHasMore(offset, returnedCount, total) {
+  return offset + returnedCount < total;
+}
+
+// trigger-tools.ts
+function createTriggerTools(config, context) {
+  const { callbacks } = config;
+  return {
+    create_trigger: {
+      description: "Schedule a tool to run at a specific time or on a recurring schedule. Use this when the user wants to do something later.",
+      inputSchema: exports_external.object({
+        name: exports_external.string().optional().describe("Human-readable trigger name"),
+        description: exports_external.string().optional().describe("Trigger description"),
+        toolName: exports_external.string().describe("MCP tool name to execute (e.g., gmail_send_email, github_create_issue)"),
+        toolArguments: exports_external.record(exports_external.unknown()).describe("Arguments to pass to the tool when it executes"),
+        schedule: exports_external.union([
+          exports_external.object({
+            type: exports_external.literal("once"),
+            runAt: exports_external.string().describe("ISO datetime string (e.g., 2024-12-13T22:00:00Z)")
+          }),
+          exports_external.object({
+            type: exports_external.literal("cron"),
+            expression: exports_external.string().describe("Cron expression (e.g., '0 9 * * *' for daily at 9 AM)")
+          })
+        ]).describe("When to execute the tool")
+      }),
+      execute: async (args) => {
+        const triggerId = generateTriggerId();
+        const provider = extractProviderFromToolName(args.toolName);
+        const now = new Date().toISOString();
+        const trigger = {
+          id: triggerId,
+          ...args,
+          provider,
+          status: "active",
+          createdAt: now,
+          updatedAt: now,
+          runCount: 0
+        };
+        return callbacks.create(trigger, context);
+      }
+    },
+    list_triggers: {
+      description: "List all scheduled triggers with optional filtering by status or tool name",
+      inputSchema: exports_external.object({
+        status: exports_external.enum(["active", "paused", "completed", "failed"]).optional().describe("Filter by trigger status"),
+        toolName: exports_external.string().optional().describe("Filter by tool name"),
+        limit: exports_external.number().optional().describe("Maximum number of results (default: 20)"),
+        offset: exports_external.number().optional().describe("Number of results to skip for pagination (default: 0)")
+      }),
+      execute: async (args) => {
+        const params = {
+          status: args.status,
+          toolName: args.toolName,
+          limit: args.limit || 20,
+          offset: args.offset || 0
+        };
+        const result = await callbacks.list(params, context);
+        const hasMore = calculateHasMore(params.offset, result.triggers.length, result.total);
+        return {
+          triggers: result.triggers,
+          total: result.total,
+          hasMore
+        };
+      }
+    },
+    get_trigger: {
+      description: "Get details of a specific trigger by its ID",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to retrieve")
+      }),
+      execute: async (args) => {
+        const trigger = await callbacks.get(args.triggerId, context);
+        if (!trigger) {
+          throw new Error(`Trigger ${args.triggerId} not found`);
+        }
+        return trigger;
+      }
+    },
+    update_trigger: {
+      description: "Update a trigger's properties like name, description, arguments, or schedule",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to update"),
+        name: exports_external.string().optional().describe("New trigger name"),
+        description: exports_external.string().optional().describe("New trigger description"),
+        toolArguments: exports_external.record(exports_external.unknown()).optional().describe("New tool arguments"),
+        schedule: exports_external.union([
+          exports_external.object({
+            type: exports_external.literal("once"),
+            runAt: exports_external.string().describe("ISO datetime string")
+          }),
+          exports_external.object({
+            type: exports_external.literal("cron"),
+            expression: exports_external.string().describe("Cron expression")
+          })
+        ]).optional().describe("New schedule")
+      }),
+      execute: async (args) => {
+        const { triggerId, ...updates } = args;
+        const updatesWithTimestamp = {
+          ...updates,
+          updatedAt: new Date().toISOString()
+        };
+        return callbacks.update(triggerId, updatesWithTimestamp, context);
+      }
+    },
+    delete_trigger: {
+      description: "Delete a trigger permanently. This cannot be undone.",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to delete")
+      }),
+      execute: async (args) => {
+        await callbacks.delete(args.triggerId, context);
+        return { success: true, message: `Trigger ${args.triggerId} deleted` };
+      }
+    },
+    pause_trigger: {
+      description: "Pause a trigger to temporarily stop it from executing. Can be resumed later.",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to pause")
+      }),
+      execute: async (args) => {
+        const trigger = await callbacks.get(args.triggerId, context);
+        if (!trigger) {
+          throw new Error(`Trigger ${args.triggerId} not found`);
+        }
+        const validation = validateStatusTransition(trigger.status, "paused");
+        if (!validation.valid) {
+          throw new Error(validation.error);
+        }
+        return callbacks.update(args.triggerId, {
+          status: "paused",
+          updatedAt: new Date().toISOString()
+        }, context);
+      }
+    },
+    resume_trigger: {
+      description: "Resume a paused trigger to start executing it again on schedule",
+      inputSchema: exports_external.object({
+        triggerId: exports_external.string().describe("The trigger ID to resume")
+      }),
+      execute: async (args) => {
+        const trigger = await callbacks.get(args.triggerId, context);
+        if (!trigger) {
+          throw new Error(`Trigger ${args.triggerId} not found`);
+        }
+        const validation = validateStatusTransition(trigger.status, "active");
+        if (!validation.valid) {
+          throw new Error(validation.error);
+        }
+        return callbacks.update(args.triggerId, {
+          status: "active",
+          updatedAt: new Date().toISOString()
+        }, context);
+      }
+    }
+  };
+}
+
 // google.ts
 async function getGoogleType() {
   try {
@@ -4269,12 +4481,19 @@ async function executeGoogleFunctionCalls(client, functionCalls, options) {
     } catch {}
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
+  const triggerConfig = client.__triggerConfig;
+  const triggerTools = triggerConfig ? createTriggerTools(triggerConfig, options?.context) : null;
   const results = await Promise.all(functionCalls.map(async (call) => {
     if (!call?.name) {
       throw new Error("Function call must have a name");
     }
     const args = call.args || {};
-    const result = await executeToolWithToken(client, call.name, args, finalOptions);
+    let result;
+    if (triggerTools && triggerTools[call.name]) {
+      result = await triggerTools[call.name].execute(args);
+    } else {
+      result = await executeToolWithToken(client, call.name, args, finalOptions);
+    }
     return JSON.stringify(result);
   }));
   return results;
@@ -4289,7 +4508,42 @@ async function getGoogleTools(client, options) {
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   const mcpTools = client.getEnabledTools();
-  return await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, finalOptions)));
+  const googleTools = await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, finalOptions)));
+  const triggerConfig = client.__triggerConfig;
+  if (triggerConfig) {
+    const triggerTools = createTriggerTools(triggerConfig, options?.context);
+    const TypeEnum = await getGoogleType();
+    for (const [name, tool] of Object.entries(triggerTools)) {
+      const zodSchema = tool.inputSchema;
+      const jsonSchema = zodToGoogleSchema(zodSchema, TypeEnum);
+      googleTools.push({
+        name,
+        description: tool.description || `Execute ${name}`,
+        parameters: jsonSchema
+      });
+    }
+  }
+  return googleTools;
+}
+function zodToGoogleSchema(schema, TypeEnum) {
+  if (schema._def?.typeName === "ZodObject") {
+    const shape = schema._def.shape();
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      const fieldSchema = value;
+      properties[key] = { type: TypeEnum.STRING };
+      if (fieldSchema._def?.typeName !== "ZodOptional") {
+        required.push(key);
+      }
+    }
+    return {
+      type: TypeEnum.OBJECT,
+      properties,
+      ...required.length > 0 ? { required } : {}
+    };
+  }
+  return { type: TypeEnum.OBJECT, properties: {} };
 }
 export {
   getGoogleTools,

package/dist/ai/index.d.ts

@@ -7,5 +7,6 @@ export { getVercelAITools, type VercelAITool, type VercelAIToolsOptions } from "
 export { getOpenAITools, handleOpenAIResponse, type OpenAITool, type OpenAIToolsOptions } from "./openai.js";
 export { getAnthropicTools, handleAnthropicMessage, type AnthropicTool, type AnthropicToolsOptions, type AnthropicToolUseBlock, type AnthropicToolResultBlock } from "./anthropic.js";
 export { getGoogleTools, executeGoogleFunctionCalls, type GoogleTool, type GoogleFunctionCall, type GoogleToolsOptions } from "./google.js";
+export { createTriggerTools, type TriggerToolsConfig } from "./trigger-tools.js";
 export type { AIToolsOptions } from "./utils.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ai/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACxB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,0BAA0B,EAC1B,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACxB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ai/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACxB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,0BAA0B,EAC1B,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACxB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,kBAAkB,EAClB,KAAK,kBAAkB,EACxB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}