integrate-sdk 0.8.36 → 0.8.37

package/dist/ai/openai.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);
+      }
+    }
+  };
+}
+
 // openai.ts
 function convertMCPToolToOpenAI(mcpTool, _client, options) {
   const inputParams = mcpTool.inputSchema;
@@ -4210,10 +4422,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 = {
@@ -4223,7 +4473,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 ?? "",

package/dist/ai/trigger-tools.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Trigger Management Tools for AI
+ *
+ * SDK-level tools that call trigger callbacks directly
+ * Automatically included in AI provider helpers when triggers are configured
+ */
+import { z } from "zod";
+import type { MCPContext } from "../config/types.js";
+import type { TriggerCallbacks } from "../triggers/types.js";
+/**
+ * Configuration for trigger tools
+ */
+export interface TriggerToolsConfig {
+    /** Trigger storage callbacks */
+    callbacks: TriggerCallbacks;
+    /** Session context extraction function */
+    getSessionContext?: (request: Request) => Promise<MCPContext | undefined> | MCPContext | undefined;
+}
+/**
+ * Create trigger management tools for AI providers
+ * These tools call the trigger callbacks directly with pre-processing
+ *
+ * @param config - Trigger configuration including callbacks
+ * @param context - Optional user context for multi-tenant support
+ * @returns Object containing trigger management tools
+ */
+export declare function createTriggerTools(config: TriggerToolsConfig, context?: MCPContext): {
+    create_trigger: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            toolName: z.ZodString;
+            toolArguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            schedule: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"once">;
+                runAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "once";
+                runAt: string;
+            }, {
+                type: "once";
+                runAt: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"cron">;
+                expression: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "cron";
+                expression: string;
+            }, {
+                type: "cron";
+                expression: string;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            toolName: string;
+            toolArguments: Record<string, unknown>;
+            schedule: {
+                type: "once";
+                runAt: string;
+            } | {
+                type: "cron";
+                expression: string;
+            };
+            name?: string | undefined;
+            description?: string | undefined;
+        }, {
+            toolName: string;
+            toolArguments: Record<string, unknown>;
+            schedule: {
+                type: "once";
+                runAt: string;
+            } | {
+                type: "cron";
+                expression: string;
+            };
+            name?: string | undefined;
+            description?: string | undefined;
+        }>;
+        execute: (args: any) => Promise<import("../index.js").Trigger>;
+    };
+    list_triggers: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            status: z.ZodOptional<z.ZodEnum<["active", "paused", "completed", "failed"]>>;
+            toolName: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            toolName?: string | undefined;
+            status?: "active" | "paused" | "completed" | "failed" | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }, {
+            toolName?: string | undefined;
+            status?: "active" | "paused" | "completed" | "failed" | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }>;
+        execute: (args: any) => Promise<{
+            triggers: import("../index.js").Trigger[];
+            total: number;
+            hasMore: boolean;
+        }>;
+    };
+    get_trigger: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            triggerId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            triggerId: string;
+        }, {
+            triggerId: string;
+        }>;
+        execute: (args: any) => Promise<import("../index.js").Trigger>;
+    };
+    update_trigger: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            triggerId: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            toolArguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            schedule: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"once">;
+                runAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "once";
+                runAt: string;
+            }, {
+                type: "once";
+                runAt: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"cron">;
+                expression: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "cron";
+                expression: string;
+            }, {
+                type: "cron";
+                expression: string;
+            }>]>>;
+        }, "strip", z.ZodTypeAny, {
+            triggerId: string;
+            name?: string | undefined;
+            description?: string | undefined;
+            toolArguments?: Record<string, unknown> | undefined;
+            schedule?: {
+                type: "once";
+                runAt: string;
+            } | {
+                type: "cron";
+                expression: string;
+            } | undefined;
+        }, {
+            triggerId: string;
+            name?: string | undefined;
+            description?: string | undefined;
+            toolArguments?: Record<string, unknown> | undefined;
+            schedule?: {
+                type: "once";
+                runAt: string;
+            } | {
+                type: "cron";
+                expression: string;
+            } | undefined;
+        }>;
+        execute: (args: any) => Promise<import("../index.js").Trigger>;
+    };
+    delete_trigger: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            triggerId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            triggerId: string;
+        }, {
+            triggerId: string;
+        }>;
+        execute: (args: any) => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+    };
+    pause_trigger: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            triggerId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            triggerId: string;
+        }, {
+            triggerId: string;
+        }>;
+        execute: (args: any) => Promise<import("../index.js").Trigger>;
+    };
+    resume_trigger: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            triggerId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            triggerId: string;
+        }, {
+            triggerId: string;
+        }>;
+        execute: (args: any) => Promise<import("../index.js").Trigger>;
+    };
+};
+//# sourceMappingURL=trigger-tools.d.ts.map

package/dist/ai/trigger-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-tools.d.ts","sourceRoot":"","sources":["../../../src/ai/trigger-tools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAQ7D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,gCAAgC;IAChC,SAAS,EAAE,gBAAgB,CAAC;IAC5B,0CAA0C;IAC1C,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,GAAG,UAAU,GAAG,SAAS,CAAC;CACpG;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsBvD,GAAG;;;;;;;;;;;;;;;;;;;;wBA4BH,GAAG;;;;;;;;;;;;;;;wBA2BH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BH,GAAG;;;;;;;;;;;wBAkBH,GAAG;;;;;;;;;;;;;;wBAWH,GAAG;;;;;;;;;;;wBA+BH,GAAG;;EA0B9B"}