skedyul 1.5.13 → 1.6.0

package/dist/index.js

@@ -199,6 +199,10 @@ __export(index_exports, {
   SelectComponentDefinitionSchema: () => SelectComponentDefinitionSchema,
   SemanticMemoryConfigSchema: () => SemanticMemoryConfigSchema2,
   SenderContextSchema: () => SenderContextSchema,
+  SequencerBackendError: () => SequencerBackendError,
+  SequencerContextError: () => SequencerContextError,
+  SequencerLockError: () => SequencerLockError,
+  SequencerNotFoundError: () => SequencerNotFoundError,
   SkedyulConfigSchema: () => SkedyulConfigSchema,
   SkillExampleSchema: () => SkillExampleSchema,
   SkillMetadataSchema: () => SkillMetadataSchema,
@@ -254,6 +258,7 @@ __export(index_exports, {
   buildAgentContext: () => buildAgentContext,
   calculateWaitTime: () => calculateWaitTime,
   call: () => call,
+  clearRegisteredSequencerConfig: () => clearRegisteredSequencerConfig,
   communicationChannel: () => communicationChannel,
   compileAgent: () => compileAgent,
   compileWorkflow: () => compileWorkflow,
@@ -273,6 +278,7 @@ __export(index_exports, {
   createPermissionError: () => createPermissionError,
   createQueueHandle: () => createQueueHandle,
   createRateLimitError: () => createRateLimitError,
+  createSequencerHandle: () => createSequencerHandle,
   createServerHookContext: () => createServerHookContext,
   createSuccessResponse: () => createSuccessResponse,
   createTimeoutError: () => createTimeoutError,
@@ -311,6 +317,8 @@ __export(index_exports, {
   getRateLimitExecutionContext: () => getRateLimitExecutionContext,
   getRequiredInstallEnvKeys: () => getRequiredInstallEnvKeys,
   getRetryDelay: () => getRetryDelay,
+  getSequencerConfig: () => getSequencerConfig,
+  getSequencerDefinitions: () => getSequencerDefinitions,
   instance: () => instance,
   isChannelDependency: () => isChannelDependency,
   isCronContext: () => isCronContext,
@@ -326,20 +334,29 @@ __export(index_exports, {
   isTimeInWindowSlot: () => isTimeInWindowSlot2,
   isWorkflowDependency: () => isWorkflowDependency,
   matchesTrigger: () => matchesTrigger,
+  memorySequencerBackend: () => memorySequencerBackend,
   parseCRMSchema: () => parseCRMSchema,
   parseEstimationFromBilling: () => parseEstimationFromBilling,
+  platformSequencerBackend: () => platformSequencerBackend,
   queuedFetch: () => queuedFetch,
   queuedFetchResponse: () => queuedFetchResponse,
   registerQueueConfig: () => registerQueueConfig,
+  registerSequencerConfig: () => registerSequencerConfig,
   report: () => report,
   requeue: () => requeue,
+  resetSequencerBackendForTests: () => resetSequencerBackendForTests,
   resolveInputMappings: () => resolveInputMappings,
   resolveQueue: () => resolveQueue,
+  resolveSequencer: () => resolveSequencer,
   resource: () => resource,
   runWithConfig: () => runWithConfig,
   runWithRateLimitExecutionContext: () => runWithRateLimitExecutionContext,
   safeParseCRMSchema: () => safeParseCRMSchema,
   safeParseConfig: () => safeParseConfig,
+  sequencer: () => sequencer,
+  sequencerAcquire: () => acquire,
+  sequencerAllow: () => allow,
+  sequencerRelease: () => release,
   server: () => server,
   toGsm7: () => toGsm7,
   token: () => token,
@@ -760,6 +777,8 @@ var CRMPageSchemaZ = import_v43.z.object({
   icon: import_v43.z.string().optional(),
   modelHandle: import_v43.z.string(),
   parentPath: import_v43.z.string().optional(),
+  isDefault: import_v43.z.boolean().optional(),
+  visibility: import_v43.z.enum(["team", "private"]).optional(),
   baseQuery: import_v43.z.unknown().optional(),
   blocks: import_v43.z.array(CRMBlockSchemaZ).optional()
 });
@@ -1635,7 +1654,8 @@ var ModelDefinitionSchema = import_v48.z.object({
   addDefaultPages: import_v48.z.boolean().optional(),
   addNavigation: import_v48.z.boolean().optional(),
   /** Root path for developer resource UI (e.g., '/access_requests'). Links internal model to a provision.pages entry. */
-  page: import_v48.z.string().optional()
+  page: import_v48.z.string().optional(),
+  env: EnvSchemaSchema.optional()
 });
 var RelationshipCardinalitySchema = import_v48.z.enum([
   "ONE_TO_ONE",
@@ -2447,6 +2467,56 @@ function getQueueConfigWithRetry(queueName) {
   return serializable;
 }
 
+// src/sequencer/config-loader.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var cachedRuntimeSequencers = null;
+function getRuntimeConfigPath2() {
+  if (process.env.LAMBDA_TASK_ROOT) {
+    return path2.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json");
+  }
+  return path2.join(process.cwd(), ".skedyul", "config.json");
+}
+function loadRuntimeConfigFile2() {
+  const configPath = getRuntimeConfigPath2();
+  if (!fs2.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const raw = fs2.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var registeredServerConfig2 = null;
+function registerSequencerConfig(config) {
+  registeredServerConfig2 = config;
+  cachedRuntimeSequencers = config.sequencers ?? null;
+}
+function clearRegisteredSequencerConfig() {
+  registeredServerConfig2 = null;
+  cachedRuntimeSequencers = null;
+}
+function getSequencerDefinitions() {
+  if (cachedRuntimeSequencers) {
+    return cachedRuntimeSequencers;
+  }
+  if (registeredServerConfig2?.sequencers) {
+    cachedRuntimeSequencers = registeredServerConfig2.sequencers;
+    return cachedRuntimeSequencers;
+  }
+  const fileConfig = loadRuntimeConfigFile2();
+  if (fileConfig?.sequencers) {
+    cachedRuntimeSequencers = fileConfig.sequencers;
+    return cachedRuntimeSequencers;
+  }
+  return {};
+}
+function getSequencerConfig(sequencerName) {
+  return getSequencerDefinitions()[sequencerName];
+}
+
 // src/server/utils/schema.ts
 var z9 = __toESM(require("zod"));
 function normalizeBilling(billing) {
@@ -2853,25 +2923,28 @@ function createInstanceClient(config) {
         pagination: pagination ?? { page: 1, total: 0, hasMore: false, limit: args?.limit ?? 50 }
       };
     },
-    async get(modelHandle, id) {
+    async get(modelHandle, id, options) {
       const { data } = await callCoreWithConfig("instance.get", {
         modelHandle,
-        id
+        id,
+        ...options?.includeEnv ? { includeEnv: true } : {}
       });
       return data;
     },
-    async create(modelHandle, data) {
+    async create(modelHandle, data, options) {
       const { data: inst } = await callCoreWithConfig("instance.create", {
         modelHandle,
-        data
+        data,
+        ...options?.env ? { env: options.env } : {}
       });
       return inst;
     },
-    async update(modelHandle, id, data) {
+    async update(modelHandle, id, data, options) {
       const { data: inst } = await callCoreWithConfig("instance.update", {
         modelHandle,
         id,
-        data
+        data,
+        ...options?.env ? { env: options.env } : {}
       });
       return inst;
     },
@@ -2970,10 +3043,11 @@ var instance = {
    * const record = await instance.get('phone_number', 'ins_abc123')
    * ```
    */
-  async get(modelHandle, id) {
+  async get(modelHandle, id, options) {
     const { data } = await callCore("instance.get", {
       modelHandle,
-      id
+      id,
+      ...options?.includeEnv ? { includeEnv: true } : {}
     });
     return data;
   },
@@ -2990,10 +3064,11 @@ var instance = {
    * })
    * ```
    */
-  async create(modelHandle, data) {
+  async create(modelHandle, data, options) {
     const { data: instance2 } = await callCore("instance.create", {
       modelHandle,
-      data
+      data,
+      ...options?.env ? { env: options.env } : {}
     });
     return instance2;
   },
@@ -3010,11 +3085,12 @@ var instance = {
    * })
    * ```
    */
-  async update(modelHandle, id, data) {
+  async update(modelHandle, id, data, options) {
     const { data: instance2 } = await callCore("instance.update", {
       modelHandle,
       id,
-      data
+      data,
+      ...options?.env ? { env: options.env } : {}
     });
     return instance2;
   },
@@ -4381,7 +4457,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";
@@ -4389,9 +4465,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 ?? {},
@@ -4473,8 +4549,8 @@ function parseBodyByContentType(req) {
 }
 
 // src/server/route-handlers/handlers.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 
 // src/server/core-api-handler.ts
 async function handleCoreMethod(method, params) {
@@ -4942,7 +5018,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;
@@ -4996,7 +5072,7 @@ function parseWebhookRequest(parsedBody, method, url, path5, headers, query, raw
   const webhookRequest = {
     method,
     url,
-    path: path5,
+    path: path6,
     headers,
     query,
     body: parsedBody,
@@ -5025,9 +5101,17 @@ async function executeWebhookHandler(handle, webhookRegistry, data) {
   };
   let webhookResponse;
   try {
+    const rateLimitContext = {
+      app: data.webhookContext.app,
+      appInstallationId: isRuntimeWebhookContext(data.webhookContext) ? data.webhookContext.appInstallationId : void 0,
+      invocation: data.invocation,
+      isProvisionContext: !isRuntimeWebhookContext(data.webhookContext)
+    };
     webhookResponse = await runWithLogContext({ invocation: data.invocation }, async () => {
       return await runWithConfig(requestConfig, async () => {
-        return await webhookDef.handler(data.webhookRequest, data.webhookContext);
+        return await runWithRateLimitExecutionContext(rateLimitContext, async () => {
+          return await webhookDef.handler(data.webhookRequest, data.webhookContext);
+        });
       });
     });
   } catch (err) {
@@ -5054,7 +5138,7 @@ function isMethodAllowed(webhookRegistry, handle, method) {
 
 // src/server/route-handlers/handlers.ts
 function getConfigFilePath() {
-  return process.env.LAMBDA_TASK_ROOT ? path2.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
+  return process.env.LAMBDA_TASK_ROOT ? path3.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
 }
 function findToolInRegistry(registry, toolName) {
   for (const [key, t] of Object.entries(registry)) {
@@ -5093,8 +5177,8 @@ function handleHealthRoute(ctx) {
 function handleConfigRoute(ctx) {
   const configFilePath = getConfigFilePath();
   try {
-    if (fs2.existsSync(configFilePath)) {
-      const fileConfig = JSON.parse(fs2.readFileSync(configFilePath, "utf-8"));
+    if (fs3.existsSync(configFilePath)) {
+      const fileConfig = JSON.parse(fs3.readFileSync(configFilePath, "utf-8"));
       return { status: 200, body: fileConfig };
     }
   } catch (err) {
@@ -5782,6 +5866,7 @@ installContextLogger();
 function createSkedyulServer(config) {
   mergeRuntimeEnv();
   registerQueueConfig(config);
+  registerSequencerConfig(config);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
   if (config.coreApi?.service) {
@@ -6050,13 +6135,13 @@ function defineNavigation(navigation) {
 }
 
 // src/config/schema-loader.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var os = __toESM(require("os"));
 
 // src/config/resolver.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 
 // src/config/utils.ts
 function getAllEnvKeys(config) {
@@ -6159,7 +6244,7 @@ function getApiToken() {
   const config = getConfig();
   return config.apiToken || process.env.SKEDYUL_API_TOKEN || "";
 }
-async function callRateLimitApi(path5, body) {
+async function callRateLimitApi(path6, body) {
   const baseUrl = getApiBaseUrl();
   const token2 = getApiToken();
   if (!baseUrl || !token2) {
@@ -6167,7 +6252,7 @@ async function callRateLimitApi(path5, body) {
       "SKEDYUL_API_URL and SKEDYUL_API_TOKEN are required for platform queue coordination"
     );
   }
-  const response = await fetch(`${baseUrl}/api/internal/ratelimit/${path5}`, {
+  const response = await fetch(`${baseUrl}/api/internal/ratelimit/${path6}`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token2}`,
@@ -6177,11 +6262,11 @@ async function callRateLimitApi(path5, body) {
   });
   const payload = await response.json().catch(() => null);
   if (!response.ok || payload?.success === false) {
-    const message = payload?.errors?.[0]?.message ?? `Queue coordination API ${path5} failed with status ${response.status}`;
+    const message = payload?.errors?.[0]?.message ?? `Queue coordination API ${path6} failed with status ${response.status}`;
     throw new RateLimitBackendError(message, response.status);
   }
   if (!payload?.data) {
-    throw new RateLimitBackendError(`Queue coordination API ${path5} returned empty data`);
+    throw new RateLimitBackendError(`Queue coordination API ${path6} returned empty data`);
   }
   return payload.data;
 }
@@ -6636,6 +6721,406 @@ async function queuedFetchResponse(queueInput, url, init) {
   return queuedFetch(queueInput, () => fetch(url, init));
 }
 
+// src/sequencer/errors.ts
+var SequencerContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "SEQUENCER_CONTEXT_ERROR";
+    this.name = "SequencerContextError";
+  }
+};
+var SequencerNotFoundError = class extends Error {
+  constructor(name) {
+    super(`Sequencer "${name}" is not defined in skedyul.config`);
+    this.code = "SEQUENCER_NOT_FOUND";
+    this.name = "SequencerNotFoundError";
+  }
+};
+var SequencerBackendError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.code = "SEQUENCER_BACKEND_ERROR";
+    this.name = "SequencerBackendError";
+    this.statusCode = statusCode;
+  }
+};
+var SequencerLockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "SEQUENCER_LOCK_ERROR";
+    this.name = "SequencerLockError";
+  }
+};
+
+// src/sequencer/resolve-sequencer-key.ts
+function resolveEndpointHandle2(config, invocation) {
+  if (config.endpoint) {
+    return config.endpoint;
+  }
+  if (invocation?.toolHandle) {
+    return invocation.toolHandle;
+  }
+  if (invocation?.serverHookHandle) {
+    return invocation.serverHookHandle;
+  }
+  throw new SequencerContextError(
+    `Cannot resolve endpoint handle for sequencer scope "${config.scope}". Set endpoint in sequencer config or ensure invocation.toolHandle/serverHookHandle is available.`
+  );
+}
+function appendSubKey2(base, subKey) {
+  return subKey ? `${base}:${subKey}` : base;
+}
+function resolveSequencerKey(sequencerName, config, ctx, subKey) {
+  const { app, appInstallationId, invocation, isProvisionContext: isProvisionContext2 } = ctx;
+  switch (config.scope) {
+    case "provision": {
+      const base = `seq:pv:${app.versionId}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "install": {
+      if (!appInstallationId) {
+        throw new SequencerContextError(
+          `Sequencer "${sequencerName}" with scope "install" requires appInstallationId in context`
+        );
+      }
+      const base = `seq:in:${appInstallationId}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "provision_endpoint": {
+      if (!isProvisionContext2 && appInstallationId) {
+        throw new SequencerContextError(
+          `Sequencer "${sequencerName}" with scope "provision_endpoint" requires provision context (no install)`
+        );
+      }
+      const endpointHandle = resolveEndpointHandle2(config, invocation);
+      const base = `seq:pep:${app.versionId}:${endpointHandle}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "install_endpoint": {
+      if (!appInstallationId) {
+        throw new SequencerContextError(
+          `Sequencer "${sequencerName}" with scope "install_endpoint" requires appInstallationId in context`
+        );
+      }
+      const endpointHandle = resolveEndpointHandle2(config, invocation);
+      const base = `seq:iep:${appInstallationId}:${endpointHandle}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "global": {
+      const base = `seq:gl:${app.versionId}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    default: {
+      const _exhaustive = config.scope;
+      throw new SequencerContextError(`Unknown sequencer scope: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+// src/sequencer/backends/platform.ts
+function getApiBaseUrl2() {
+  const config = getConfig();
+  if (config.baseUrl) {
+    return config.baseUrl.replace(/\/+$/, "");
+  }
+  return (process.env.SKEDYUL_API_URL ?? process.env.SKEDYUL_NODE_URL ?? "").replace(/\/+$/, "");
+}
+function getApiToken2() {
+  const config = getConfig();
+  return config.apiToken || process.env.SKEDYUL_API_TOKEN || "";
+}
+async function callSequencerApi(path6, body) {
+  const baseUrl = getApiBaseUrl2();
+  const token2 = getApiToken2();
+  if (!baseUrl || !token2) {
+    throw new SequencerBackendError(
+      "SKEDYUL_API_URL and SKEDYUL_API_TOKEN are required for platform sequencer coordination"
+    );
+  }
+  const response = await fetch(`${baseUrl}/api/internal/sequencer/${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 ?? `Sequencer coordination API ${path6} failed with status ${response.status}`;
+    throw new SequencerBackendError(message, response.status);
+  }
+  if (!payload?.data) {
+    throw new SequencerBackendError(`Sequencer coordination API ${path6} returned empty data`);
+  }
+  return payload.data;
+}
+var PlatformSequencerBackend = class {
+  async allow(sequencerKey, input) {
+    return callSequencerApi("allow", {
+      sequencerKey,
+      timestamp: input.timestamp,
+      leaseId: input.leaseId,
+      watermarkTtlMs: input.watermarkTtlMs
+    });
+  }
+  async acquire(sequencerKey, input) {
+    return callSequencerApi("acquire", {
+      sequencerKey,
+      leaseId: input.leaseId,
+      timestamp: input.timestamp,
+      lockTtlMs: input.lockTtlMs,
+      watermarkTtlMs: input.watermarkTtlMs
+    });
+  }
+  async release(sequencerKey, leaseId) {
+    await callSequencerApi("release", {
+      sequencerKey,
+      leaseId
+    });
+  }
+};
+var platformSequencerBackend = new PlatformSequencerBackend();
+
+// src/sequencer/backends/memory.ts
+function generateLeaseId2() {
+  return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+var MemorySequencerBackend = class {
+  constructor() {
+    this.state = /* @__PURE__ */ new Map();
+  }
+  getState(sequencerKey) {
+    let state = this.state.get(sequencerKey);
+    if (!state) {
+      state = { watermark: 0, lockLeaseId: null, lockExpiresAt: 0 };
+      this.state.set(sequencerKey, state);
+    }
+    if (state.lockLeaseId && state.lockExpiresAt <= Date.now()) {
+      state.lockLeaseId = null;
+      state.lockExpiresAt = 0;
+    }
+    return state;
+  }
+  async allow(sequencerKey, input) {
+    void input.watermarkTtlMs;
+    const state = this.getState(sequencerKey);
+    if (input.timestamp < state.watermark) {
+      return { allowed: false, reason: "stale", watermark: state.watermark };
+    }
+    if (state.lockLeaseId && input.leaseId && state.lockLeaseId !== input.leaseId) {
+      return { allowed: false, reason: "locked", watermark: state.watermark };
+    }
+    state.watermark = Math.max(state.watermark, input.timestamp);
+    return { allowed: true, reason: "ok", watermark: state.watermark };
+  }
+  async acquire(sequencerKey, input) {
+    void input.watermarkTtlMs;
+    const state = this.getState(sequencerKey);
+    const leaseId = input.leaseId || generateLeaseId2();
+    if (state.lockLeaseId && state.lockLeaseId !== leaseId) {
+      return { acquired: false, reason: "locked" };
+    }
+    state.lockLeaseId = leaseId;
+    state.lockExpiresAt = Date.now() + (input.lockTtlMs ?? 6e4);
+    if (input.timestamp !== void 0) {
+      state.watermark = Math.max(state.watermark, input.timestamp);
+    }
+    return { acquired: true, reason: "ok" };
+  }
+  async release(sequencerKey, leaseId) {
+    const state = this.state.get(sequencerKey);
+    if (!state || state.lockLeaseId !== leaseId) {
+      return;
+    }
+    state.lockLeaseId = null;
+    state.lockExpiresAt = 0;
+  }
+  resetForTests() {
+    this.state.clear();
+  }
+};
+var memorySequencerBackend = new MemorySequencerBackend();
+
+// src/sequencer/backends/index.ts
+var cachedBackend2 = null;
+function shouldForceMemoryBackend2() {
+  const flag = process.env.SKEDYUL_SEQUENCER_MEMORY;
+  return flag === "1" || flag === "true";
+}
+function getSequencerBackend() {
+  if (cachedBackend2) {
+    return cachedBackend2;
+  }
+  if (shouldForceMemoryBackend2()) {
+    cachedBackend2 = memorySequencerBackend;
+    return cachedBackend2;
+  }
+  cachedBackend2 = createResilientBackend2();
+  return cachedBackend2;
+}
+function createResilientBackend2() {
+  return {
+    async allow(sequencerKey, input) {
+      try {
+        return await platformSequencerBackend.allow(sequencerKey, input);
+      } catch (error) {
+        if (shouldFallbackToMemory2(error)) {
+          return memorySequencerBackend.allow(sequencerKey, input);
+        }
+        throw error;
+      }
+    },
+    async acquire(sequencerKey, input) {
+      try {
+        return await platformSequencerBackend.acquire(sequencerKey, input);
+      } catch (error) {
+        if (shouldFallbackToMemory2(error)) {
+          return memorySequencerBackend.acquire(sequencerKey, input);
+        }
+        throw error;
+      }
+    },
+    async release(sequencerKey, leaseId) {
+      if (leaseId.startsWith("mem_")) {
+        return memorySequencerBackend.release(sequencerKey, leaseId);
+      }
+      try {
+        await platformSequencerBackend.release(sequencerKey, leaseId);
+      } catch (error) {
+        if (shouldFallbackToMemory2(error)) {
+          return memorySequencerBackend.release(sequencerKey, leaseId);
+        }
+        throw error;
+      }
+    }
+  };
+}
+function shouldFallbackToMemory2(error) {
+  if (shouldForceMemoryBackend2()) {
+    return true;
+  }
+  if (error instanceof SequencerBackendError) {
+    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";
+}
+function resetSequencerBackendForTests() {
+  cachedBackend2 = null;
+}
+
+// src/sequencer/index.ts
+function normalizeSequencerInput(input) {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return { name: input.sequencer, subKey: input.key };
+}
+function mergeContext(ctxOverride) {
+  const ctx = getRateLimitExecutionContext();
+  if (!ctx?.app?.versionId) {
+    throw new SequencerContextError(
+      "Cannot resolve sequencer without app context. Ensure sequencer runs inside a tool/hook/webhook handler."
+    );
+  }
+  return { ...ctx, ...ctxOverride };
+}
+function resolveSequencer(sequencerInput, ctxOverride) {
+  const ctx = mergeContext(ctxOverride);
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config) {
+    throw new SequencerNotFoundError(name);
+  }
+  const sequencerKey = resolveSequencerKey(name, config, ctx, subKey);
+  return { name, sequencerKey, config };
+}
+function createSequencerHandle(sequencerInput, ctxOverride) {
+  return {
+    allow(input) {
+      return allow(sequencerInput, input, ctxOverride);
+    },
+    acquire(input) {
+      return acquire(sequencerInput, input, ctxOverride);
+    },
+    release(input) {
+      return release(sequencerInput, input, ctxOverride);
+    }
+  };
+}
+function disabledAllowResult() {
+  return { allowed: true, reason: "disabled" };
+}
+async function allow(sequencerInput, input, ctxOverride) {
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config || config.enabled !== true) {
+    return disabledAllowResult();
+  }
+  const resolvedSubKey = input.key ?? subKey;
+  const resolved = resolveSequencer(
+    { sequencer: name, key: resolvedSubKey },
+    ctxOverride
+  );
+  const backend = getSequencerBackend();
+  return backend.allow(resolved.sequencerKey, {
+    timestamp: input.timestamp,
+    leaseId: input.leaseId,
+    watermarkTtlMs: resolved.config.watermarkTtlMs
+  });
+}
+async function acquire(sequencerInput, input, ctxOverride) {
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config || config.enabled !== true) {
+    return;
+  }
+  const resolvedSubKey = input.key ?? subKey;
+  const resolved = resolveSequencer(
+    { sequencer: name, key: resolvedSubKey },
+    ctxOverride
+  );
+  const backend = getSequencerBackend();
+  const result = await backend.acquire(resolved.sequencerKey, {
+    leaseId: input.leaseId,
+    timestamp: input.timestamp,
+    lockTtlMs: input.lockTtlMs ?? resolved.config.lockTtlMs,
+    watermarkTtlMs: resolved.config.watermarkTtlMs
+  });
+  if (!result.acquired) {
+    throw new SequencerLockError(
+      `Sequencer "${name}" lock held by another lease (${result.reason})`
+    );
+  }
+}
+async function release(sequencerInput, input, ctxOverride) {
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config || config.enabled !== true) {
+    return;
+  }
+  const resolvedSubKey = input.key ?? subKey;
+  const resolved = resolveSequencer(
+    { sequencer: name, key: resolvedSubKey },
+    ctxOverride
+  );
+  const backend = getSequencerBackend();
+  await backend.release(resolved.sequencerKey, input.leaseId);
+}
+var sequencer = {
+  allow,
+  acquire,
+  release,
+  resolve: resolveSequencer,
+  createHandle: createSequencerHandle
+};
+
 // src/triggers/types.ts
 var import_v410 = require("zod/v4");
 var CRMDataSchema = import_v410.z.object({
@@ -6740,16 +7225,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) {
@@ -6770,14 +7255,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);
@@ -8230,6 +8715,10 @@ var index_default = { z: import_v414.z };
   SelectComponentDefinitionSchema,
   SemanticMemoryConfigSchema,
   SenderContextSchema,
+  SequencerBackendError,
+  SequencerContextError,
+  SequencerLockError,
+  SequencerNotFoundError,
   SkedyulConfigSchema,
   SkillExampleSchema,
   SkillMetadataSchema,
@@ -8285,6 +8774,7 @@ var index_default = { z: import_v414.z };
   buildAgentContext,
   calculateWaitTime,
   call,
+  clearRegisteredSequencerConfig,
   communicationChannel,
   compileAgent,
   compileWorkflow,
@@ -8304,6 +8794,7 @@ var index_default = { z: import_v414.z };
   createPermissionError,
   createQueueHandle,
   createRateLimitError,
+  createSequencerHandle,
   createServerHookContext,
   createSuccessResponse,
   createTimeoutError,
@@ -8341,6 +8832,8 @@ var index_default = { z: import_v414.z };
   getRateLimitExecutionContext,
   getRequiredInstallEnvKeys,
   getRetryDelay,
+  getSequencerConfig,
+  getSequencerDefinitions,
   instance,
   isChannelDependency,
   isCronContext,
@@ -8356,20 +8849,29 @@ var index_default = { z: import_v414.z };
   isTimeInWindowSlot,
   isWorkflowDependency,
   matchesTrigger,
+  memorySequencerBackend,
   parseCRMSchema,
   parseEstimationFromBilling,
+  platformSequencerBackend,
   queuedFetch,
   queuedFetchResponse,
   registerQueueConfig,
+  registerSequencerConfig,
   report,
   requeue,
+  resetSequencerBackendForTests,
   resolveInputMappings,
   resolveQueue,
+  resolveSequencer,
   resource,
   runWithConfig,
   runWithRateLimitExecutionContext,
   safeParseCRMSchema,
   safeParseConfig,
+  sequencer,
+  sequencerAcquire,
+  sequencerAllow,
+  sequencerRelease,
   server,
   toGsm7,
   token,