skedyul 1.7.3 → 1.7.6

package/dist/.build-stamp

@@ -1 +1 @@
-1785796289915
+1785913911217

package/dist/cli/index.js

@@ -3111,6 +3111,26 @@ function parsePreAcquiredLeases(raw) {
     return void 0;
   }
 }
+function parseHeldMutexQueueKeys(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    const keys = parsed.filter(
+      (item) => item != null && typeof item === "object" && typeof item.queueKey === "string" && typeof item.queueName === "string"
+    ).map((item) => ({
+      queueKey: item.queueKey,
+      queueName: item.queueName
+    }));
+    return keys.length > 0 ? keys : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function buildToolMetadata(registry) {
   return Object.values(registry).map((tool) => {
     const toolConfig = tool.config ?? {};
@@ -3248,7 +3268,10 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
         invocation,
         isProvisionContext: trigger === "provision",
-        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES)
+        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES),
+        heldMutexQueueKeys: parseHeldMutexQueueKeys(
+          toolEnv.SKEDYUL_HELD_MUTEX_QUEUE_KEYS
+        )
       };
       const functionResult = await runWithConfig(requestConfig, async () => {
         return await runWithRateLimitExecutionContext(rateLimitContext, async () => {

package/dist/dedicated/server.js

@@ -441,6 +441,26 @@ function parsePreAcquiredLeases(raw) {
     return void 0;
   }
 }
+function parseHeldMutexQueueKeys(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    const keys = parsed.filter(
+      (item) => item != null && typeof item === "object" && typeof item.queueKey === "string" && typeof item.queueName === "string"
+    ).map((item) => ({
+      queueKey: item.queueKey,
+      queueName: item.queueName
+    }));
+    return keys.length > 0 ? keys : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function buildToolMetadata(registry) {
   return Object.values(registry).map((tool) => {
     const toolConfig = tool.config ?? {};
@@ -578,7 +598,10 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
         invocation,
         isProvisionContext: trigger === "provision",
-        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES)
+        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES),
+        heldMutexQueueKeys: parseHeldMutexQueueKeys(
+          toolEnv.SKEDYUL_HELD_MUTEX_QUEUE_KEYS
+        )
       };
       const functionResult = await runWithConfig(requestConfig, async () => {
         return await runWithRateLimitExecutionContext(rateLimitContext, async () => {

package/dist/esm/index.mjs

@@ -3649,6 +3649,14 @@ function getActiveMutexQueueNames() {
       names.add(operation.resolved.name);
     }
   }
+  const held = getRateLimitExecutionContext()?.heldMutexQueueKeys;
+  if (held?.length) {
+    for (const entry of held) {
+      if (entry.queueName) {
+        names.add(entry.queueName);
+      }
+    }
+  }
   return [...names];
 }
 function shouldSkipNestedAcquire(queueName) {
@@ -3887,6 +3895,26 @@ function parsePreAcquiredLeases(raw) {
     return void 0;
   }
 }
+function parseHeldMutexQueueKeys(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    const keys = parsed.filter(
+      (item) => item != null && typeof item === "object" && typeof item.queueKey === "string" && typeof item.queueName === "string"
+    ).map((item) => ({
+      queueKey: item.queueKey,
+      queueName: item.queueName
+    }));
+    return keys.length > 0 ? keys : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function buildToolMetadata(registry) {
   return Object.values(registry).map((tool) => {
     const toolConfig = tool.config ?? {};
@@ -4024,7 +4052,10 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
         invocation,
         isProvisionContext: trigger === "provision",
-        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES)
+        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES),
+        heldMutexQueueKeys: parseHeldMutexQueueKeys(
+          toolEnv.SKEDYUL_HELD_MUTEX_QUEUE_KEYS
+        )
       };
       const functionResult = await runWithConfig(requestConfig, async () => {
         return await runWithRateLimitExecutionContext(rateLimitContext, async () => {
@@ -6416,6 +6447,11 @@ async function queuedFetch(queueInput, fnOrPromise) {
 function findPreAcquiredLease(queueKey, ctx) {
   return ctx?.preAcquiredLeases?.find((lease) => lease.queueKey === queueKey);
 }
+function isHeldMutexQueueKey(queueKey, ctx) {
+  return Boolean(
+    ctx?.heldMutexQueueKeys?.some((entry) => entry.queueKey === queueKey)
+  );
+}
 function shouldRethrowRateLimitCause(maxRetries, error, attempt, shouldRetryFn) {
   if (maxRetries !== 0 || !shouldRetryFn(error, attempt)) {
     return false;
@@ -6433,10 +6469,14 @@ async function executeWithRetries(operation, maxRetries) {
     operation.resolved.queueKey,
     rateLimitCtx
   );
+  const heldByPlatform = isHeldMutexQueueKey(
+    operation.resolved.queueKey,
+    rateLimitCtx
+  );
   if (shouldSkipNestedAcquire(operation.resolved.name)) {
     return operation.fn();
   }
-  if (preAcquired) {
+  if (preAcquired || heldByPlatform) {
     try {
       return await operation.fn();
     } catch (error) {
@@ -7987,7 +8027,15 @@ var WaitInputRelativeSchema = z15.object({
   mode: z15.literal("relative"),
   amount: z15.number(),
   unit: WaitUnitSchema,
-  windows: z15.array(TimeWindowSlotSchema).optional()
+  windows: z15.array(TimeWindowSlotSchema).optional(),
+  /**
+   * Optional ISO datetime to use as the base for the relative delay instead of
+   * wall-clock `now`. Used for cadence chaining (schedule relative to a prior
+   * message's scheduledAt). `waitTime` is still measured from wall-clock `now`.
+   */
+  from: z15.union([z15.string(), z15.date()]).optional().describe(
+    "ISO datetime base for the relative delay (e.g. previous message scheduledAt)"
+  )
 });
 var WaitInputAbsoluteSchema = z15.object({
   mode: z15.literal("absolute"),
@@ -8100,10 +8148,12 @@ function calculateWaitTime(step, now) {
       };
     }
     case "relative": {
+      const baseTime = step.from != null ? new Date(step.from).getTime() : nowTime;
+      const baseDate = new Date(baseTime);
       if (!step.amount && (!step.windows || step.windows.length === 0)) {
         return {
-          waitTime: 0,
-          scheduledAt: now
+          waitTime: Math.max(0, baseTime - nowTime),
+          scheduledAt: baseDate
         };
       }
       let relativeDelay = 0;
@@ -8142,17 +8192,18 @@ function calculateWaitTime(step, now) {
         }
       }
       if (!step.windows || step.windows.length === 0) {
+        const scheduledAt = new Date(baseTime + relativeDelay);
         return {
-          waitTime: relativeDelay,
-          scheduledAt: new Date(nowTime + relativeDelay)
+          waitTime: Math.max(0, scheduledAt.getTime() - nowTime),
+          scheduledAt
         };
       }
-      const targetDate = new Date(nowTime + relativeDelay);
+      const targetDate = new Date(baseTime + relativeDelay);
       for (const window of step.windows) {
         if (isTimeInWindowSlot(targetDate, window)) {
           return {
-            waitTime: relativeDelay,
-            scheduledAt: new Date(nowTime + relativeDelay)
+            waitTime: Math.max(0, targetDate.getTime() - nowTime),
+            scheduledAt: targetDate
           };
         }
       }
@@ -8197,8 +8248,8 @@ function calculateWaitTime(step, now) {
           msUntilWindowStart = daysMs + hoursAdjustment + minutesAdjustment;
         }
         const windowStartTimeMs = targetDate.getTime() + msUntilWindowStart;
-        const sameLocalDayAsNow = getLocalDateKey(now, tz) === getLocalDateKey(targetDate, tz);
-        const windowScheduledTime = sameLocalDayAsNow ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
+        const sameLocalDayAsBase = getLocalDateKey(baseDate, tz) === getLocalDateKey(targetDate, tz);
+        const windowScheduledTime = sameLocalDayAsBase ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
         const waitFromNow = windowScheduledTime.getTime() - nowTime;
         if (waitFromNow < earliestWaitFromNow) {
           earliestWaitFromNow = waitFromNow;

package/dist/index.js

@@ -4023,6 +4023,14 @@ function getActiveMutexQueueNames() {
       names.add(operation.resolved.name);
     }
   }
+  const held = getRateLimitExecutionContext()?.heldMutexQueueKeys;
+  if (held?.length) {
+    for (const entry of held) {
+      if (entry.queueName) {
+        names.add(entry.queueName);
+      }
+    }
+  }
   return [...names];
 }
 function shouldSkipNestedAcquire(queueName) {
@@ -4261,6 +4269,26 @@ function parsePreAcquiredLeases(raw) {
     return void 0;
   }
 }
+function parseHeldMutexQueueKeys(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    const keys = parsed.filter(
+      (item) => item != null && typeof item === "object" && typeof item.queueKey === "string" && typeof item.queueName === "string"
+    ).map((item) => ({
+      queueKey: item.queueKey,
+      queueName: item.queueName
+    }));
+    return keys.length > 0 ? keys : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function buildToolMetadata(registry) {
   return Object.values(registry).map((tool) => {
     const toolConfig = tool.config ?? {};
@@ -4398,7 +4426,10 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
         invocation,
         isProvisionContext: trigger === "provision",
-        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES)
+        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES),
+        heldMutexQueueKeys: parseHeldMutexQueueKeys(
+          toolEnv.SKEDYUL_HELD_MUTEX_QUEUE_KEYS
+        )
       };
       const functionResult = await runWithConfig(requestConfig, async () => {
         return await runWithRateLimitExecutionContext(rateLimitContext, async () => {
@@ -6790,6 +6821,11 @@ async function queuedFetch(queueInput, fnOrPromise) {
 function findPreAcquiredLease(queueKey, ctx) {
   return ctx?.preAcquiredLeases?.find((lease) => lease.queueKey === queueKey);
 }
+function isHeldMutexQueueKey(queueKey, ctx) {
+  return Boolean(
+    ctx?.heldMutexQueueKeys?.some((entry) => entry.queueKey === queueKey)
+  );
+}
 function shouldRethrowRateLimitCause(maxRetries, error, attempt, shouldRetryFn) {
   if (maxRetries !== 0 || !shouldRetryFn(error, attempt)) {
     return false;
@@ -6807,10 +6843,14 @@ async function executeWithRetries(operation, maxRetries) {
     operation.resolved.queueKey,
     rateLimitCtx
   );
+  const heldByPlatform = isHeldMutexQueueKey(
+    operation.resolved.queueKey,
+    rateLimitCtx
+  );
   if (shouldSkipNestedAcquire(operation.resolved.name)) {
     return operation.fn();
   }
-  if (preAcquired) {
+  if (preAcquired || heldByPlatform) {
     try {
       return await operation.fn();
     } catch (error) {
@@ -8361,7 +8401,15 @@ var WaitInputRelativeSchema = import_v413.z.object({
   mode: import_v413.z.literal("relative"),
   amount: import_v413.z.number(),
   unit: WaitUnitSchema,
-  windows: import_v413.z.array(TimeWindowSlotSchema).optional()
+  windows: import_v413.z.array(TimeWindowSlotSchema).optional(),
+  /**
+   * Optional ISO datetime to use as the base for the relative delay instead of
+   * wall-clock `now`. Used for cadence chaining (schedule relative to a prior
+   * message's scheduledAt). `waitTime` is still measured from wall-clock `now`.
+   */
+  from: import_v413.z.union([import_v413.z.string(), import_v413.z.date()]).optional().describe(
+    "ISO datetime base for the relative delay (e.g. previous message scheduledAt)"
+  )
 });
 var WaitInputAbsoluteSchema = import_v413.z.object({
   mode: import_v413.z.literal("absolute"),
@@ -8474,10 +8522,12 @@ function calculateWaitTime(step, now) {
       };
     }
     case "relative": {
+      const baseTime = step.from != null ? new Date(step.from).getTime() : nowTime;
+      const baseDate = new Date(baseTime);
       if (!step.amount && (!step.windows || step.windows.length === 0)) {
         return {
-          waitTime: 0,
-          scheduledAt: now
+          waitTime: Math.max(0, baseTime - nowTime),
+          scheduledAt: baseDate
         };
       }
       let relativeDelay = 0;
@@ -8516,17 +8566,18 @@ function calculateWaitTime(step, now) {
         }
       }
       if (!step.windows || step.windows.length === 0) {
+        const scheduledAt = new Date(baseTime + relativeDelay);
         return {
-          waitTime: relativeDelay,
-          scheduledAt: new Date(nowTime + relativeDelay)
+          waitTime: Math.max(0, scheduledAt.getTime() - nowTime),
+          scheduledAt
         };
       }
-      const targetDate = new Date(nowTime + relativeDelay);
+      const targetDate = new Date(baseTime + relativeDelay);
       for (const window of step.windows) {
         if (isTimeInWindowSlot(targetDate, window)) {
           return {
-            waitTime: relativeDelay,
-            scheduledAt: new Date(nowTime + relativeDelay)
+            waitTime: Math.max(0, targetDate.getTime() - nowTime),
+            scheduledAt: targetDate
           };
         }
       }
@@ -8571,8 +8622,8 @@ function calculateWaitTime(step, now) {
           msUntilWindowStart = daysMs + hoursAdjustment + minutesAdjustment;
         }
         const windowStartTimeMs = targetDate.getTime() + msUntilWindowStart;
-        const sameLocalDayAsNow = getLocalDateKey(now, tz) === getLocalDateKey(targetDate, tz);
-        const windowScheduledTime = sameLocalDayAsNow ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
+        const sameLocalDayAsBase = getLocalDateKey(baseDate, tz) === getLocalDateKey(targetDate, tz);
+        const windowScheduledTime = sameLocalDayAsBase ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
         const waitFromNow = windowScheduledTime.getTime() - nowTime;
         if (waitFromNow < earliestWaitFromNow) {
           earliestWaitFromNow = waitFromNow;

package/dist/ratelimit/context.d.ts

@@ -4,7 +4,7 @@ export declare function getRateLimitExecutionContext(): RateLimitExecutionContex
 export declare function runWithActiveQueuedOperation<T>(operation: ActiveQueuedOperation<T>, fn: () => Promise<T>): Promise<T>;
 export declare function getActiveQueuedOperation<T>(): ActiveQueuedOperation<T> | undefined;
 export declare function getActiveQueuedOperationStack(): ActiveQueuedOperation<unknown>[];
-/** Active mutex queue names holding a lease in an outer queuedFetch. */
+/** Active mutex queue names holding a lease in an outer queuedFetch or platform-held. */
 export declare function getActiveMutexQueueNames(): string[];
 /** True when an active mutex queue suppresses acquire for the target queue name. */
 export declare function shouldSkipNestedAcquire(queueName: string): boolean;

package/dist/ratelimit/types.d.ts

@@ -1,6 +1,10 @@
 import type { SerializableQueueConfig } from '../config/queue-config';
 import type { AppInfo } from '../types/shared';
 import type { InvocationContext } from '../types/invocation';
+export interface HeldMutexQueueKey {
+    queueKey: string;
+    queueName: string;
+}
 export interface RateLimitExecutionContext {
     app: AppInfo;
     appInstallationId?: string;
@@ -11,6 +15,12 @@ export interface RateLimitExecutionContext {
         queueKey: string;
         leaseId: string;
     }>;
+    /**
+     * Mutex queue keys held by platform Temporal orchestration for this tool call.
+     * queuedFetch skips acquire/release for matching keys; queue names count as active mutexes
+     * for suppressesQueues.
+     */
+    heldMutexQueueKeys?: HeldMutexQueueKey[];
 }
 export interface QueueSelector {
     queue: string;

package/dist/scheduling/calculateWaitTime.d.ts

@@ -9,8 +9,10 @@
 import type { WaitInputType, CalculateWaitTimeResult } from './types-workflow';
 /**
  * Calculate the wait time for a wait step
- * @param step The input parameters for the wait step
- * @param now The current date/time
+ * @param step The input parameters for the wait step. Relative mode may include
+ *   optional `from` (ISO datetime / Date) as the base for the delay instead of `now`.
+ * @param now Wall-clock current date/time. Used as the default relative base and
+ *   always used to compute `waitTime` (ms until `scheduledAt`).
  * @returns The time to wait in milliseconds and the scheduled date
  */
 export declare function calculateWaitTime(step: WaitInputType, now: Date): CalculateWaitTimeResult;

package/dist/scheduling/index.js

@@ -128,10 +128,12 @@ function calculateWaitTime(step, now) {
       };
     }
     case "relative": {
+      const baseTime = step.from != null ? new Date(step.from).getTime() : nowTime;
+      const baseDate = new Date(baseTime);
       if (!step.amount && (!step.windows || step.windows.length === 0)) {
         return {
-          waitTime: 0,
-          scheduledAt: now
+          waitTime: Math.max(0, baseTime - nowTime),
+          scheduledAt: baseDate
         };
       }
       let relativeDelay = 0;
@@ -170,17 +172,18 @@ function calculateWaitTime(step, now) {
         }
       }
       if (!step.windows || step.windows.length === 0) {
+        const scheduledAt = new Date(baseTime + relativeDelay);
         return {
-          waitTime: relativeDelay,
-          scheduledAt: new Date(nowTime + relativeDelay)
+          waitTime: Math.max(0, scheduledAt.getTime() - nowTime),
+          scheduledAt
         };
       }
-      const targetDate = new Date(nowTime + relativeDelay);
+      const targetDate = new Date(baseTime + relativeDelay);
       for (const window of step.windows) {
         if (isTimeInWindowSlot(targetDate, window)) {
           return {
-            waitTime: relativeDelay,
-            scheduledAt: new Date(nowTime + relativeDelay)
+            waitTime: Math.max(0, targetDate.getTime() - nowTime),
+            scheduledAt: targetDate
           };
         }
       }
@@ -225,8 +228,8 @@ function calculateWaitTime(step, now) {
           msUntilWindowStart = daysMs + hoursAdjustment + minutesAdjustment;
         }
         const windowStartTimeMs = targetDate.getTime() + msUntilWindowStart;
-        const sameLocalDayAsNow = getLocalDateKey(now, tz) === getLocalDateKey(targetDate, tz);
-        const windowScheduledTime = sameLocalDayAsNow ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
+        const sameLocalDayAsBase = getLocalDateKey(baseDate, tz) === getLocalDateKey(targetDate, tz);
+        const windowScheduledTime = sameLocalDayAsBase ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
         const waitFromNow = windowScheduledTime.getTime() - nowTime;
         if (waitFromNow < earliestWaitFromNow) {
           earliestWaitFromNow = waitFromNow;

package/dist/scheduling/index.mjs

@@ -100,10 +100,12 @@ function calculateWaitTime(step, now) {
       };
     }
     case "relative": {
+      const baseTime = step.from != null ? new Date(step.from).getTime() : nowTime;
+      const baseDate = new Date(baseTime);
       if (!step.amount && (!step.windows || step.windows.length === 0)) {
         return {
-          waitTime: 0,
-          scheduledAt: now
+          waitTime: Math.max(0, baseTime - nowTime),
+          scheduledAt: baseDate
         };
       }
       let relativeDelay = 0;
@@ -142,17 +144,18 @@ function calculateWaitTime(step, now) {
         }
       }
       if (!step.windows || step.windows.length === 0) {
+        const scheduledAt = new Date(baseTime + relativeDelay);
         return {
-          waitTime: relativeDelay,
-          scheduledAt: new Date(nowTime + relativeDelay)
+          waitTime: Math.max(0, scheduledAt.getTime() - nowTime),
+          scheduledAt
         };
       }
-      const targetDate = new Date(nowTime + relativeDelay);
+      const targetDate = new Date(baseTime + relativeDelay);
       for (const window of step.windows) {
         if (isTimeInWindowSlot(targetDate, window)) {
           return {
-            waitTime: relativeDelay,
-            scheduledAt: new Date(nowTime + relativeDelay)
+            waitTime: Math.max(0, targetDate.getTime() - nowTime),
+            scheduledAt: targetDate
           };
         }
       }
@@ -197,8 +200,8 @@ function calculateWaitTime(step, now) {
           msUntilWindowStart = daysMs + hoursAdjustment + minutesAdjustment;
         }
         const windowStartTimeMs = targetDate.getTime() + msUntilWindowStart;
-        const sameLocalDayAsNow = getLocalDateKey(now, tz) === getLocalDateKey(targetDate, tz);
-        const windowScheduledTime = sameLocalDayAsNow ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
+        const sameLocalDayAsBase = getLocalDateKey(baseDate, tz) === getLocalDateKey(targetDate, tz);
+        const windowScheduledTime = sameLocalDayAsBase ? new Date(windowStartTimeMs + relativeDelay) : new Date(windowStartTimeMs);
         const waitFromNow = windowScheduledTime.getTime() - nowTime;
         if (waitFromNow < earliestWaitFromNow) {
           earliestWaitFromNow = waitFromNow;

package/dist/scheduling/types-workflow.d.ts

@@ -33,6 +33,13 @@ export interface WaitInputRelative {
     amount: number;
     unit: WaitUnit;
     windows?: TimeWindowSlot[];
+    /**
+     * Optional ISO datetime (or Date) to use as the base for the relative delay
+     * instead of wall-clock `now`. Used for cadence chaining: schedule message N
+     * relative to message N-1's `scheduledAt`.
+     * `waitTime` in the result is still measured from wall-clock `now`.
+     */
+    from?: string | Date;
 }
 export interface WaitInputAbsolute {
     mode: 'absolute';

package/dist/scheduling/types.d.ts

@@ -107,6 +107,7 @@ export declare const WaitInputRelativeSchema: z.ZodObject<{
         }>>;
         timezone: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    from: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
 }, z.core.$strip>;
 export declare const WaitInputAbsoluteSchema: z.ZodObject<{
     mode: z.ZodLiteral<"absolute">;
@@ -153,6 +154,7 @@ export declare const WaitInputSchema: z.ZodUnion<readonly [z.ZodObject<{
         }>>;
         timezone: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    from: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
 }, z.core.$strip>, z.ZodObject<{
     mode: z.ZodLiteral<"absolute">;
     scheduleAt: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;

package/dist/server/tool-handler.d.ts

@@ -4,6 +4,10 @@ export declare function parsePreAcquiredLeases(raw: string | undefined): Array<{
     queueKey: string;
     leaseId: string;
 }> | undefined;
+export declare function parseHeldMutexQueueKeys(raw: string | undefined): Array<{
+    queueKey: string;
+    queueName: string;
+}> | undefined;
 /**
  * Builds tool metadata array from a tool registry
  */

package/dist/server.js

@@ -441,6 +441,26 @@ function parsePreAcquiredLeases(raw) {
     return void 0;
   }
 }
+function parseHeldMutexQueueKeys(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    const keys = parsed.filter(
+      (item) => item != null && typeof item === "object" && typeof item.queueKey === "string" && typeof item.queueName === "string"
+    ).map((item) => ({
+      queueKey: item.queueKey,
+      queueName: item.queueName
+    }));
+    return keys.length > 0 ? keys : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function buildToolMetadata(registry) {
   return Object.values(registry).map((tool) => {
     const toolConfig = tool.config ?? {};
@@ -578,7 +598,10 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
         invocation,
         isProvisionContext: trigger === "provision",
-        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES)
+        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES),
+        heldMutexQueueKeys: parseHeldMutexQueueKeys(
+          toolEnv.SKEDYUL_HELD_MUTEX_QUEUE_KEYS
+        )
       };
       const functionResult = await runWithConfig(requestConfig, async () => {
         return await runWithRateLimitExecutionContext(rateLimitContext, async () => {

package/dist/serverless/server.mjs

@@ -402,6 +402,26 @@ function parsePreAcquiredLeases(raw) {
     return void 0;
   }
 }
+function parseHeldMutexQueueKeys(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    const keys = parsed.filter(
+      (item) => item != null && typeof item === "object" && typeof item.queueKey === "string" && typeof item.queueName === "string"
+    ).map((item) => ({
+      queueKey: item.queueKey,
+      queueName: item.queueName
+    }));
+    return keys.length > 0 ? keys : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function buildToolMetadata(registry) {
   return Object.values(registry).map((tool) => {
     const toolConfig = tool.config ?? {};
@@ -539,7 +559,10 @@ function createCallToolHandler(registry, state, onMaxRequests) {
         appInstallationId: trigger === "provision" ? void 0 : rawContext.appInstallationId,
         invocation,
         isProvisionContext: trigger === "provision",
-        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES)
+        preAcquiredLeases: parsePreAcquiredLeases(toolEnv.SKEDYUL_RATE_LIMIT_LEASES),
+        heldMutexQueueKeys: parseHeldMutexQueueKeys(
+          toolEnv.SKEDYUL_HELD_MUTEX_QUEUE_KEYS
+        )
       };
       const functionResult = await runWithConfig(requestConfig, async () => {
         return await runWithRateLimitExecutionContext(rateLimitContext, async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skedyul",
-  "version": "1.7.3",
+  "version": "1.7.6",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",