skedyul 1.2.51 → 1.3.0

package/dist/esm/index.mjs

@@ -1852,6 +1852,68 @@ var CoreApiService = class {
 };
 var coreApiService = new CoreApiService();
 
+// src/ratelimit/config-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+var cachedRuntimeQueues = null;
+function getRuntimeConfigPath() {
+  if (process.env.LAMBDA_TASK_ROOT) {
+    return path.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json");
+  }
+  return path.join(process.cwd(), ".skedyul", "config.json");
+}
+function loadRuntimeConfigFile() {
+  const configPath = getRuntimeConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var registeredServerConfig = null;
+function registerQueueConfig(config) {
+  registeredServerConfig = config;
+  cachedRuntimeQueues = config.queues ?? null;
+}
+function getQueueDefinitions() {
+  if (cachedRuntimeQueues) {
+    return cachedRuntimeQueues;
+  }
+  if (registeredServerConfig?.queues) {
+    cachedRuntimeQueues = stripNonSerializableQueues(registeredServerConfig.queues);
+    return cachedRuntimeQueues;
+  }
+  const fileConfig = loadRuntimeConfigFile();
+  if (fileConfig?.queues) {
+    cachedRuntimeQueues = fileConfig.queues;
+    return cachedRuntimeQueues;
+  }
+  return {};
+}
+function stripNonSerializableQueues(queues) {
+  const result = {};
+  for (const [name, config] of Object.entries(queues)) {
+    const { shouldRetry: _shouldRetry, ...serializable } = config;
+    result[name] = serializable;
+  }
+  return result;
+}
+function getQueueConfig(queueName) {
+  return getQueueDefinitions()[queueName];
+}
+function getQueueConfigWithRetry(queueName) {
+  const fromServer = registeredServerConfig?.queues?.[queueName];
+  if (fromServer) {
+    return fromServer;
+  }
+  const serializable = getQueueConfig(queueName);
+  return serializable;
+}
+
 // src/server/utils/schema.ts
 import * as z8 from "zod";
 function normalizeBilling(billing) {
@@ -3173,6 +3235,35 @@ var report = {
   }
 };
 
+// src/ratelimit/context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var executionContextStorage = new AsyncLocalStorage2();
+var activeOperationStorage = new AsyncLocalStorage2();
+function runWithRateLimitExecutionContext(ctx, fn) {
+  return executionContextStorage.run(ctx, fn);
+}
+function getRateLimitExecutionContext() {
+  return executionContextStorage.getStore();
+}
+function runWithActiveQueuedOperation(operation, fn) {
+  return activeOperationStorage.run(operation, fn);
+}
+function getActiveQueuedOperation() {
+  return activeOperationStorage.getStore();
+}
+function setActiveQueuedOperationLease(lease) {
+  const op = activeOperationStorage.getStore();
+  if (op) {
+    op.lease = lease;
+  }
+}
+function updateActiveQueuedOperationAttempt(attempt) {
+  const op = activeOperationStorage.getStore();
+  if (op) {
+    op.attempt = attempt;
+  }
+}
+
 // src/errors.ts
 var InstallError = class extends Error {
   // Optional: which field caused the error
@@ -3227,8 +3318,8 @@ var AppAuthInvalidError = class extends Error {
 };
 
 // src/server/context-logger.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var logContextStorage = new AsyncLocalStorage2();
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+var logContextStorage = new AsyncLocalStorage3();
 function runWithLogContext(context, fn) {
   return logContextStorage.run(context, fn);
 }
@@ -3441,9 +3532,17 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         baseUrl: toolEnv.SKEDYUL_API_URL ?? "",
         apiToken: toolEnv.SKEDYUL_API_TOKEN ?? ""
       };
+      const rateLimitContext = {
+        app,
+        appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
+        invocation,
+        isProvisionContext: trigger === "provision"
+      };
       const functionResult = await runWithConfig(requestConfig, async () => {
-        return await runWithLogContext({ invocation }, async () => {
-          return await fn(inputs, executionContext);
+        return await runWithRateLimitExecutionContext(rateLimitContext, async () => {
+          return await runWithLogContext({ invocation }, async () => {
+            return await fn(inputs, executionContext);
+          });
         });
       });
       const billing = normalizeBilling(functionResult.billing);
@@ -3580,7 +3679,7 @@ function printStartupLog(config, tools, port) {
 
 // src/server/route-handlers/adapters.ts
 function fromLambdaEvent(event2) {
-  const path5 = event2.path || event2.rawPath || "/";
+  const path6 = event2.path || event2.rawPath || "/";
   const method = event2.httpMethod || event2.requestContext?.http?.method || "POST";
   const forwardedProto = event2.headers?.["x-forwarded-proto"] ?? event2.headers?.["X-Forwarded-Proto"];
   const protocol = forwardedProto ?? "https";
@@ -3588,9 +3687,9 @@ function fromLambdaEvent(event2) {
   const queryString = event2.queryStringParameters ? "?" + new URLSearchParams(
     event2.queryStringParameters
   ).toString() : "";
-  const url = `${protocol}://${host}${path5}${queryString}`;
+  const url = `${protocol}://${host}${path6}${queryString}`;
   return {
-    path: path5,
+    path: path6,
     method,
     headers: event2.headers,
     query: event2.queryStringParameters ?? {},
@@ -3672,8 +3771,8 @@ function parseBodyByContentType(req) {
 }
 
 // src/server/route-handlers/handlers.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 
 // src/server/core-api-handler.ts
 async function handleCoreMethod(method, params) {
@@ -3841,7 +3940,8 @@ function serializeConfig(config) {
       type: w.type ?? "WEBHOOK"
     })) : [],
     provision: isProvisionConfig(config.provision) ? config.provision : void 0,
-    agents: config.agents
+    agents: config.agents,
+    queues: config.queues
   };
 }
 function isProvisionConfig(value) {
@@ -4137,7 +4237,7 @@ async function handleOAuthCallback(parsedBody, hooks) {
 }
 
 // src/server/handlers/webhook-handler.ts
-function parseWebhookRequest(parsedBody, method, url, path5, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
+function parseWebhookRequest(parsedBody, method, url, path6, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
   const isEnvelope = typeof parsedBody === "object" && parsedBody !== null && "env" in parsedBody && "request" in parsedBody && "context" in parsedBody;
   if (isEnvelope) {
     const envelope = parsedBody;
@@ -4191,7 +4291,7 @@ function parseWebhookRequest(parsedBody, method, url, path5, headers, query, raw
   const webhookRequest = {
     method,
     url,
-    path: path5,
+    path: path6,
     headers,
     query,
     body: parsedBody,
@@ -4249,7 +4349,7 @@ function isMethodAllowed(webhookRegistry, handle, method) {
 
 // src/server/route-handlers/handlers.ts
 function getConfigFilePath() {
-  return process.env.LAMBDA_TASK_ROOT ? path.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
+  return process.env.LAMBDA_TASK_ROOT ? path2.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
 }
 function findToolInRegistry(registry, toolName) {
   for (const [key, t] of Object.entries(registry)) {
@@ -4288,8 +4388,8 @@ function handleHealthRoute(ctx) {
 function handleConfigRoute(ctx) {
   const configFilePath = getConfigFilePath();
   try {
-    if (fs.existsSync(configFilePath)) {
-      const fileConfig = JSON.parse(fs.readFileSync(configFilePath, "utf-8"));
+    if (fs2.existsSync(configFilePath)) {
+      const fileConfig = JSON.parse(fs2.readFileSync(configFilePath, "utf-8"));
       return { status: 200, body: fileConfig };
     }
   } catch (err) {
@@ -4974,6 +5074,7 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer) {
 installContextLogger();
 function createSkedyulServer(config) {
   mergeRuntimeEnv();
+  registerQueueConfig(config);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
   if (config.coreApi?.service) {
@@ -5242,8 +5343,8 @@ function defineNavigation(navigation) {
 }
 
 // src/config/loader.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import * as os from "os";
 var CONFIG_FILE_NAMES = [
   "skedyul.config.ts",
@@ -5252,13 +5353,13 @@ var CONFIG_FILE_NAMES = [
   "skedyul.config.cjs"
 ];
 async function transpileTypeScript(filePath) {
-  const content = fs2.readFileSync(filePath, "utf-8");
-  const configDir = path2.dirname(path2.resolve(filePath));
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const configDir = path3.dirname(path3.resolve(filePath));
   let transpiled = content.replace(/import\s+type\s+\{[^}]+\}\s+from\s+['"][^'"]+['"]\s*;?\n?/g, "").replace(/import\s+\{\s*defineConfig\s*\}\s+from\s+['"]skedyul['"]\s*;?\n?/g, "").replace(/:\s*SkedyulConfig/g, "").replace(/export\s+default\s+/, "module.exports = ").replace(/defineConfig\s*\(\s*\{/, "{").replace(/\}\s*\)\s*;?\s*$/, "}");
   transpiled = transpiled.replace(
     /import\s+(\w+)\s+from\s+['"](\.[^'"]+)['"]\s*(?:with\s*\{[^}]*\})?/g,
     (match, varName, relativePath) => {
-      const absolutePath = path2.resolve(configDir, relativePath);
+      const absolutePath = path3.resolve(configDir, relativePath);
       return `const ${varName} = require('${absolutePath.replace(/\\/g, "/")}')`;
     }
   );
@@ -5266,8 +5367,8 @@ async function transpileTypeScript(filePath) {
   return transpiled;
 }
 async function loadConfig(configPath) {
-  const absolutePath = path2.resolve(configPath);
-  if (!fs2.existsSync(absolutePath)) {
+  const absolutePath = path3.resolve(configPath);
+  if (!fs3.existsSync(absolutePath)) {
     throw new Error(`Config file not found: ${absolutePath}`);
   }
   const isTypeScript = absolutePath.endsWith(".ts");
@@ -5276,8 +5377,8 @@ async function loadConfig(configPath) {
     if (isTypeScript) {
       const transpiled = await transpileTypeScript(absolutePath);
       const tempDir = os.tmpdir();
-      const tempFile = path2.join(tempDir, `skedyul-config-${Date.now()}.cjs`);
-      fs2.writeFileSync(tempFile, transpiled);
+      const tempFile = path3.join(tempDir, `skedyul-config-${Date.now()}.cjs`);
+      fs3.writeFileSync(tempFile, transpiled);
       moduleToLoad = tempFile;
       try {
         const module2 = __require(moduleToLoad);
@@ -5291,7 +5392,7 @@ async function loadConfig(configPath) {
         return config2;
       } finally {
         try {
-          fs2.unlinkSync(tempFile);
+          fs3.unlinkSync(tempFile);
         } catch {
         }
       }
@@ -5326,13 +5427,13 @@ function validateConfig(config) {
 }
 
 // src/config/schema-loader.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import * as os2 from "os";
 
 // src/config/resolver.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 
 // src/config/utils.ts
 function getAllEnvKeys(config) {
@@ -5349,6 +5450,553 @@ function getRequiredInstallEnvKeys(config) {
   return Object.entries(provision.env).filter(([, def]) => def.required).map(([key]) => key);
 }
 
+// src/ratelimit/errors.ts
+var QueueContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "QUEUE_CONTEXT_ERROR";
+    this.name = "QueueContextError";
+  }
+};
+var QueueNotFoundError = class extends Error {
+  constructor(queueName) {
+    super(`Queue "${queueName}" is not defined in skedyul.config queues`);
+    this.code = "QUEUE_NOT_FOUND";
+    this.name = "QueueNotFoundError";
+  }
+};
+var QueuedFetchExhaustedError = class extends Error {
+  constructor(attempts, maxRetries, causeError) {
+    super(
+      `queuedFetch exhausted retries after ${attempts} attempts (maxRetries=${maxRetries})`
+    );
+    this.code = "QUEUED_FETCH_EXHAUSTED";
+    this.name = "QueuedFetchExhaustedError";
+    this.attempts = attempts;
+    this.maxRetries = maxRetries;
+    this.causeError = causeError;
+  }
+};
+var RequeueOutsideContextError = class extends Error {
+  constructor() {
+    super("requeue() can only be called inside an active queuedFetch operation");
+    this.code = "REQUEUE_OUTSIDE_CONTEXT";
+    this.name = "RequeueOutsideContextError";
+  }
+};
+var RateLimitBackendError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.code = "RATE_LIMIT_BACKEND_ERROR";
+    this.name = "RateLimitBackendError";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/ratelimit/resolve-queue-key.ts
+function resolveEndpointHandle(config, invocation) {
+  if (config.endpoint) {
+    return config.endpoint;
+  }
+  if (invocation?.toolHandle) {
+    return invocation.toolHandle;
+  }
+  if (invocation?.serverHookHandle) {
+    return invocation.serverHookHandle;
+  }
+  throw new QueueContextError(
+    `Cannot resolve endpoint handle for queue scope "${config.scope}". Set endpoint in queue config or ensure invocation.toolHandle/serverHookHandle is available.`
+  );
+}
+function appendSubKey(base, subKey) {
+  return subKey ? `${base}:${subKey}` : base;
+}
+function resolveQueueKey(queueName, config, ctx, subKey) {
+  const { app, appInstallationId, invocation, isProvisionContext: isProvisionContext2 } = ctx;
+  switch (config.scope) {
+    case "provision": {
+      const base = `rl:pv:${app.versionId}:${queueName}`;
+      return appendSubKey(base, subKey);
+    }
+    case "install": {
+      if (!appInstallationId) {
+        throw new QueueContextError(
+          `Queue "${queueName}" with scope "install" requires appInstallationId in context`
+        );
+      }
+      const base = `rl:in:${appInstallationId}:${queueName}`;
+      return appendSubKey(base, subKey);
+    }
+    case "provision_endpoint": {
+      if (!isProvisionContext2 && appInstallationId) {
+        throw new QueueContextError(
+          `Queue "${queueName}" with scope "provision_endpoint" requires provision context (no install)`
+        );
+      }
+      const endpointHandle = resolveEndpointHandle(config, invocation);
+      const base = `rl:pep:${app.versionId}:${endpointHandle}:${queueName}`;
+      return appendSubKey(base, subKey);
+    }
+    case "install_endpoint": {
+      if (!appInstallationId) {
+        throw new QueueContextError(
+          `Queue "${queueName}" with scope "install_endpoint" requires appInstallationId in context`
+        );
+      }
+      const endpointHandle = resolveEndpointHandle(config, invocation);
+      const base = `rl:iep:${appInstallationId}:${endpointHandle}:${queueName}`;
+      return appendSubKey(base, subKey);
+    }
+    case "global": {
+      const base = `rl:gl:${app.versionId}:${queueName}`;
+      return appendSubKey(base, subKey);
+    }
+    default: {
+      const _exhaustive = config.scope;
+      throw new QueueContextError(`Unknown queue scope: ${String(_exhaustive)}`);
+    }
+  }
+}
+function toQueueLimits(config) {
+  return {
+    maxConcurrent: config.maxConcurrent,
+    minTime: config.minTime,
+    reservoir: config.reservoir,
+    reservoirRefreshAmount: config.reservoirRefreshAmount,
+    reservoirRefreshInterval: config.reservoirRefreshInterval
+  };
+}
+
+// src/ratelimit/backends/platform.ts
+function getApiBaseUrl() {
+  const config = getConfig();
+  if (config.baseUrl) {
+    return config.baseUrl.replace(/\/+$/, "");
+  }
+  return (process.env.SKEDYUL_API_URL ?? process.env.SKEDYUL_NODE_URL ?? "").replace(/\/+$/, "");
+}
+function getApiToken() {
+  const config = getConfig();
+  return config.apiToken || process.env.SKEDYUL_API_TOKEN || "";
+}
+async function callRateLimitApi(path6, body) {
+  const baseUrl = getApiBaseUrl();
+  const token2 = getApiToken();
+  if (!baseUrl || !token2) {
+    throw new RateLimitBackendError(
+      "SKEDYUL_API_URL and SKEDYUL_API_TOKEN are required for platform rate limiting"
+    );
+  }
+  const response = await fetch(`${baseUrl}/api/internal/ratelimit/${path6}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token2}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || payload?.success === false) {
+    const message = payload?.errors?.[0]?.message ?? `Rate limit API ${path6} failed with status ${response.status}`;
+    throw new RateLimitBackendError(message, response.status);
+  }
+  if (!payload?.data) {
+    throw new RateLimitBackendError(`Rate limit API ${path6} returned empty data`);
+  }
+  return payload.data;
+}
+var PlatformRateLimitBackend = class {
+  async acquire(queueKey, limits, timeoutMs) {
+    const data = await callRateLimitApi("acquire", {
+      queueKey,
+      limits,
+      timeoutMs
+    });
+    return {
+      leaseId: data.leaseId,
+      acquiredAt: data.acquiredAt,
+      queueKey: data.queueKey
+    };
+  }
+  async release(lease) {
+    await callRateLimitApi("release", {
+      leaseId: lease.leaseId
+    });
+  }
+};
+var platformRateLimitBackend = new PlatformRateLimitBackend();
+
+// src/ratelimit/backends/memory.ts
+var DEFAULT_MAX_CONCURRENT = 10;
+function getMaxConcurrent(limits) {
+  return limits.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+}
+function getMinTime(limits) {
+  return limits.minTime ?? 0;
+}
+function generateLeaseId() {
+  return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function refillTokens(state, limits) {
+  if (limits.reservoir === void 0) {
+    return;
+  }
+  const capacity = limits.reservoir;
+  const refreshAmount = limits.reservoirRefreshAmount ?? limits.reservoir;
+  const refreshInterval = limits.reservoirRefreshInterval ?? 6e4;
+  const now = Date.now();
+  const elapsed = now - state.lastRefillAt;
+  if (elapsed >= refreshInterval) {
+    const intervals = Math.floor(elapsed / refreshInterval);
+    state.tokens = Math.min(capacity, state.tokens + intervals * refreshAmount);
+    state.lastRefillAt = now;
+  }
+}
+function canAcquire(state, limits) {
+  if (state.running >= getMaxConcurrent(limits)) {
+    return false;
+  }
+  refillTokens(state, limits);
+  if (limits.reservoir !== void 0 && state.tokens <= 0) {
+    return false;
+  }
+  const minTime = getMinTime(limits);
+  if (minTime > 0 && state.lastStartAt > 0) {
+    if (Date.now() - state.lastStartAt < minTime) {
+      return false;
+    }
+  }
+  return true;
+}
+var MemoryRateLimitBackend = class {
+  constructor() {
+    this.queues = /* @__PURE__ */ new Map();
+    this.leases = /* @__PURE__ */ new Map();
+  }
+  getState(queueKey) {
+    let state = this.queues.get(queueKey);
+    if (!state) {
+      state = {
+        running: 0,
+        waiters: [],
+        lastStartAt: 0,
+        tokens: Number.POSITIVE_INFINITY,
+        lastRefillAt: Date.now()
+      };
+      if (queueKey.includes(":")) {
+      }
+      this.queues.set(queueKey, state);
+    }
+    return state;
+  }
+  grant(state, queueKey, limits) {
+    if (limits.reservoir !== void 0) {
+      state.tokens -= 1;
+    }
+    state.running += 1;
+    state.lastStartAt = Date.now();
+    const leaseId = generateLeaseId();
+    this.leases.set(leaseId, { queueKey, limits });
+    return { leaseId, acquiredAt: Date.now(), queueKey };
+  }
+  drainWaiters(queueKey, state) {
+    let progressed = true;
+    while (progressed && state.waiters.length > 0) {
+      progressed = false;
+      for (let i = 0; i < state.waiters.length; i += 1) {
+        const waiter = state.waiters[i];
+        if (!waiter || !canAcquire(state, waiter.limits)) {
+          continue;
+        }
+        state.waiters.splice(i, 1);
+        if (waiter.timer) {
+          clearTimeout(waiter.timer);
+        }
+        waiter.resolve(this.grant(state, queueKey, waiter.limits));
+        progressed = true;
+        break;
+      }
+    }
+  }
+  async acquire(queueKey, limits, timeoutMs = 12e4) {
+    const state = this.getState(queueKey);
+    if (limits.reservoir !== void 0 && state.tokens === Number.POSITIVE_INFINITY) {
+      state.tokens = limits.reservoir;
+    }
+    if (canAcquire(state, limits)) {
+      return this.grant(state, queueKey, limits);
+    }
+    return new Promise((resolve4, reject) => {
+      const waiter = {
+        resolve: resolve4,
+        reject,
+        timer: null,
+        limits
+      };
+      if (timeoutMs > 0) {
+        waiter.timer = setTimeout(() => {
+          const idx = state.waiters.indexOf(waiter);
+          if (idx >= 0) {
+            state.waiters.splice(idx, 1);
+          }
+          reject(
+            new Error(`Rate limit acquire timed out after ${timeoutMs}ms for ${queueKey}`)
+          );
+        }, timeoutMs);
+      }
+      state.waiters.push(waiter);
+      const retry = () => {
+        if (!state.waiters.includes(waiter)) {
+          return;
+        }
+        if (canAcquire(state, limits)) {
+          const idx = state.waiters.indexOf(waiter);
+          if (idx >= 0) {
+            state.waiters.splice(idx, 1);
+          }
+          if (waiter.timer) {
+            clearTimeout(waiter.timer);
+          }
+          resolve4(this.grant(state, queueKey, limits));
+          return;
+        }
+        setTimeout(retry, Math.max(getMinTime(limits), 10));
+      };
+      setTimeout(retry, Math.max(getMinTime(limits), 10));
+    });
+  }
+  async release(lease) {
+    const tracked = this.leases.get(lease.leaseId);
+    this.leases.delete(lease.leaseId);
+    const queueKey = tracked?.queueKey ?? lease.queueKey;
+    const state = this.queues.get(queueKey);
+    if (!state) {
+      return;
+    }
+    state.running = Math.max(0, state.running - 1);
+    this.drainWaiters(queueKey, state);
+  }
+};
+var memoryRateLimitBackend = new MemoryRateLimitBackend();
+
+// src/ratelimit/backends/index.ts
+var cachedBackend = null;
+function shouldForceMemoryBackend() {
+  const flag = process.env.SKEDYUL_RATE_LIMIT_MEMORY;
+  return flag === "1" || flag === "true";
+}
+function getRateLimitBackend() {
+  if (cachedBackend) {
+    return cachedBackend;
+  }
+  if (shouldForceMemoryBackend()) {
+    cachedBackend = memoryRateLimitBackend;
+    return cachedBackend;
+  }
+  cachedBackend = createResilientBackend();
+  return cachedBackend;
+}
+function createResilientBackend() {
+  return {
+    async acquire(queueKey, limits, timeoutMs) {
+      try {
+        return await platformRateLimitBackend.acquire(queueKey, limits, timeoutMs);
+      } catch (error) {
+        if (shouldFallbackToMemory(error)) {
+          return memoryRateLimitBackend.acquire(queueKey, limits, timeoutMs);
+        }
+        throw error;
+      }
+    },
+    async release(lease) {
+      if (lease.leaseId.startsWith("mem_")) {
+        return memoryRateLimitBackend.release(lease);
+      }
+      try {
+        await platformRateLimitBackend.release(lease);
+      } catch (error) {
+        if (shouldFallbackToMemory(error)) {
+          return memoryRateLimitBackend.release(lease);
+        }
+        throw error;
+      }
+    }
+  };
+}
+function shouldFallbackToMemory(error) {
+  if (shouldForceMemoryBackend()) {
+    return true;
+  }
+  if (error instanceof RateLimitBackendError) {
+    if (error.statusCode === 404 || error.statusCode === 503) {
+      return true;
+    }
+  }
+  if (error instanceof TypeError) {
+    return true;
+  }
+  const nodeEnv = process.env.NODE_ENV;
+  return nodeEnv === "development" || nodeEnv === "test";
+}
+
+// src/ratelimit/should-retry.ts
+var DEFAULT_RETRY_STATUS_CODES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+function getErrorStatusCode(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const record2 = error;
+  if (typeof record2.statusCode === "number") {
+    return record2.statusCode;
+  }
+  if (typeof record2.status === "number") {
+    return record2.status;
+  }
+  return void 0;
+}
+function getErrorCode(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const record2 = error;
+  return typeof record2.code === "string" ? record2.code : void 0;
+}
+function defaultShouldRetry(error, _attempt) {
+  const code = getErrorCode(error);
+  if (code === "RATE_LIMITED" || code === "RATE_LIMIT_BACKEND_ERROR") {
+    return true;
+  }
+  const status = getErrorStatusCode(error);
+  if (status !== void 0 && DEFAULT_RETRY_STATUS_CODES.has(status)) {
+    return true;
+  }
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  const lower = message.toLowerCase();
+  if (lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("econnreset") || lower.includes("etimedout")) {
+    return true;
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+
+// src/ratelimit/queued-fetch.ts
+function normalizeQueueInput(input) {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return { name: input.queue, subKey: input.key };
+}
+function resolveQueue(queueInput, ctxOverride) {
+  const ctx = ctxOverride ?? getRateLimitExecutionContext();
+  if (!ctx?.app?.versionId) {
+    throw new QueueContextError(
+      "Cannot resolve queue without app context. Ensure queuedFetch runs inside a tool/hook handler."
+    );
+  }
+  const { name, subKey } = normalizeQueueInput(queueInput);
+  const config = getQueueConfigWithRetry(name);
+  if (!config) {
+    throw new QueueNotFoundError(name);
+  }
+  const queueKey = resolveQueueKey(name, config, ctx, subKey);
+  return {
+    name,
+    queueKey,
+    config,
+    limits: toQueueLimits(config)
+  };
+}
+function createQueueHandle(queueInput) {
+  return {
+    run(fn) {
+      return queuedFetch(queueInput, fn);
+    }
+  };
+}
+async function queuedFetch(queueInput, fnOrPromise) {
+  const fn = typeof fnOrPromise === "function" ? fnOrPromise : () => fnOrPromise;
+  const resolved = resolveQueue(queueInput);
+  const maxRetries = resolved.config.maxRetries ?? 0;
+  const operation = {
+    queueInput,
+    fn,
+    attempt: 0,
+    resolved,
+    lease: null
+  };
+  return runWithActiveQueuedOperation(
+    operation,
+    () => executeWithRetries(operation, maxRetries)
+  );
+}
+async function executeWithRetries(operation, maxRetries) {
+  const backend = getRateLimitBackend();
+  const timeoutMs = operation.resolved.config.timeout ?? 12e4;
+  const retryDelayMs = operation.resolved.config.retryDelayMs ?? 1e3;
+  const shouldRetryFn = getQueueConfigWithRetry(operation.resolved.name)?.shouldRetry ?? defaultShouldRetry;
+  const lease = await backend.acquire(
+    operation.resolved.queueKey,
+    operation.resolved.limits,
+    timeoutMs
+  );
+  operation.lease = lease;
+  setActiveQueuedOperationLease(lease);
+  try {
+    return await operation.fn();
+  } catch (error) {
+    await backend.release(lease);
+    operation.lease = null;
+    setActiveQueuedOperationLease(null);
+    if (shouldRetryFn(error, operation.attempt) && operation.attempt < maxRetries) {
+      await sleep(retryDelayMs);
+      operation.attempt += 1;
+      updateActiveQueuedOperationAttempt(operation.attempt);
+      return executeWithRetries(operation, maxRetries);
+    }
+    if (shouldRetryFn(error, operation.attempt) && operation.attempt >= maxRetries) {
+      throw new QueuedFetchExhaustedError(
+        operation.attempt + 1,
+        maxRetries,
+        error
+      );
+    }
+    throw error;
+  } finally {
+    if (operation.lease) {
+      await backend.release(operation.lease);
+      operation.lease = null;
+      setActiveQueuedOperationLease(null);
+    }
+  }
+}
+async function requeue() {
+  const operation = getActiveQueuedOperation();
+  if (!operation) {
+    throw new RequeueOutsideContextError();
+  }
+  const maxRetries = operation.resolved.config.maxRetries ?? 0;
+  const nextAttempt = operation.attempt + 1;
+  if (nextAttempt > maxRetries) {
+    throw new QueuedFetchExhaustedError(nextAttempt, maxRetries, void 0);
+  }
+  if (operation.lease) {
+    const backend = getRateLimitBackend();
+    await backend.release(operation.lease);
+    operation.lease = null;
+    setActiveQueuedOperationLease(null);
+  }
+  operation.attempt = nextAttempt;
+  updateActiveQueuedOperationAttempt(nextAttempt);
+  const retryDelayMs = operation.resolved.config.retryDelayMs ?? 1e3;
+  await sleep(retryDelayMs);
+  return executeWithRetries(operation, maxRetries);
+}
+async function queuedFetchResponse(queueInput, url, init) {
+  return queuedFetch(queueInput, () => fetch(url, init));
+}
+
 // src/triggers/types.ts
 import { z as z11 } from "zod/v4";
 var CRMDataSchema = z11.object({
@@ -5453,16 +6101,16 @@ function evaluateTemplate(template, context) {
   const templateRegex = /\{\{\s*([^}]+)\s*\}\}/g;
   const singleMatch = template.match(/^\{\{\s*([^}]+)\s*\}\}$/);
   if (singleMatch) {
-    const path5 = singleMatch[1].trim();
-    return resolvePath(context, path5);
+    const path6 = singleMatch[1].trim();
+    return resolvePath(context, path6);
   }
-  return template.replace(templateRegex, (_, path5) => {
-    const value = resolvePath(context, path5.trim());
+  return template.replace(templateRegex, (_, path6) => {
+    const value = resolvePath(context, path6.trim());
     return value === void 0 || value === null ? "" : String(value);
   });
 }
-function resolvePath(obj, path5) {
-  const parts = path5.split(".");
+function resolvePath(obj, path6) {
+  const parts = path6.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -5483,14 +6131,14 @@ function evaluateCondition(condition, context) {
   const expression = match[1].trim();
   const eqMatch = expression.match(/^(.+?)\s*==\s*['"](.+)['"]$/);
   if (eqMatch) {
-    const [, path5, expectedValue] = eqMatch;
-    const actualValue = resolvePath(context, path5.trim());
+    const [, path6, expectedValue] = eqMatch;
+    const actualValue = resolvePath(context, path6.trim());
     return actualValue === expectedValue;
   }
   const neqMatch = expression.match(/^(.+?)\s*!=\s*['"](.+)['"]$/);
   if (neqMatch) {
-    const [, path5, expectedValue] = neqMatch;
-    const actualValue = resolvePath(context, path5.trim());
+    const [, path6, expectedValue] = neqMatch;
+    const actualValue = resolvePath(context, path6.trim());
     return actualValue !== expectedValue;
   }
   const value = resolvePath(context, expression);
@@ -6854,10 +7502,15 @@ export {
   ParticipantEventPayloadSchema,
   ParticipantKindSchema,
   ProvisionConfigSchema,
+  QueueContextError,
+  QueueNotFoundError,
+  QueuedFetchExhaustedError,
+  RateLimitBackendError,
   RelationshipCardinalitySchema,
   RelationshipDefinitionSchema,
   RelationshipExtensionSchema,
   RelationshipLinkSchema,
+  RequeueOutsideContextError,
   ResolvedSkillSchema,
   ResolvedTriggerSchema,
   ResourceDependencySchema,
@@ -6935,6 +7588,7 @@ export {
   createListResponse,
   createNotFoundError,
   createPermissionError,
+  createQueueHandle,
   createRateLimitError,
   createServerHookContext,
   createSuccessResponse,
@@ -6945,6 +7599,7 @@ export {
   createWorkflowStepContext,
   cron,
   src_default as default,
+  defaultShouldRetry,
   defineAgent,
   defineChannel,
   defineConfig,
@@ -6967,6 +7622,7 @@ export {
   getConfig,
   getContextByHandle,
   getContextByModel,
+  getRateLimitExecutionContext,
   getRequiredInstallEnvKeys,
   getRetryDelay,
   instance,
@@ -6986,10 +7642,16 @@ export {
   loadConfig,
   matchesTrigger,
   parseCRMSchema,
+  queuedFetch,
+  queuedFetchResponse,
+  registerQueueConfig,
   report,
+  requeue,
   resolveInputMappings,
+  resolveQueue,
   resource,
   runWithConfig,
+  runWithRateLimitExecutionContext,
   safeParseCRMSchema,
   safeParseConfig,
   server,