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

package/dist/oauth.js

@@ -10181,21 +10181,7 @@ var init_ai = __esm(() => {
   init_trigger_tools();
 });
 
-// src/triggers/types.ts
-var exports_types = {};
-__export(exports_types, {
-  WEBHOOK_DELIVERY_TIMEOUT_MS: () => WEBHOOK_DELIVERY_TIMEOUT_MS,
-  MAX_TRIGGER_STEPS: () => MAX_TRIGGER_STEPS
-});
-var MAX_TRIGGER_STEPS = 20, WEBHOOK_DELIVERY_TIMEOUT_MS = 1e4;
-
 // src/triggers/webhooks.ts
-var exports_webhooks = {};
-__export(exports_webhooks, {
-  signPayload: () => signPayload,
-  deliverWebhooks: () => deliverWebhooks,
-  deliverWebhook: () => deliverWebhook
-});
 async function signPayload(payload, secret) {
   const encoder = new TextEncoder;
   const data = encoder.encode(JSON.stringify(payload));
@@ -10244,6 +10230,155 @@ var init_webhooks = __esm(() => {
   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, {
@@ -10337,7 +10472,7 @@ function createMCPServer(config) {
     if (integration.oauth) {
       const { clientId, clientSecret, redirectUri: integrationRedirectUri, config: oauthConfig } = integration.oauth;
       if (!clientId || !clientSecret) {
-        logger31.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();
@@ -10468,7 +10603,7 @@ function createMCPServer(config) {
         }
         return response2;
       } catch (error) {
-        logger31.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 });
       }
     }
@@ -10484,6 +10619,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 });
@@ -10524,8 +10710,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: {
@@ -10535,8 +10722,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
@@ -10544,7 +10730,7 @@ function createMCPServer(config) {
                 })
               });
             } catch (scheduleError) {
-              logger31.error("[Trigger] Failed to register with scheduler:", scheduleError);
+              logger32.error("[Trigger] Failed to register with scheduler:", scheduleError);
             }
             return Response.json(created, { status: 201 });
           }
@@ -10579,7 +10765,7 @@ function createMCPServer(config) {
                 body: JSON.stringify({ triggerId })
               });
             } catch (error) {
-              logger31.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") {
@@ -10607,7 +10793,7 @@ function createMCPServer(config) {
                 body: JSON.stringify({ triggerId })
               });
             } catch (error) {
-              logger31.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") {
@@ -10618,10 +10804,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,
@@ -10631,145 +10814,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 });
-            }
-            if (body.stepIndex != null) {
-              const { validateStepLimit: validateStepLimit2 } = await Promise.resolve().then(() => (init_utils2(), exports_utils));
-              const { MAX_TRIGGER_STEPS: MAX_TRIGGER_STEPS2 } = await Promise.resolve().then(() => exports_types);
-              const stepValidation = validateStepLimit2(body.stepIndex, MAX_TRIGGER_STEPS2);
-              if (!stepValidation.valid) {
-                return Response.json({ error: stepValidation.error }, { status: 400 });
+              handleToolCall: (toolBody, authHeader, integrationsHeader) => {
+                return oauthHandler.handleToolCall(toolBody, authHeader, integrationsHeader);
               }
-            }
-            if (config.triggers.onComplete) {
-              try {
-                const completeResponse = await config.triggers.onComplete({
-                  trigger,
-                  request: body,
-                  context: context2
-                });
-                if (completeResponse.hasMore) {
-                  return Response.json(completeResponse);
-                }
-                const updates2 = {
-                  lastRunAt: body.executedAt,
-                  runCount: (trigger.runCount || 0) + 1
-                };
-                if (body.success) {
-                  updates2.lastResult = body.result;
-                  updates2.lastError = undefined;
-                  if (trigger.schedule.type === "once") {
-                    updates2.status = "completed";
-                  }
-                } else {
-                  updates2.lastError = body.error;
-                  updates2.status = "failed";
-                }
-                await config.triggers.update(triggerId, updates2, context2);
-                if (completeResponse.webhooks && completeResponse.webhooks.length > 0) {
-                  const { deliverWebhooks: deliverWebhooks2 } = await Promise.resolve().then(() => (init_webhooks(), exports_webhooks));
-                  const { WEBHOOK_DELIVERY_TIMEOUT_MS: WEBHOOK_DELIVERY_TIMEOUT_MS2 } = await Promise.resolve().then(() => exports_types);
-                  const steps = body.previousResults || [];
-                  const totalDuration = steps.reduce((sum, s) => sum + (s.duration || 0), 0);
-                  const payload = {
-                    triggerId,
-                    success: body.success,
-                    steps,
-                    totalSteps: steps.length,
-                    totalDuration,
-                    executedAt: body.executedAt
-                  };
-                  deliverWebhooks2(completeResponse.webhooks, payload, WEBHOOK_DELIVERY_TIMEOUT_MS2).catch(() => {});
-                }
-                return Response.json(completeResponse);
-              } catch (error) {
-                logger31.error("onComplete callback error:", error);
-                return Response.json({ error: "Internal server error in onComplete callback" }, { status: 500 });
-              }
-            }
-            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";
-              }
-            } 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) {
@@ -10802,7 +10863,7 @@ function createMCPServer(config) {
                   })
                 });
               } catch (error) {
-                logger31.error("[Trigger] Failed to update scheduler:", error);
+                logger32.error("[Trigger] Failed to update scheduler:", error);
               }
             }
             return Response.json(updated);
