integrate-sdk 0.8.60-dev.0 → 0.8.62-dev.0

package/dist/index.js

@@ -8303,6 +8303,7 @@ var init_index_browser = () => {};
 // src/triggers/utils.ts
 var exports_utils = {};
 __export(exports_utils, {
+  validateStepLimit: () => validateStepLimit,
   validateStatusTransition: () => validateStatusTransition,
   generateTriggerId: () => generateTriggerId,
   extractProviderFromToolName: () => extractProviderFromToolName,
@@ -8330,6 +8331,15 @@ function validateStatusTransition(currentStatus, targetStatus) {
   }
   return { valid: true };
 }
+function validateStepLimit(stepIndex, maxSteps) {
+  if (stepIndex >= maxSteps) {
+    return {
+      valid: false,
+      error: `Step index ${stepIndex} exceeds maximum of ${maxSteps} steps`
+    };
+  }
+  return { valid: true };
+}
 function calculateHasMore(offset, returnedCount, total) {
   return offset + returnedCount < total;
 }
@@ -10337,6 +10347,204 @@ var init_ai = __esm(() => {
   init_trigger_tools();
 });
 
+// src/triggers/webhooks.ts
+async function signPayload(payload, secret) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(JSON.stringify(payload));
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, data);
+  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function deliverWebhook(webhook, payload, timeoutMs) {
+  const headers = {
+    "Content-Type": "application/json",
+    ...webhook.headers
+  };
+  if (webhook.secret) {
+    headers["X-Webhook-Signature"] = await signPayload(payload, webhook.secret);
+  }
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(webhook.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      logger30.warn(`Webhook delivery to ${webhook.url} returned ${response.status}`);
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function deliverWebhooks(webhooks, payload, timeoutMs) {
+  if (webhooks.length === 0)
+    return;
+  const results = await Promise.allSettled(webhooks.map((webhook) => deliverWebhook(webhook, payload, timeoutMs)));
+  for (let i = 0;i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "rejected") {
+      logger30.warn(`Webhook delivery to ${webhooks[i].url} failed:`, result.reason);
+    }
+  }
+}
+var logger30;
+var init_webhooks = __esm(() => {
+  init_logger();
+  logger30 = createLogger("Webhooks", "server");
+});
+
+// src/triggers/types.ts
+var MAX_TRIGGER_STEPS = 20, WEBHOOK_DELIVERY_TIMEOUT_MS = 1e4;
+
+// src/triggers/executor.ts
+var exports_executor = {};
+__export(exports_executor, {
+  executeTrigger: () => executeTrigger
+});
+async function executeTrigger(trigger, config, context) {
+  const steps = [];
+  let currentToolName = trigger.toolName;
+  let currentToolArguments = trigger.toolArguments;
+  let currentProvider = trigger.provider;
+  let stepIndex = 0;
+  while (stepIndex < MAX_TRIGGER_STEPS) {
+    const stepValidation = validateStepLimit(stepIndex, MAX_TRIGGER_STEPS);
+    if (!stepValidation.valid) {
+      logger31.error(`[Trigger ${trigger.id}] ${stepValidation.error}`);
+      break;
+    }
+    const providerToken = await config.getProviderToken(currentProvider, undefined, context);
+    if (!providerToken) {
+      const error = `No OAuth token available for provider '${currentProvider}'`;
+      logger31.error(`[Trigger ${trigger.id}] ${error}`);
+      steps.push({
+        stepIndex,
+        toolName: currentToolName,
+        success: false,
+        error,
+        duration: 0,
+        executedAt: new Date().toISOString()
+      });
+      await config.triggers.update(trigger.id, {
+        lastRunAt: new Date().toISOString(),
+        runCount: (trigger.runCount || 0) + 1,
+        lastError: error,
+        status: "failed"
+      }, context);
+      return { success: false, steps, error };
+    }
+    const startTime = Date.now();
+    let toolResult;
+    let stepSuccess = true;
+    let stepError;
+    try {
+      toolResult = await config.handleToolCall({ name: currentToolName, arguments: currentToolArguments }, `${providerToken.tokenType || "Bearer"} ${providerToken.accessToken}`, null);
+    } catch (err) {
+      stepSuccess = false;
+      stepError = err.message || "Tool execution failed";
+      logger31.error(`[Trigger ${trigger.id}] Step ${stepIndex} failed:`, err);
+    }
+    const duration = Date.now() - startTime;
+    const executedAt = new Date().toISOString();
+    steps.push({
+      stepIndex,
+      toolName: currentToolName,
+      success: stepSuccess,
+      result: stepSuccess ? toolResult : undefined,
+      error: stepError,
+      duration,
+      executedAt
+    });
+    if (!config.triggers.onComplete || !stepSuccess) {
+      const updates = {
+        lastRunAt: executedAt,
+        runCount: (trigger.runCount || 0) + 1
+      };
+      if (stepSuccess) {
+        updates.lastResult = toolResult;
+        updates.lastError = undefined;
+        if (trigger.schedule.type === "once") {
+          updates.status = "completed";
+        }
+      } else {
+        updates.lastError = stepError;
+        updates.status = "failed";
+      }
+      await config.triggers.update(trigger.id, updates, context);
+      return { success: stepSuccess, steps, error: stepError };
+    }
+    const completeRequest = {
+      success: stepSuccess,
+      result: stepSuccess ? toolResult : undefined,
+      error: stepError,
+      executedAt,
+      duration,
+      stepIndex,
+      previousResults: steps,
+      final: false
+    };
+    const completeResponse = await config.triggers.onComplete({
+      trigger,
+      request: completeRequest,
+      context
+    });
+    if (completeResponse.hasMore && completeResponse.nextStep) {
+      currentToolName = completeResponse.nextStep.toolName;
+      currentToolArguments = completeResponse.nextStep.toolArguments;
+      currentProvider = completeResponse.nextStep.provider;
+      stepIndex++;
+      continue;
+    }
+    const finalUpdates = {
+      lastRunAt: executedAt,
+      runCount: (trigger.runCount || 0) + 1
+    };
+    if (stepSuccess) {
+      finalUpdates.lastResult = toolResult;
+      finalUpdates.lastError = undefined;
+      if (trigger.schedule.type === "once") {
+        finalUpdates.status = "completed";
+      }
+    } else {
+      finalUpdates.lastError = stepError;
+      finalUpdates.status = "failed";
+    }
+    await config.triggers.update(trigger.id, finalUpdates, context);
+    if (completeResponse.webhooks && completeResponse.webhooks.length > 0) {
+      const totalDuration = steps.reduce((sum, s) => sum + (s.duration || 0), 0);
+      const payload = {
+        triggerId: trigger.id,
+        success: steps.every((s) => s.success),
+        steps,
+        totalSteps: steps.length,
+        totalDuration,
+        executedAt
+      };
+      deliverWebhooks(completeResponse.webhooks, payload, WEBHOOK_DELIVERY_TIMEOUT_MS).catch(() => {});
+    }
+    return { success: stepSuccess, steps, error: stepError };
+  }
+  const limitError = `Trigger execution exceeded maximum of ${MAX_TRIGGER_STEPS} steps`;
+  logger31.error(`[Trigger ${trigger.id}] ${limitError}`);
+  await config.triggers.update(trigger.id, {
+    lastRunAt: new Date().toISOString(),
+    runCount: (trigger.runCount || 0) + 1,
+    lastError: limitError,
+    status: "failed"
+  }, context);
+  return { success: false, steps, error: limitError };
+}
+var logger31;
+var init_executor = __esm(() => {
+  init_logger();
+  init_utils2();
+  init_webhooks();
+  logger31 = createLogger("TriggerExecutor", "server");
+});
+
 // src/server.ts
 var exports_server = {};
 __export(exports_server, {
@@ -10430,7 +10638,7 @@ function createMCPServer(config) {
     if (integration.oauth) {
       const { clientId, clientSecret, redirectUri: integrationRedirectUri, config: oauthConfig } = integration.oauth;
       if (!clientId || !clientSecret) {
-        logger30.warn(`Warning: Integration "${integration.id}" is missing OAuth credentials. ` + `Provide clientId and clientSecret in the integration configuration.`);
+        logger32.warn(`Warning: Integration "${integration.id}" is missing OAuth credentials. ` + `Provide clientId and clientSecret in the integration configuration.`);
         return integration;
       }
       const redirectUri = integrationRedirectUri || config.redirectUri || getDefaultRedirectUri();
@@ -10561,7 +10769,7 @@ function createMCPServer(config) {
         }
         return response2;
       } catch (error) {
-        logger30.error("[MCP Tool Call] Error:", error);
+        logger32.error("[MCP Tool Call] Error:", error);
         return Response.json({ error: error.message || "Failed to execute tool call" }, { status: error.statusCode || 500 });
       }
     }
@@ -10577,6 +10785,57 @@ function createMCPServer(config) {
       }));
       return Response.json({ integrations });
     }
