integrate-sdk 0.8.36 → 0.8.37

package/dist/ai/index.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;
@@ -4341,12 +4594,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;
@@ -4361,7 +4621,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: {} };
 }
 
 // vercel-ai.ts
@@ -4391,6 +4686,11 @@ async function getVercelAITools(client, options) {
   for (const mcpTool of mcpTools) {
     vercelTools[mcpTool.name] = convertMCPToolToVercelAI(mcpTool, client, finalOptions);
   }
+  const triggerConfig = client.__triggerConfig;
+  if (triggerConfig) {
+    const triggerTools = createTriggerTools(triggerConfig, options?.context);
+    Object.assign(vercelTools, triggerTools);
+  }
   return vercelTools;
 }
 
@@ -4415,10 +4715,48 @@ async function getOpenAITools(client, options) {
   }
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   const mcpTools = client.getEnabledTools();
-  return mcpTools.map((mcpTool) => convertMCPToolToOpenAI(mcpTool, client, finalOptions));
+  const openaiTools = mcpTools.map((mcpTool) => convertMCPToolToOpenAI(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 = zodToJsonSchema(zodSchema);
+      openaiTools.push({
+        type: "function",
+        name,
+        parameters: jsonSchema,
+        strict: options?.strict ?? null,
+        description: tool.description || null
+      });
+    }
+  }
+  return openaiTools;
+}
+function zodToJsonSchema(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" };
 }
 async function handleOpenAIToolCalls(client, toolCalls, options) {
   const toolOutputs = [];
+  const triggerConfig = client.__triggerConfig;
+  const triggerTools = triggerConfig ? createTriggerTools(triggerConfig, options?.context) : null;
   for (const output of toolCalls) {
     if (output.type === "function_call") {
       const toolCall = {
@@ -4428,7 +4766,12 @@ async function handleOpenAIToolCalls(client, toolCalls, options) {
       };
       try {
         const args = JSON.parse(toolCall.arguments);
-        const result = await executeToolWithToken(client, toolCall.name, args, options);
+        let result;
+        if (triggerTools && triggerTools[toolCall.name]) {
+          result = await triggerTools[toolCall.name].execute(args);
+        } else {
+          result = await executeToolWithToken(client, toolCall.name, args, options);
+        }
         const resultString = JSON.stringify(result);
         toolOutputs.push({
           call_id: output.call_id ?? output.id ?? "",
@@ -4469,5 +4812,6 @@ export {
   getOpenAITools,
   getGoogleTools,
   getAnthropicTools,
-  executeGoogleFunctionCalls
+  executeGoogleFunctionCalls,
+  createTriggerTools
 };

package/dist/ai/openai.d.ts

@@ -4,6 +4,7 @@
  * Helper functions to convert MCP tools to OpenAI Responses API format
  */
 import type { MCPClient } from "../client.js";
+import type { MCPContext } from "../config/types.js";
 import { type AIToolsOptions } from "./utils.js";
 import type { OpenAI } from "openai";
 /**
@@ -28,6 +29,8 @@ export interface OpenAIToolsOptions extends AIToolsOptions {
      * @default false
      */
     strict?: boolean;
+    /** User context for multi-tenant token storage */
+    context?: MCPContext;
 }
 /**
  * Get tools in a format compatible with OpenAI Responses API

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

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/ai/openai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AACjH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GAAG,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAgBvB;AA4ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,EAChE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAyB3H"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/ai/openai.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;AAEjH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GAAG,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAuCvB;AAsHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,EAChE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAyB3H"}