integrate-sdk 0.8.36 → 0.8.39

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/cloudflare.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Cloudflare Workers AI Integration
+ *
+ * Helper functions to convert MCP tools to Cloudflare Workers AI format
+ */
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Cloudflare AI tool definition
+ * Compatible with Cloudflare Workers AI
+ */
+export interface CloudflareTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, {
+                type: string;
+                description?: string;
+            }>;
+            required: string[];
+        };
+    };
+}
+/**
+ * Options for converting MCP tools to Cloudflare format
+ */
+export interface CloudflareToolsOptions extends AIToolsOptions {
+}
+/**
+ * Convert a single MCP tool to Cloudflare Workers AI 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
+ * @returns Cloudflare compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const cloudflareTool = convertMCPToolToCloudflare(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToCloudflare(mcpTool: MCPTool, _client: MCPClient<any>, _options?: CloudflareToolsOptions): CloudflareTool;
+/**
+ * Convert all enabled MCP tools to Cloudflare Workers AI format
+ * Returns a dictionary keyed by tool name
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Dictionary of Cloudflare compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToCloudflare(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToCloudflare(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToCloudflare(client: MCPClient<any>, options?: CloudflareToolsOptions): Record<string, CloudflareTool>;
+/**
+ * Execute a tool call from Cloudflare Workers AI
+ *
+ * @param client - The MCP client instance
+ * @param toolCall - The tool call with name and arguments
+ * @param options - Optional configuration including provider tokens
+ * @returns Tool execution result as JSON string
+ *
+ * @example
+ * ```typescript
+ * const result = await executeCloudflareToolCall(client, {
+ *   name: 'github_create_issue',
+ *   arguments: { owner: 'user', repo: 'repo', title: 'Bug' }
+ * }, { providerTokens });
+ * ```
+ */
+export declare function executeCloudflareToolCall(client: MCPClient<any>, toolCall: {
+    name: string;
+    arguments: Record<string, unknown> | string;
+}, options?: CloudflareToolsOptions): Promise<string>;
+/**
+ * Get tools in a format compatible with Cloudflare Workers AI
+ *
+ * Automatically connects the client if not already connected.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Dictionary of tools ready to use with Cloudflare Workers AI
+ *
+ * @example
+ * ```typescript
+ * // Cloudflare Worker usage
+ * import { createMCPClient, githubIntegration } from 'integrate-sdk';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/ai/cloudflare';
+ *
+ * export default {
+ *   async fetch(request: Request, env: Env): Promise<Response> {
+ *     const client = createMCPClient({
+ *       integrations: [githubIntegration({ clientId: env.GITHUB_CLIENT_ID })],
+ *     });
+ *
+ *     const tools = await getCloudflareTools(client);
+ *     const ai = new Ai(env.AI);
+ *
+ *     const response = await ai.run('@cf/meta/llama-3-8b-instruct', {
+ *       messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ *       tools: Object.values(tools)
+ *     });
+ *
+ *     return Response.json(response);
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
+ * import { getCloudflareTools, executeCloudflareToolCall } from 'integrate-sdk/ai/cloudflare';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   integrations: [githubIntegration({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const tools = await getCloudflareTools(serverClient, { providerTokens });
+ *
+ *   // Use with Cloudflare AI
+ *   const ai = new Ai(env.AI);
+ *   const response = await ai.run('@cf/meta/llama-3-8b-instruct', {
+ *     messages: [{ role: 'user', content: 'Create a GitHub issue' }],
+ *     tools: Object.values(tools)
+ *   });
+ *
+ *   // Handle tool calls
+ *   if (response.tool_calls) {
+ *     for (const toolCall of response.tool_calls) {
+ *       await executeCloudflareToolCall(serverClient, toolCall, { providerTokens });
+ *     }
+ *   }
+ *
+ *   return Response.json(response);
+ * }
+ * ```
+ */
+export declare function getCloudflareTools(client: MCPClient<any>, options?: CloudflareToolsOptions): Promise<Record<string, CloudflareTool>>;
+//# sourceMappingURL=cloudflare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/ai/cloudflare.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;AAEjH;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ,CAAC;YACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;gBACzB,IAAI,EAAE,MAAM,CAAC;gBACb,WAAW,CAAC,EAAE,MAAM,CAAC;aACtB,CAAC,CAAC;YACH,QAAQ,EAAE,MAAM,EAAE,CAAC;SACpB,CAAC;KACH,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,cAAc;CAAI;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,sBAAsB,GAChC,cAAc,CAahB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAShC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IACR,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;CAC7C,EACD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAezC"}