+    if (segments.length === 2 && segments[0] === "triggers" && segments[1] === "notify" && method === "POST") {
+      if (!config.triggers) {
+        return Response.json({ error: "Triggers not configured. Add triggers callbacks to createMCPServer config." }, { status: 501 });
+      }
+      try {
+        const apiKey = webRequest.headers.get("x-api-key");
+        if (!apiKey || apiKey !== config.apiKey) {
+          return Response.json({ error: "Unauthorized" }, { status: 401 });
+        }
+        const body = await webRequest.json();
+        const { triggerId } = body;
+        if (!triggerId) {
+          return Response.json({ error: "triggerId is required" }, { status: 400 });
+        }
+        const trigger = await config.triggers.get(triggerId);
+        if (!trigger) {
+          return Response.json({ error: "Trigger not found" }, { status: 404 });
+        }
+        if (!trigger.provider) {
+          return Response.json({ error: "Trigger has no provider configured" }, { status: 400 });
+        }
+        const triggerContext = trigger.userId ? { userId: trigger.userId } : undefined;
+        const { executeTrigger: executeTrigger2 } = await Promise.resolve().then(() => (init_executor(), exports_executor));
+        const { OAuthHandler: OAuthHandler2 } = await Promise.resolve().then(() => (init_base_handler(), exports_base_handler));
+        const oauthHandler = new OAuthHandler2({
+          providers,
+          serverUrl: config.serverUrl,
+          apiKey: config.apiKey,
+          setProviderToken: config.setProviderToken,
+          removeProviderToken: config.removeProviderToken,
+          getSessionContext: config.getSessionContext
+        });
+        const executionResult = await executeTrigger2(trigger, {
+          triggers: config.triggers,
+          getProviderToken: async (provider, email, ctx) => {
+            return config.getProviderToken ? await config.getProviderToken(provider, email, ctx) : undefined;
+          },
+          handleToolCall: (toolBody, authHeader, integrationsHeader) => {
+            return oauthHandler.handleToolCall(toolBody, authHeader, integrationsHeader);
+          }
+        }, triggerContext);
+        return Response.json({
+          success: executionResult.success,
+          steps: executionResult.steps,
+          error: executionResult.error
+        });
+      } catch (error) {
+        logger32.error("[Trigger Notify] Error:", error);
+        return Response.json({ error: error.message || "Failed to execute trigger" }, { status: 500 });
+      }
+    }
     if (segments.length >= 1 && segments[0] === "triggers") {
       if (!config.triggers) {
         return Response.json({ error: "Triggers not configured. Add triggers callbacks to createMCPServer config." }, { status: 501 });
@@ -10617,8 +10876,9 @@ function createMCPServer(config) {
             };
             const created = await config.triggers.create(trigger, context2);
             const schedulerUrl = config.schedulerUrl || config.serverUrl || "https://mcp.integrate.dev";
-            const callbackBaseUrl = process.env.INTEGRATE_URL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+            const defaultCallbackBaseUrl = process.env.INTEGRATE_URL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
             try {
+              const callbackBaseUrl = config.triggers.getCallbackUrl ? await config.triggers.getCallbackUrl(context2) : defaultCallbackBaseUrl;
               await fetch(`${schedulerUrl}/scheduler/register`, {
                 method: "POST",
                 headers: {
@@ -10628,8 +10888,7 @@ function createMCPServer(config) {
                 body: JSON.stringify({
                   triggerId: created.id,
                   schedule: created.schedule,
-                  callbackUrl: `${callbackBaseUrl}/api/integrate/triggers/${created.id}/execute`,
-                  completeUrl: `${callbackBaseUrl}/api/integrate/triggers/${created.id}/complete`,
+                  callbackUrl: `${callbackBaseUrl}/api/integrate/triggers/notify`,
                   metadata: {
                     userId: context2?.userId,
                     provider: created.provider
@@ -10637,7 +10896,7 @@ function createMCPServer(config) {
                 })
               });
             } catch (scheduleError) {
-              logger30.error("[Trigger] Failed to register with scheduler:", scheduleError);
+              logger32.error("[Trigger] Failed to register with scheduler:", scheduleError);
             }
             return Response.json(created, { status: 201 });
           }
@@ -10672,7 +10931,7 @@ function createMCPServer(config) {
                 body: JSON.stringify({ triggerId })
               });
             } catch (error) {
-              logger30.error("[Trigger] Failed to pause in scheduler:", error);
+              logger32.error("[Trigger] Failed to pause in scheduler:", error);
             }
             return Response.json(updated);
           } else if (subAction === "resume" && method === "POST") {
@@ -10700,7 +10959,7 @@ function createMCPServer(config) {
                 body: JSON.stringify({ triggerId })
               });
             } catch (error) {
-              logger30.error("[Trigger] Failed to resume in scheduler:", error);
+              logger32.error("[Trigger] Failed to resume in scheduler:", error);
             }
             return Response.json(updated);
           } else if (subAction === "run" && method === "POST") {
@@ -10711,10 +10970,7 @@ function createMCPServer(config) {
             if (!trigger.provider) {
               return Response.json({ error: "Trigger has no provider configured" }, { status: 400 });
             }
-            const providerToken = config.getProviderToken ? await config.getProviderToken(trigger.provider, undefined, context2) : undefined;
-            if (!providerToken) {
-              return Response.json({ error: "No OAuth token available for this trigger" }, { status: 401 });
-            }
+            const { executeTrigger: executeTrigger2 } = await Promise.resolve().then(() => (init_executor(), exports_executor));
             const { OAuthHandler: OAuthHandler2 } = await Promise.resolve().then(() => (init_base_handler(), exports_base_handler));
             const oauthHandler = new OAuthHandler2({
               providers,
@@ -10724,91 +10980,23 @@ function createMCPServer(config) {
               removeProviderToken: config.removeProviderToken,
               getSessionContext: config.getSessionContext
             });
-            const startTime = Date.now();
-            try {
-              const result = await oauthHandler.handleToolCall({ name: trigger.toolName, arguments: trigger.toolArguments }, `Bearer ${providerToken.accessToken}`, null);
-              const duration = Date.now() - startTime;
-              const executionResult = {
-                success: true,
-                result,
-                executedAt: new Date().toISOString(),
-                duration
-              };
-              await config.triggers.update(triggerId, {
-                lastRunAt: executionResult.executedAt,
-                runCount: (trigger.runCount || 0) + 1,
-                lastResult: result,
-                lastError: undefined
-              }, context2);
-              return Response.json(executionResult);
-            } catch (error) {
-              const duration = Date.now() - startTime;
-              const executionResult = {
-                success: false,
-                error: error.message || "Tool execution failed",
-                executedAt: new Date().toISOString(),
-                duration
-              };
-              await config.triggers.update(triggerId, {
-                lastRunAt: executionResult.executedAt,
-                runCount: (trigger.runCount || 0) + 1,
-                lastError: error.message,
-                status: "failed"
-              }, context2);
-              return Response.json(executionResult, { status: 500 });
-            }
-          } else if (subAction === "execute" && method === "GET") {
-            const apiKey = webRequest.headers.get("x-api-key");
-            if (!apiKey || apiKey !== config.apiKey) {
-              return Response.json({ error: "Unauthorized" }, { status: 401 });
-            }
-            const trigger = await config.triggers.get(triggerId, context2);
-            if (!trigger) {
-              return Response.json({ error: "Trigger not found" }, { status: 404 });
-            }
-            if (!trigger.provider) {
-              return Response.json({ error: "Trigger has no provider configured" }, { status: 400 });
-            }
-            const providerToken = config.getProviderToken ? await config.getProviderToken(trigger.provider, undefined, context2) : undefined;
-            if (!providerToken) {
-              return Response.json({ error: "No OAuth token available for this trigger" }, { status: 401 });
-            }
-            return Response.json({
-              trigger: {
-                id: trigger.id,
-                toolName: trigger.toolName,
-                toolArguments: trigger.toolArguments,
-                provider: trigger.provider
+            const executionResult = await executeTrigger2(trigger, {
+              triggers: config.triggers,
+              getProviderToken: async (provider, email, ctx) => {
+                return config.getProviderToken ? await config.getProviderToken(provider, email, ctx) : undefined;
               },
-              accessToken: providerToken.accessToken,
-              tokenType: providerToken.tokenType || "Bearer"
-            });
-          } else if (subAction === "complete" && method === "POST") {
-            const apiKey = webRequest.headers.get("x-api-key");
-            if (!apiKey || apiKey !== config.apiKey) {
-              return Response.json({ error: "Unauthorized" }, { status: 401 });
-            }
-            const body = await webRequest.json();
-            const trigger = await config.triggers.get(triggerId, context2);
-            if (!trigger) {
-              return Response.json({ error: "Trigger not found" }, { status: 404 });
-            }
-            const updates = {
-              lastRunAt: body.executedAt,
-              runCount: (trigger.runCount || 0) + 1
-            };
-            if (body.success) {
-              updates.lastResult = body.result;
-              updates.lastError = undefined;
-              if (trigger.schedule.type === "once") {
-                updates.status = "completed";
+              handleToolCall: (toolBody, authHeader, integrationsHeader) => {
+                return oauthHandler.handleToolCall(toolBody, authHeader, integrationsHeader);
               }
-            } else {
-              updates.lastError = body.error;
-              updates.status = "failed";
-            }
-            await config.triggers.update(triggerId, updates, context2);
-            return Response.json({ success: true });
+            }, context2);
+            return Response.json({
+              success: executionResult.success,
+              result: executionResult.steps[0]?.result,
+              executedAt: executionResult.steps[0]?.executedAt || new Date().toISOString(),
+              duration: executionResult.steps[0]?.duration,
+              error: executionResult.error,
+              steps: executionResult.steps
+            }, { status: executionResult.success ? 200 : 500 });
           } else if (!subAction && method === "GET") {
             const trigger = await config.triggers.get(triggerId, context2);
             if (!trigger) {
@@ -10841,7 +11029,7 @@ function createMCPServer(config) {
                   })
                 });
               } catch (error) {
-                logger30.error("[Trigger] Failed to update scheduler:", error);
+                logger32.error("[Trigger] Failed to update scheduler:", error);
               }
             }
             return Response.json(updated);
@@ -10858,14 +11046,14 @@ function createMCPServer(config) {
                 body: JSON.stringify({ triggerId })
               });
             } catch (error) {
-              logger30.error("[Trigger] Failed to unregister from scheduler:", error);
+              logger32.error("[Trigger] Failed to unregister from scheduler:", error);
             }
             return new Response(null, { status: 204 });
           }
         }
         return Response.json({ error: "Invalid trigger route or method" }, { status: 404 });
       } catch (error) {
-        logger30.error("[Trigger] Error:", error);
+        logger32.error("[Trigger] Error:", error);
         return Response.json({ error: error.message || "Failed to process trigger request" }, { status: error.statusCode || 500 });
       }
     }