@@ -10819,14 +10880,14 @@ function createMCPServer(config) {
                 body: JSON.stringify({ triggerId })
               });
             } catch (error) {
-              logger31.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) {
-        logger31.error("[Trigger] Error:", error);
+        logger32.error("[Trigger] Error:", error);
         return Response.json({ error: error.message || "Failed to process trigger request" }, { status: error.statusCode || 500 });
       }
     }
@@ -10852,11 +10913,11 @@ function createMCPServer(config) {
       const errorRedirectUrl = "/auth-error";
       if (error) {
         const errorMsg = errorDescription || error;
-        logger31.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) {
-        logger31.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;
@@ -10932,7 +10993,7 @@ function createMCPServer(config) {
           frontendUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state, tokenData }))}`;
           return Response.redirect(frontendUrl);
         } catch (error2) {
-          logger31.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 {
@@ -11151,7 +11212,7 @@ function toSvelteKitHandler(clientOrHandlerOrOptions, _redirectOptions) {
     }
   };
 }
-var SERVER_LOG_CONTEXT2 = "server", logger31, 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 });
   }
@@ -11199,7 +11260,7 @@ var init_server = __esm(() => {
   init_anthropic();
   init_google();
   init_ai();
-  logger31 = createLogger("MCPServer", SERVER_LOG_CONTEXT2);
+  logger32 = createLogger("MCPServer", SERVER_LOG_CONTEXT2);
   codeVerifierStorage = new Map;
 });
 
@@ -11550,7 +11611,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);
     }
@@ -11662,7 +11723,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) {}
@@ -11712,11 +11773,11 @@ class OAuthHandler {
           try {
             await this.config.removeProviderToken(request.provider, undefined, context);
           } catch (error) {
-            logger32.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) {
-        logger32.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);
@@ -11776,17 +11837,17 @@ class OAuthHandler {
     return jsonRpcResponse.result;
   }
 }
-var SERVER_LOG_CONTEXT3 = "server", logger32, 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();
-  logger32 = createLogger("OAuthHandler", SERVER_LOG_CONTEXT3);
+  logger33 = createLogger("OAuthHandler", SERVER_LOG_CONTEXT3);
 });
 
 // src/adapters/auto-routes.ts
 init_base_handler();
 init_logger();
 var SERVER_LOG_CONTEXT4 = "server";
-var logger33 = createLogger("AutoRoutes", SERVER_LOG_CONTEXT4);
+var logger34 = createLogger("AutoRoutes", SERVER_LOG_CONTEXT4);
 var globalOAuthConfig = null;
 async function POST2(req, context) {
   if (!globalOAuthConfig) {
@@ -11828,7 +11889,7 @@ async function POST2(req, context) {
     }
     return createErrorResponse(`Unknown action: ${action}`, 404);
   } catch (error) {
-    logger33.error(`[OAuth ${action}] Error:`, error);
+    logger34.error(`[OAuth ${action}] Error:`, error);
     return createErrorResponse(error.message, 500);
   }
 }
@@ -11856,7 +11917,7 @@ async function GET2(req, context) {
     }
     return createErrorResponse(`Unknown action: ${action}`, 404);
   } catch (error) {
-    logger33.error(`[OAuth ${action}] Error:`, error);
+    logger34.error(`[OAuth ${action}] Error:`, error);
     return createErrorResponse(error.message, 500);
   }
 }