skedyul 1.7.8 → 1.7.11

package/dist/index.js

@@ -42,6 +42,7 @@ __export(index_exports, {
   AssociationSchema: () => AssociationSchema,
   AuthenticationError: () => AuthenticationError,
   BaseEventPayloadSchema: () => BaseEventPayloadSchema,
+  BatchCascadePhaseSchema: () => BatchCascadePhaseSchema,
   BatchOperationDefinitionSchema: () => BatchOperationDefinitionSchema,
   BatchOperationIterateResultSchema: () => BatchOperationIterateResultSchema,
   BatchOperationSetupResultSchema: () => BatchOperationSetupResultSchema,
@@ -273,6 +274,7 @@ __export(index_exports, {
   computeSkewedExpectedMinorUnits: () => computeSkewedExpectedMinorUnits,
   configure: () => configure,
   createAuthError: () => createAuthError,
+  createBatchOperationContext: () => createBatchOperationContext,
   createConflictError: () => createConflictError,
   createContextLogger: () => createContextLogger,
   createErrorResponse: () => createErrorResponse,
@@ -420,6 +422,17 @@ function createWorkflowStepContext(params) {
     workflowStepId: params.workflowStepId
   };
 }
+function createBatchOperationContext(params) {
+  return {
+    invocationId: params.invocationId,
+    invocationType: "batch_operation",
+    batchOperationHandle: params.batchOperationHandle,
+    batchOperationMethod: params.batchOperationMethod,
+    appInstallationId: params.appInstallationId,
+    workflowId: params.workflowId,
+    workflowRunId: params.workflowRunId
+  };
+}
 
 // src/types/tool-context.ts
 function isProvisionContext(ctx) {
@@ -2291,8 +2304,15 @@ var BatchOperationSetupResultSchema = import_v48.z.object({
   state: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()).optional(),
   total: import_v48.z.number().int().nonnegative().optional()
 });
+var BatchCascadePhaseSchema = import_v48.z.object({
+  entity: import_v48.z.string(),
+  order: import_v48.z.number().int(),
+  wave: import_v48.z.enum(["setup", "page"]),
+  requires: import_v48.z.array(import_v48.z.string()).optional()
+});
 var BatchOperationIterateResultSchema = import_v48.z.object({
   items: import_v48.z.array(import_v48.z.record(import_v48.z.string(), import_v48.z.unknown())),
+  itemsByEntity: import_v48.z.record(import_v48.z.string(), import_v48.z.array(import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()))).optional(),
   pagination: BatchPaginationSchema,
   state: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()).optional()
 });
@@ -2301,6 +2321,7 @@ var BatchOperationDefinitionSchema = import_v48.z.object({
   label: import_v48.z.string(),
   description: import_v48.z.string().optional(),
   entity: import_v48.z.string(),
+  cascade: import_v48.z.array(BatchCascadePhaseSchema).optional(),
   maxConcurrent: import_v48.z.number().int().positive().optional(),
   pageSize: import_v48.z.number().int().positive().optional(),
   icon: import_v48.z.string().optional()
@@ -5843,6 +5864,39 @@ async function handleMcpBatchRoute(req, ctx) {
     }
   };
 }
+function isBatchOperationFailure(result) {
+  return result != null && typeof result === "object" && result.success === false && typeof result.error === "object" && result.error != null;
+}
+function toStringEnv(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function stripBillingFields(result) {
+  const {
+    billing: _billing,
+    success: _success,
+    error: _error,
+    retry: _retry,
+    ...domain
+  } = result;
+  return domain;
+}
+function softFailureResponse(error, retry, billing) {
+  return {
+    status: 200,
+    body: {
+      success: false,
+      error,
+      ...retry ? { retry } : {},
+      billing: normalizeBilling(billing)
+    }
+  };
+}
 async function handleBatchOperationRoute(req, ctx) {
   const bodyResult = parseJsonBody(req);
   if (!bodyResult.success) {
@@ -5851,49 +5905,80 @@ async function handleBatchOperationRoute(req, ctx) {
   const body = bodyResult.data;
   const registry = ctx.batchOperationRegistry;
   if (!registry) {
-    return {
-      status: 404,
-      body: {
-        success: false,
-        error: "No batch operations registered"
-      }
-    };
+    return softFailureResponse({
+      code: "NOT_FOUND",
+      message: "No batch operations registered",
+      category: "validation"
+    });
   }
   const operation = registry[body.handle];
   if (!operation) {
-    return {
-      status: 404,
-      body: {
-        success: false,
-        error: `Batch operation not found: ${body.handle}`
-      }
-    };
+    return softFailureResponse({
+      code: "NOT_FOUND",
+      message: `Batch operation not found: ${body.handle}`,
+      category: "validation"
+    });
   }
   const context = body.context;
   if (!context?.workplaceId || !context?.appInstallationId || !context?.appId) {
-    return {
-      status: 400,
-      body: {
-        success: false,
-        error: "Missing context (workplaceId, appInstallationId, and appId required)"
-      }
-    };
+    return softFailureResponse({
+      code: "VALIDATION_ERROR",
+      message: "Missing context (workplaceId, appInstallationId, and appId required)",
+      category: "validation"
+    });
   }
-  const env = body.env ?? {};
-  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 ?? "");
-    }
+  if (body.method !== "setup" && body.method !== "iterate") {
+    return softFailureResponse({
+      code: "VALIDATION_ERROR",
+      message: `Unknown method: ${body.method}`,
+      category: "validation"
+    });
+  }
+  const requestEnv = body.env ?? {};
+  const mergedEnv = toStringEnv(buildToolExecutionEnv(requestEnv));
+  const originalEnv = { ...process.env };
+  Object.assign(process.env, mergedEnv);
+  const log = createContextLogger();
+  const app = context.app ?? {
+    id: context.appId,
+    versionId: context.appId
+  };
+  const workplace2 = context.workplace ?? {
+    id: context.workplaceId,
+    subdomain: ""
+  };
+  const invocation = body.invocation ?? {
+    invocationId: `${body.handle}-${body.method}-${Date.now()}`,
+    invocationType: "batch_operation",
+    batchOperationHandle: body.handle,
+    batchOperationMethod: body.method,
+    appInstallationId: context.appInstallationId
   };
   const requestConfig = {
-    baseUrl: env.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
-    apiToken: env.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+    baseUrl: mergedEnv.SKEDYUL_API_URL ?? process.env.SKEDYUL_API_URL ?? "",
+    apiToken: mergedEnv.SKEDYUL_API_TOKEN ?? process.env.SKEDYUL_API_TOKEN ?? ""
+  };
+  const rateLimitContext = {
+    app,
+    appInstallationId: context.appInstallationId,
+    invocation,
+    preAcquiredLeases: parsePreAcquiredLeases(
+      mergedEnv.SKEDYUL_RATE_LIMIT_LEASES
+    ),
+    heldMutexQueueKeys: parseHeldMutexQueueKeys(
+      mergedEnv.SKEDYUL_HELD_MUTEX_QUEUE_KEYS
+    )
+  };
+  const opContextBase = {
+    workplaceId: context.workplaceId,
+    appInstallationId: context.appInstallationId,
+    appId: context.appId,
+    app,
+    workplace: workplace2,
+    input: body.input,
+    env: mergedEnv,
+    invocation,
+    log
   };
   try {
     if (body.method === "setup") {
@@ -5902,67 +5987,98 @@ async function handleBatchOperationRoute(req, ctx) {
           status: 200,
           body: {
             success: true,
-            result: { state: {}, total: void 0 }
+            result: {
+              state: {},
+              total: void 0,
+              cascade: operation.cascade
+            },
+            billing: normalizeBilling(void 0)
           }
         };
       }
-      const result = await runWithConfig(requestConfig, async () => {
-        return operation.setup({
-          workplaceId: context.workplaceId,
-          appInstallationId: context.appInstallationId,
-          appId: context.appId,
-          input: body.input,
-          env,
-          log
+      const raw2 = await runWithConfig(requestConfig, async () => {
+        return runWithRateLimitExecutionContext(rateLimitContext, async () => {
+          return runWithLogContext({ invocation }, async () => {
+            return operation.setup(opContextBase);
+          });
         });
       });
+      if (isBatchOperationFailure(raw2)) {
+        return softFailureResponse(raw2.error, raw2.retry, raw2.billing);
+      }
+      const setupResult = raw2;
+      const domain2 = stripBillingFields(
+        setupResult
+      );
       return {
         status: 200,
         body: {
           success: true,
-          result
+          result: {
+            ...domain2,
+            // Expose definition cascade to the platform workflow
+            cascade: operation.cascade ?? domain2.cascade
+          },
+          billing: normalizeBilling(setupResult.billing)
         }
       };
     }
-    if (body.method === "iterate") {
-      const result = await runWithConfig(requestConfig, async () => {
-        return operation.iterate({
-          workplaceId: context.workplaceId,
-          appInstallationId: context.appInstallationId,
-          appId: context.appId,
-          input: body.input,
-          state: body.state,
-          page: body.page,
-          cursor: body.cursor,
-          limit: body.limit,
-          env,
-          log
+    const iterateBody = body;
+    const raw = await runWithConfig(requestConfig, async () => {
+      return runWithRateLimitExecutionContext(rateLimitContext, async () => {
+        return runWithLogContext({ invocation }, async () => {
+          return operation.iterate({
+            ...opContextBase,
+            state: iterateBody.state,
+            page: iterateBody.page,
+            cursor: iterateBody.cursor,
+            limit: iterateBody.limit,
+            cascadeEntities: iterateBody.cascadeEntities
+          });
         });
       });
-      return {
-        status: 200,
-        body: {
-          success: true,
-          result
-        }
-      };
+    });
+    if (isBatchOperationFailure(raw)) {
+      return softFailureResponse(raw.error, raw.retry, raw.billing);
     }
+    const iterateResult = raw;
+    const domain = stripBillingFields(
+      iterateResult
+    );
     return {
-      status: 400,
+      status: 200,
       body: {
-        success: false,
-        error: `Unknown method: ${body.method}`
+        success: true,
+        result: domain,
+        billing: normalizeBilling(iterateResult.billing)
       }
     };
   } catch (err) {
-    log.error("Batch operation failed", { error: err });
+    if (err instanceof RateLimitExceededError) {
+      return softFailureResponse(
+        {
+          code: "RATE_LIMITED",
+          message: err.message,
+          category: "external"
+        },
+        { allowed: true, afterMs: err.retryAfterMs }
+      );
+    }
+    log.error("Batch operation failed", err);
     return {
       status: 500,
       body: {
         success: false,
-        error: err instanceof Error ? err.message : String(err)
+        error: {
+          code: "INTERNAL_ERROR",
+          message: err instanceof Error ? err.message : String(err),
+          category: "internal"
+        },
+        billing: normalizeBilling(void 0)
       }
     };
+  } finally {
+    process.env = originalEnv;
   }
 }
 function createNotFoundResponse() {
@@ -8962,6 +9078,7 @@ var index_default = { z: import_v414.z };
   AssociationSchema,
   AuthenticationError,
   BaseEventPayloadSchema,
+  BatchCascadePhaseSchema,
   BatchOperationDefinitionSchema,
   BatchOperationIterateResultSchema,
   BatchOperationSetupResultSchema,
@@ -9193,6 +9310,7 @@ var index_default = { z: import_v414.z };
   computeSkewedExpectedMinorUnits,
   configure,
   createAuthError,
+  createBatchOperationContext,
   createConflictError,
   createContextLogger,
   createErrorResponse,

package/dist/schemas.d.ts

@@ -3368,8 +3368,18 @@ 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 BatchCascadePhaseSchema: z.ZodObject<{
+    entity: z.ZodString;
+    order: z.ZodNumber;
+    wave: z.ZodEnum<{
+        page: "page";
+        setup: "setup";
+    }>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare const BatchOperationIterateResultSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    itemsByEntity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
     pagination: z.ZodObject<{
         hasMore: z.ZodBoolean;
         page: z.ZodOptional<z.ZodNumber>;
@@ -3384,6 +3394,15 @@ export declare const BatchOperationDefinitionSchema: z.ZodObject<{
     label: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     entity: z.ZodString;
+    cascade: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        entity: z.ZodString;
+        order: z.ZodNumber;
+        wave: z.ZodEnum<{
+            page: "page";
+            setup: "setup";
+        }>;
+        requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
     maxConcurrent: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     icon: z.ZodOptional<z.ZodString>;
@@ -4197,6 +4216,15 @@ export declare const ProvisionConfigSchema: z.ZodObject<{
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         entity: z.ZodString;
+        cascade: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            entity: z.ZodString;
+            order: z.ZodNumber;
+            wave: z.ZodEnum<{
+                page: "page";
+                setup: "setup";
+            }>;
+            requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
         maxConcurrent: z.ZodOptional<z.ZodNumber>;
         pageSize: z.ZodOptional<z.ZodNumber>;
         icon: z.ZodOptional<z.ZodString>;
@@ -5021,6 +5049,15 @@ export declare const SkedyulConfigSchema: z.ZodObject<{
             label: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             entity: z.ZodString;
+            cascade: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                entity: z.ZodString;
+                order: z.ZodNumber;
+                wave: z.ZodEnum<{
+                    page: "page";
+                    setup: "setup";
+                }>;
+                requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
             maxConcurrent: z.ZodOptional<z.ZodNumber>;
             pageSize: z.ZodOptional<z.ZodNumber>;
             icon: z.ZodOptional<z.ZodString>;

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

@@ -63,8 +63,8 @@ export declare function handleMcpBatchRoute(req: UnifiedRequest, ctx: RouteConte
 /**
  * Handle /batch-operation route for invoking batch operation setup/iterate.
  *
- * Mirrors tool/install handlers: platform passes env + context in the body;
- * we wrap handlers in runWithConfig so SDK clients (instance.*, etc.) work.
+ * Mirrors tool handlers: buildToolExecutionEnv, process.env assign/restore,
+ * runWithConfig + rate-limit + log ALS wrappers, tool-shaped billing/error envelope.
  */
 export declare function handleBatchOperationRoute(req: UnifiedRequest, ctx: RouteContext): Promise<UnifiedResponse>;
 /**