@@ -10891,11 +11079,11 @@ function createMCPServer(config) {
       const errorRedirectUrl = "/auth-error";
       if (error) {
         const errorMsg = errorDescription || error;
-        logger30.error("[OAuth Redirect] Error:", errorMsg);
+        logger32.error("[OAuth Redirect] Error:", errorMsg);
         return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, webRequest.url));
       }
       if (!code || !state) {
-        logger30.error("[OAuth Redirect] Missing code or state parameter");
+        logger32.error("[OAuth Redirect] Missing code or state parameter");
         return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, webRequest.url));
       }
       let returnUrl = defaultRedirectUrl;
@@ -10971,7 +11159,7 @@ function createMCPServer(config) {
           frontendUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state, tokenData }))}`;
           return Response.redirect(frontendUrl);
         } catch (error2) {
-          logger30.error("[OAuth Backend Callback] Error:", error2);
+          logger32.error("[OAuth Backend Callback] Error:", error2);
           return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(error2.message || "Failed to exchange token")}`, webRequest.url));
         }
       } else {
@@ -11190,7 +11378,7 @@ function toSvelteKitHandler(clientOrHandlerOrOptions, _redirectOptions) {
     }
   };
 }
-var SERVER_LOG_CONTEXT2 = "server", logger30, globalServerConfig = null, codeVerifierStorage, POST = async (req, context) => {
+var SERVER_LOG_CONTEXT2 = "server", logger32, globalServerConfig = null, codeVerifierStorage, POST = async (req, context) => {
   if (!globalServerConfig) {
     return Response.json({ error: "OAuth not configured. Call createMCPServer() in your server initialization file first." }, { status: 500 });
   }
@@ -11238,7 +11426,7 @@ var init_server = __esm(() => {
   init_anthropic();
   init_google();
   init_ai();
-  logger30 = createLogger("MCPServer", SERVER_LOG_CONTEXT2);
+  logger32 = createLogger("MCPServer", SERVER_LOG_CONTEXT2);
   codeVerifierStorage = new Map;
 });
 
@@ -11589,7 +11777,7 @@ class OAuthHandler {
     url.searchParams.set("state", authorizeRequest.state);
     url.searchParams.set("code_challenge", authorizeRequest.codeChallenge);
     url.searchParams.set("code_challenge_method", authorizeRequest.codeChallengeMethod);
-    const redirectUri = authorizeRequest.redirectUri || providerConfig.redirectUri;
+    const redirectUri = providerConfig.redirectUri;
     if (redirectUri) {
       url.searchParams.set("redirect_uri", redirectUri);
     }
@@ -11701,7 +11889,7 @@ class OAuthHandler {
           tokenType: result.tokenType,
           expiresIn: result.expiresIn,
           expiresAt: result.expiresAt,
-          scopes: result.scopes
+          scopes: result.scopes ? result.scopes.flatMap((s) => s.split(" ").filter(Boolean)) : result.scopes
         };
         await this.config.setProviderToken(callbackRequest.provider, tokenData, undefined, context);
       } catch (error) {}
@@ -11751,11 +11939,11 @@ class OAuthHandler {
           try {
             await this.config.removeProviderToken(request.provider, undefined, context);
           } catch (error) {
-            logger31.error(`Failed to delete token for ${request.provider} from database via removeProviderToken:`, error);
+            logger33.error(`Failed to delete token for ${request.provider} from database via removeProviderToken:`, error);
           }
         }
       } catch (error) {
-        logger31.error(`Failed to extract context for disconnect:`, error);
+        logger33.error(`Failed to extract context for disconnect:`, error);
       }
     }
     const url = new URL("/oauth/disconnect", this.serverUrl);
