skedyul 1.7.5 → 1.7.7

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/schemas.d.ts

@@ -3357,6 +3357,37 @@ export declare const SetupStepDefinitionSchema: z.ZodObject<{
     listenToEnv: z.ZodOptional<z.ZodBoolean>;
     capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+export declare const BatchPaginationSchema: z.ZodObject<{
+    hasMore: z.ZodBoolean;
+    page: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodOptional<z.ZodNumber>;
+    nextCursor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const BatchOperationSetupResultSchema: z.ZodObject<{
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    total: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const BatchOperationIterateResultSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    pagination: z.ZodObject<{
+        hasMore: z.ZodBoolean;
+        page: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+        nextCursor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const BatchOperationDefinitionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    entity: z.ZodString;
+    maxConcurrent: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const ProvisionConfigSchema: z.ZodObject<{
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         label: z.ZodString;
@@ -4161,6 +4192,15 @@ export declare const ProvisionConfigSchema: z.ZodObject<{
         listenToEnv: z.ZodOptional<z.ZodBoolean>;
         capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
+    batchOperations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        entity: z.ZodString;
+        maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        pageSize: z.ZodOptional<z.ZodNumber>;
+        icon: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export declare const SkedyulConfigSchema: z.ZodObject<{
     name: z.ZodString;
@@ -4976,6 +5016,15 @@ export declare const SkedyulConfigSchema: z.ZodObject<{
             listenToEnv: z.ZodOptional<z.ZodBoolean>;
             capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>>;
+        batchOperations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            handle: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            entity: z.ZodString;
+            maxConcurrent: z.ZodOptional<z.ZodNumber>;
+            pageSize: z.ZodOptional<z.ZodNumber>;
+            icon: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodUnknown]>>;
     agents: z.ZodOptional<z.ZodArray<z.ZodObject<{
         handle: z.ZodString;
@@ -5039,6 +5088,10 @@ export type InstallConfig = z.infer<typeof InstallConfigSchema>;
 export type ProvisionConfig = z.infer<typeof ProvisionConfigSchema>;
 export type SetupStepKind = z.infer<typeof SetupStepKindSchema>;
 export type SetupStepDefinition = z.infer<typeof SetupStepDefinitionSchema>;
+export type BatchPagination = z.infer<typeof BatchPaginationSchema>;
+export type BatchOperationSetupResult = z.infer<typeof BatchOperationSetupResultSchema>;
+export type BatchOperationIterateResult = z.infer<typeof BatchOperationIterateResultSchema>;
+export type BatchOperationDefinition = z.infer<typeof BatchOperationDefinitionSchema>;
 export type FormV2StyleProps = z.infer<typeof FormV2StylePropsSchema>;
 export type FieldSettingButtonProps = z.infer<typeof FieldSettingButtonPropsSchema>;
 export type RelationshipExtension = z.infer<typeof RelationshipExtensionSchema>;

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import type { DedicatedServerInstance, ServerlessServerInstance, SkedyulServerInstance, ToolRegistry, WebhookRegistry } from '../types';
+import type { DedicatedServerInstance, ServerlessServerInstance, SkedyulServerInstance, ToolRegistry, WebhookRegistry, BatchOperationRegistry } from '../types';
 import type { SkedyulConfig } from '../config/app-config';
 export type { RequestState, CoreMethod, ToolCallArgs } from './types';
 export { normalizeBilling, toJsonSchema, isToolSchemaWithJson, getZodSchema, getJsonSchemaFromToolSchema, parseJsonRecord, parseNumberEnv, mergeRuntimeEnv, readRawRequestBody, parseJSONBody, sendJSON, sendHTML, getDefaultHeaders, createResponse, getListeningPort, } from './utils';
@@ -15,9 +15,10 @@ export type { UnifiedRequest, UnifiedResponse, RouteContext } from './route-hand
  * Runtime config type - SkedyulConfig with resolved registries (not promises).
  * This is what server.create() expects at runtime.
  */
-export type RuntimeSkedyulConfig = Omit<SkedyulConfig, 'tools' | 'webhooks'> & {
+export type RuntimeSkedyulConfig = Omit<SkedyulConfig, 'tools' | 'webhooks' | 'batchOperations'> & {
     tools: ToolRegistry;
     webhooks?: WebhookRegistry;
+    batchOperations?: BatchOperationRegistry;
 };
 export declare function createSkedyulServer(config: RuntimeSkedyulConfig & {
     computeLayer: 'dedicated';

package/dist/server/route-handlers/handlers.d.ts

@@ -60,6 +60,10 @@ export declare function handleMcpRoute(req: UnifiedRequest, ctx: RouteContext):
  * This is used by the message outbox processor for efficient batched delivery.
  */
 export declare function handleMcpBatchRoute(req: UnifiedRequest, ctx: RouteContext): Promise<UnifiedResponse>;
+/**
+ * Handle /batch-operation route for invoking batch operation setup/iterate.
+ */
+export declare function handleBatchOperationRoute(req: UnifiedRequest, ctx: RouteContext): Promise<UnifiedResponse>;
 /**
  * Create a 404 Not Found response in JSON-RPC format.
  */

package/dist/server/route-handlers/index.d.ts

@@ -6,5 +6,5 @@
  */
 export type { UnifiedRequest, UnifiedResponse, RouteContext, CallToolFn, ParsedJsonRpcBody, SkedyulToolCallArgs, ParseResult, } from './types';
 export { fromLambdaEvent, toLambdaResponse, parseJsonBody, parseJsonRpcBody, getHeader, getContentType, parseBodyByContentType, } from './adapters';
-export { handleHealthRoute, handleConfigRoute, handleCoreRoute, handleCoreWebhookRoute, handleEstimateRoute, handleInstallRoute, handleUninstallRoute, handleProvisionRoute, handleSetupRevalidateRoute, handleOAuthCallbackRoute, handleWebhookRoute, handleMcpRoute, createNotFoundResponse, createOptionsResponse, createErrorResponse, } from './handlers';
+export { handleHealthRoute, handleConfigRoute, handleCoreRoute, handleCoreWebhookRoute, handleEstimateRoute, handleInstallRoute, handleUninstallRoute, handleProvisionRoute, handleSetupRevalidateRoute, handleOAuthCallbackRoute, handleWebhookRoute, handleMcpRoute, handleBatchOperationRoute, createNotFoundResponse, createOptionsResponse, createErrorResponse, } from './handlers';
 export { routeRequest } from './router';

package/dist/server/route-handlers/types.d.ts

@@ -5,7 +5,7 @@
  * allowing route handlers to be transport-agnostic.
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ToolCallResponse, ToolMetadata, ToolRegistry, WebhookRegistry, InvocationContext } from '../../types';
+import type { ToolCallResponse, ToolMetadata, ToolRegistry, WebhookRegistry, BatchOperationRegistry, InvocationContext } from '../../types';
 import type { RuntimeSkedyulConfig } from '../index';
 import type { RequestState } from '../types';
 /**
@@ -39,6 +39,7 @@ export interface RouteContext {
     tools: ToolMetadata[];
     registry: ToolRegistry;
     webhookRegistry?: WebhookRegistry;
+    batchOperationRegistry?: BatchOperationRegistry;
     callTool: CallToolFn;
     state: RequestState;
     mcpServer: McpServer;

package/dist/server.js

@@ -1988,6 +1988,107 @@ async function handleMcpBatchRoute(req, ctx) {
     }
   };
 }
+async function handleBatchOperationRoute(req, ctx) {
+  const bodyResult = parseJsonBody(req);
+  if (!bodyResult.success) {
+    return bodyResult.error;
+  }
+  const body = bodyResult.data;
+  const registry = ctx.batchOperationRegistry;
+  if (!registry) {
+    return {
+      status: 404,
+      body: {
+        success: false,
+        error: "No batch operations registered"
+      }
+    };
+  }
+  const operation = registry[body.handle];
+  if (!operation) {
+    return {
+      status: 404,
+      body: {
+        success: false,
+        error: `Batch operation not found: ${body.handle}`
+      }
+    };
+  }
+  const log = {
+    info: (message, meta) => {
+      console.log(`[batch:${body.handle}] ${message}`, meta ?? "");
+    },
+    warn: (message, meta) => {
+      console.warn(`[batch:${body.handle}] ${message}`, meta ?? "");
+    },
+    error: (message, meta) => {
+      console.error(`[batch:${body.handle}] ${message}`, meta ?? "");
+    }
+  };
+  try {
+    if (body.method === "setup") {
+      if (!operation.setup) {
+        return {
+          status: 200,
+          body: {
+            success: true,
+            result: { state: {}, total: void 0 }
+          }
+        };
+      }
+      const result = await operation.setup({
+        workplaceId: body.workplaceId,
+        appInstallationId: body.appInstallationId,
+        appId: body.appId,
+        input: body.input,
+        log
+      });
+      return {
+        status: 200,
+        body: {
+          success: true,
+          result
+        }
+      };
+    }
+    if (body.method === "iterate") {
+      const result = await operation.iterate({
+        workplaceId: body.workplaceId,
+        appInstallationId: body.appInstallationId,
+        appId: body.appId,
+        input: body.input,
+        state: body.state,
+        page: body.page,
+        cursor: body.cursor,
+        limit: body.limit,
+        log
+      });
+      return {
+        status: 200,
+        body: {
+          success: true,
+          result
+        }
+      };
+    }
+    return {
+      status: 400,
+      body: {
+        success: false,
+        error: `Unknown method: ${body.method}`
+      }
+    };
+  } catch (err) {
+    log.error("Batch operation failed", { error: err });
+    return {
+      status: 500,
+      body: {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
 function createNotFoundResponse() {
   return {
     status: 404,
@@ -2067,6 +2168,9 @@ async function routeRequest(req, ctx) {
     if (req.path === "/mcp/batch" && req.method === "POST") {
       return handleMcpBatchRoute(req, ctx);
     }
+    if (req.path === "/batch-operation" && req.method === "POST") {
+      return handleBatchOperationRoute(req, ctx);
+    }
     return createNotFoundResponse();
   } catch (err) {
     return createErrorResponse(err);
@@ -2108,11 +2212,13 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
   const defaultHeaders = getDefaultHeaders(config.cors);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
+  const batchOperationRegistry = config.batchOperations;
   const ctx = {
     config,
     tools,
     registry,
     webhookRegistry,
+    batchOperationRegistry,
     callTool,
     state,
     mcpServer,
@@ -2227,12 +2333,14 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer) {
   const defaultHeaders = getDefaultHeaders(config.cors);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
+  const batchOperationRegistry = config.batchOperations;
   let hasLoggedStartup = false;
   const ctx = {
     config,
     tools,
     registry,
     webhookRegistry,
+    batchOperationRegistry,
     callTool,
     state,
     mcpServer,

package/dist/serverless/server.mjs

@@ -1949,6 +1949,107 @@ async function handleMcpBatchRoute(req, ctx) {
     }
   };
 }
+async function handleBatchOperationRoute(req, ctx) {
+  const bodyResult = parseJsonBody(req);
+  if (!bodyResult.success) {
+    return bodyResult.error;
+  }
+  const body = bodyResult.data;
+  const registry = ctx.batchOperationRegistry;
+  if (!registry) {
+    return {
+      status: 404,
+      body: {
+        success: false,
+        error: "No batch operations registered"
+      }
+    };
+  }
+  const operation = registry[body.handle];
+  if (!operation) {
+    return {
+      status: 404,
+      body: {
+        success: false,
+        error: `Batch operation not found: ${body.handle}`
+      }
+    };
+  }
+  const log = {
+    info: (message, meta) => {
+      console.log(`[batch:${body.handle}] ${message}`, meta ?? "");
+    },
+    warn: (message, meta) => {
+      console.warn(`[batch:${body.handle}] ${message}`, meta ?? "");
+    },
+    error: (message, meta) => {
+      console.error(`[batch:${body.handle}] ${message}`, meta ?? "");
+    }
+  };
+  try {
+    if (body.method === "setup") {
+      if (!operation.setup) {
+        return {
+          status: 200,
+          body: {
+            success: true,
+            result: { state: {}, total: void 0 }
+          }
+        };
+      }
+      const result = await operation.setup({
+        workplaceId: body.workplaceId,
+        appInstallationId: body.appInstallationId,
+        appId: body.appId,
+        input: body.input,
+        log
+      });
+      return {
+        status: 200,
+        body: {
+          success: true,
+          result
+        }
+      };
+    }
+    if (body.method === "iterate") {
+      const result = await operation.iterate({
+        workplaceId: body.workplaceId,
+        appInstallationId: body.appInstallationId,
+        appId: body.appId,
+        input: body.input,
+        state: body.state,
+        page: body.page,
+        cursor: body.cursor,
+        limit: body.limit,
+        log
+      });
+      return {
+        status: 200,
+        body: {
+          success: true,
+          result
+        }
+      };
+    }
+    return {
+      status: 400,
+      body: {
+        success: false,
+        error: `Unknown method: ${body.method}`
+      }
+    };
+  } catch (err) {
+    log.error("Batch operation failed", { error: err });
+    return {
+      status: 500,
+      body: {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
 function createNotFoundResponse() {
   return {
     status: 404,
@@ -2028,6 +2129,9 @@ async function routeRequest(req, ctx) {
     if (req.path === "/mcp/batch" && req.method === "POST") {
       return handleMcpBatchRoute(req, ctx);
     }
+    if (req.path === "/batch-operation" && req.method === "POST") {
+      return handleBatchOperationRoute(req, ctx);
+    }
     return createNotFoundResponse();
   } catch (err) {
     return createErrorResponse(err);
@@ -2069,11 +2173,13 @@ function createDedicatedServerInstance(config, tools, callTool, state, mcpServer
   const defaultHeaders = getDefaultHeaders(config.cors);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
+  const batchOperationRegistry = config.batchOperations;
   const ctx = {
     config,
     tools,
     registry,
     webhookRegistry,
+    batchOperationRegistry,
     callTool,
     state,
     mcpServer,
@@ -2188,12 +2294,14 @@ function createServerlessInstance(config, tools, callTool, state, mcpServer) {
   const defaultHeaders = getDefaultHeaders(config.cors);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
+  const batchOperationRegistry = config.batchOperations;
   let hasLoggedStartup = false;
   const ctx = {
     config,
     tools,
     registry,
     webhookRegistry,
+    batchOperationRegistry,
     callTool,
     state,
     mcpServer,

package/dist/types/batch-operation.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Batch operation runtime types.
+ *
+ * These types define the registry and context for batch operations at runtime.
+ */
+import type { BatchOperationSetupFn, BatchOperationIterateFn } from '../config/types/batch-operation';
+export type { BatchOperationContext } from '../config/types/batch-operation';
+/**
+ * Entry in the batch operation registry.
+ * Contains both metadata and function implementations.
+ */
+export interface BatchOperationRegistryEntry {
+    /** Unique handle for this operation */
+    handle: string;
+    /** Human-readable label */
+    label: string;
+    /** Description of what this operation does */
+    description?: string;
+    /** Entity handle that items will be upserted to */
+    entity: string;
+    /** Setup function called once at the start */
+    setup?: BatchOperationSetupFn;
+    /** Iterate function called for each page */
+    iterate: BatchOperationIterateFn;
+    /** Maximum concurrent operations per app installation */
+    maxConcurrent?: number;
+    /** Default page size */
+    pageSize?: number;
+    /** Optional icon */
+    icon?: string;
+}
+/**
+ * Registry mapping batch operation handles to their implementations.
+ */
+export type BatchOperationRegistry = Record<string, BatchOperationRegistryEntry>;
+/**
+ * Metadata for a batch operation (serializable, no functions).
+ */
+export interface BatchOperationMetadata {
+    handle: string;
+    label: string;
+    description?: string;
+    entity: string;
+    maxConcurrent?: number;
+    pageSize?: number;
+    icon?: string;
+}

package/dist/types/index.d.ts

@@ -22,3 +22,4 @@ export type { WebhookWireRequest, HandlerRawRequest, WebhookRequest, WebhookResp
 export { isRuntimeWebhookContext } from './webhook';
 export type { MCPError, MCPContentItem, MCPResult, MCPResponse, MCPRequest, } from './mcp-protocol';
 export type { DataBlock, DataBlockLink, SpreadsheetBlock, SpreadsheetColumn, ProfileBlock, ProfileAvatar, ProfileField, FieldChangesBlock, FieldChangeItem, DateTimeBlock, } from './data-blocks';
+export type { BatchOperationContext, BatchOperationRegistryEntry, BatchOperationRegistry, BatchOperationMetadata, } from './batch-operation';

package/package.json

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