integrate-sdk 0.8.35 → 0.8.37

package/dist/oauth.js

@@ -7633,6 +7633,230 @@ var init_utils = __esm(() => {
   init_zod();
 });
 
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var init_url_alphabet = () => {};
+
+// node_modules/nanoid/index.js
+import crypto2 from "crypto";
+var POOL_SIZE_MULTIPLIER = 128, pool, poolOffset, fillPool = (bytes) => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto2.randomFillSync(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto2.randomFillSync(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}, nanoid = (size = 21) => {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+};
+var init_nanoid = __esm(() => {
+  init_url_alphabet();
+});
+
+// src/triggers/utils.ts
+var exports_utils = {};
+__export(exports_utils, {
+  validateStatusTransition: () => validateStatusTransition,
+  generateTriggerId: () => generateTriggerId,
+  extractProviderFromToolName: () => extractProviderFromToolName,
+  calculateHasMore: () => calculateHasMore
+});
+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;
+}
+var init_utils2 = __esm(() => {
+  init_nanoid();
+});
+
+// src/ai/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);
+      }
+    }
+  };
+}
+var init_trigger_tools = __esm(() => {
+  init_zod();
+  init_utils2();
+});
+
 // src/ai/vercel-ai.ts
 function convertMCPToolToVercelAI(mcpTool, client, options) {
   return {
@@ -7660,10 +7884,16 @@ 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;
 }
 var init_vercel_ai = __esm(() => {
   init_utils();
+  init_trigger_tools();
 });
 
 // src/ai/openai.ts
@@ -7687,10 +7917,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 = {
@@ -7700,7 +7968,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 ?? "",
@@ -7736,6 +8009,7 @@ async function handleOpenAIResponse(client, response, options) {
 }
 var init_openai = __esm(() => {
   init_utils();
+  init_trigger_tools();
 });
 
 // src/ai/anthropic.ts
@@ -7752,10 +8026,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",
@@ -7784,7 +8065,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;
@@ -7811,6 +8126,7 @@ async function handleAnthropicMessage(client, message, options) {
 }
 var init_anthropic = __esm(() => {
   init_utils();
+  init_trigger_tools();
 });
 
 // src/ai/google.ts
@@ -7893,12 +8209,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;
@@ -7913,10 +8236,46 @@ 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: {} };
 }
 var init_google = __esm(() => {
   init_utils();
+  init_trigger_tools();
 });
 
 // src/ai/index.ts
@@ -7925,71 +8284,7 @@ var init_ai = __esm(() => {
   init_openai();
   init_anthropic();
   init_google();
-});
-
-// node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-var init_url_alphabet = () => {};
-
-// node_modules/nanoid/index.js
-import crypto2 from "crypto";
-var POOL_SIZE_MULTIPLIER = 128, pool, poolOffset, fillPool = (bytes) => {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    crypto2.randomFillSync(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    crypto2.randomFillSync(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}, nanoid = (size = 21) => {
-  fillPool(size |= 0);
-  let id = "";
-  for (let i = poolOffset - size;i < poolOffset; i++) {
-    id += urlAlphabet[pool[i] & 63];
-  }
-  return id;
-};
-var init_nanoid = __esm(() => {
-  init_url_alphabet();
-});
-
-// src/triggers/utils.ts
-var exports_utils = {};
-__export(exports_utils, {
-  validateStatusTransition: () => validateStatusTransition,
-  generateTriggerId: () => generateTriggerId,
-  extractProviderFromToolName: () => extractProviderFromToolName,
-  calculateHasMore: () => calculateHasMore
-});
-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;
-}
-var init_utils2 = __esm(() => {
-  init_nanoid();
+  init_trigger_tools();
 });
 
 // src/server.ts
@@ -8029,6 +8324,7 @@ __export(exports_server, {
   figmaIntegration: () => figmaIntegration,
   executeGoogleFunctionCalls: () => executeGoogleFunctionCalls,
   cursorIntegration: () => cursorIntegration,
+  createTriggerTools: () => createTriggerTools,
   createSimpleIntegration: () => createSimpleIntegration,
   createMCPServer: () => createMCPServer,
   calcomIntegration: () => calcomIntegration,
@@ -8126,6 +8422,10 @@ function createMCPServer(config) {
     setProviderToken: config.setProviderToken,
     removeProviderToken: config.removeProviderToken
   };
+  client.__triggerConfig = config.triggers ? {
+    callbacks: config.triggers,
+    getSessionContext: config.getSessionContext
+  } : undefined;
   const { POST, GET } = createOAuthRouteHandlers({
     providers,
     serverUrl: config.serverUrl,