@@ -11815,10 +12003,10 @@ class OAuthHandler {
     return jsonRpcResponse.result;
   }
 }
-var SERVER_LOG_CONTEXT3 = "server", logger31, MCP_SERVER_URL2 = "https://mcp.integrate.dev/api/v1/mcp";
+var SERVER_LOG_CONTEXT3 = "server", logger33, MCP_SERVER_URL2 = "https://mcp.integrate.dev/api/v1/mcp";
 var init_base_handler = __esm(() => {
   init_logger();
-  logger31 = createLogger("OAuthHandler", SERVER_LOG_CONTEXT3);
+  logger33 = createLogger("OAuthHandler", SERVER_LOG_CONTEXT3);
 });
 
 // src/index.ts
@@ -11831,7 +12019,7 @@ init_nextjs();
 // src/adapters/nextjs-oauth-redirect.ts
 init_logger();
 var SERVER_LOG_CONTEXT4 = "server";
-var logger32 = createLogger("OAuthRedirect", SERVER_LOG_CONTEXT4);
+var logger34 = createLogger("OAuthRedirect", SERVER_LOG_CONTEXT4);
 function createOAuthRedirectHandler(config) {
   const defaultRedirectUrl = config?.redirectUrl || "/";
   const errorRedirectUrl = config?.errorRedirectUrl || "/auth-error";
@@ -11843,11 +12031,11 @@ function createOAuthRedirectHandler(config) {
     const errorDescription = searchParams.get("error_description");
     if (error) {
       const errorMsg = errorDescription || error;
-      logger32.error("[OAuth Redirect] Error:", errorMsg);
+      logger34.error("[OAuth Redirect] Error:", errorMsg);
       return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, req.url));
     }
     if (!code || !state) {
-      logger32.error("[OAuth Redirect] Missing code or state parameter");
+      logger34.error("[OAuth Redirect] Missing code or state parameter");
       return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, req.url));
     }
     let returnUrl = defaultRedirectUrl;
@@ -11927,6 +12115,8 @@ init_intercom();
 init_hubspot();
 init_youtube();
 init_cursor();
+init_utils2();
+init_webhooks();
 init_generic();
 init_messages();
 init_http_session();
@@ -11989,6 +12179,7 @@ export {
   youtubeIntegration,
   whatsappIntegration,
   vercelIntegration,
+  validateStepLimit,
   todoistIntegration,
   toWebRequest,
   toTanStackStartHandler,
@@ -12022,6 +12213,7 @@ export {
   gcalIntegration,
   fromNodeHeaders,
   figmaIntegration,
+  deliverWebhooks,
   cursorIntegration,
   createTanStackOAuthHandler,
   createSimpleIntegration,
@@ -12032,6 +12224,7 @@ export {
   clearClientCache,
   calcomIntegration,
   airtableIntegration,
+  WEBHOOK_DELIVERY_TIMEOUT_MS,
   TriggerClient,
   ToolCallError,
   TokenExpiredError,
@@ -12040,6 +12233,7 @@ export {
   OAuthHandler,
   MCPMethod,
   MCPClientBase,
+  MAX_TRIGGER_STEPS,
   IntegrateSDKError,
   HttpSessionTransport,
   ConnectionError,