@aikirun/task 0.16.0 → 0.18.0

package/dist/index.d.ts

@@ -11,10 +11,7 @@ type IsSubtype<SubT, SuperT> = SubT extends SuperT ? true : false;
 type And<T extends NonEmptyArray<boolean>> = T extends [infer First, ...infer Rest] ? false extends First ? false : Rest extends NonEmptyArray<boolean> ? And<Rest> : true : never;
 type Or<T extends NonEmptyArray<boolean>> = T extends [infer First, ...infer Rest] ? true extends First ? true : Rest extends NonEmptyArray<boolean> ? Or<Rest> : false : never;
 type PathFromObject<T, IncludeArrayKeys extends boolean = false> = T extends T ? PathFromObjectInternal<T, IncludeArrayKeys> : never;
-type PathFromObjectInternal<T, IncludeArrayKeys extends boolean> = And<[
-    IsSubtype<T, object>,
-    Or<[IncludeArrayKeys, NonArrayObject<T> extends never ? false : true]>
-]> extends true ? {
+type PathFromObjectInternal<T, IncludeArrayKeys extends boolean> = And<[IsSubtype<T, object>, Or<[IncludeArrayKeys, NonArrayObject<T> extends never ? false : true]>]> extends true ? {
     [K in Exclude<keyof T, symbol>]-?: And<[
         IsSubtype<NonNullable<T[K]>, object>,
         Or<[IncludeArrayKeys, NonArrayObject<NonNullable<T[K]>> extends never ? false : true]>

package/dist/index.js

@@ -1,6 +1,6 @@
 // ../../lib/address/index.ts
-function getTaskAddress(name, referenceId) {
-  return `${name}/${referenceId}`;
+function getTaskAddress(name, inputHash) {
+  return `${name}:${inputHash}`;
 }
 
 // ../../lib/async/delay.ts
@@ -22,6 +22,9 @@ function delay(ms, options) {
   });
 }
 
+// ../../lib/crypto/hash.ts
+import { createHash } from "crypto";
+
 // ../../lib/json/stable-stringify.ts
 function stableStringify(value) {
   return stringifyValue(value);
@@ -153,6 +156,7 @@ function getRetryParams(attempts, strategy) {
 import { INTERNAL } from "@aikirun/types/symbols";
 import { TaskFailedError } from "@aikirun/types/task";
 import {
+  NonDeterminismError,
   WorkflowRunFailedError,
   WorkflowRunRevisionConflictError,
   WorkflowRunSuspendedError
@@ -180,40 +184,18 @@ var TaskImpl = class {
     const inputRaw = args[0];
     const input = await this.parse(handle, this.params.schema?.input, inputRaw, run.logger);
     const inputHash = await hashInput(input);
-    const reference = startOpts.reference;
-    const address = getTaskAddress(this.name, reference?.id ?? inputHash);
-    const existingTaskInfo = handle.run.tasks[address];
-    if (existingTaskInfo) {
-      await this.assertUniqueTaskReferenceId(handle, existingTaskInfo, inputHash, reference, run.logger);
-    }
-    if (existingTaskInfo?.state.status === "completed") {
-      return this.parse(handle, this.params.schema?.output, existingTaskInfo.state.output, run.logger);
-    }
-    if (existingTaskInfo?.state.status === "failed") {
-      const { state } = existingTaskInfo;
-      throw new TaskFailedError(existingTaskInfo.id, state.attempts, state.error.message);
+    const address = getTaskAddress(this.name, inputHash);
+    const replayManifest = run[INTERNAL].replayManifest;
+    if (replayManifest.hasUnconsumedEntries()) {
+      const existingTaskInfo = replayManifest.consumeNextTask(address);
+      if (existingTaskInfo) {
+        return this.getExistingTaskResult(run, handle, startOpts, input, existingTaskInfo);
+      }
+      await this.throwNonDeterminismError(run, handle, inputHash, replayManifest);
     }
-    let attempts = 0;
+    const attempts = 1;
     const retryStrategy = startOpts.retry ?? { type: "never" };
-    if (existingTaskInfo?.state) {
-      const taskId2 = existingTaskInfo.id;
-      const state = existingTaskInfo?.state;
-      attempts = state.attempts;
-      this.assertRetryAllowed(taskId2, attempts, retryStrategy, run.logger);
-      run.logger.debug("Retrying task", {
-        "aiki.taskName": this.name,
-        "aiki.taskId": taskId2,
-        "aiki.attempts": attempts,
-        "aiki.taskStatus": state.status
-      });
-    }
-    attempts++;
-    const { taskId } = existingTaskInfo ? await handle[INTERNAL].transitionTaskState({
-      type: "retry",
-      taskId: existingTaskInfo.id,
-      options: startOpts,
-      taskState: { status: "running", attempts, input }
-    }) : await handle[INTERNAL].transitionTaskState({
+    const taskInfo = await handle[INTERNAL].transitionTaskState({
       type: "create",
       taskName: this.name,
       options: startOpts,
@@ -222,20 +204,89 @@ var TaskImpl = class {
     const logger = run.logger.child({
       "aiki.component": "task-execution",
       "aiki.taskName": this.name,
-      "aiki.taskId": taskId
+      "aiki.taskId": taskInfo.id
     });
     logger.info("Task started", { "aiki.attempts": attempts });
     const { output, lastAttempt } = await this.tryExecuteTask(
       handle,
       input,
-      taskId,
+      taskInfo.id,
       retryStrategy,
       attempts,
       run[INTERNAL].options.spinThresholdMs,
       logger
     );
     await handle[INTERNAL].transitionTaskState({
+      taskId: taskInfo.id,
+      taskState: { status: "completed", attempts: lastAttempt, output }
+    });
+    logger.info("Task complete", { "aiki.attempts": lastAttempt });
+    return output;
+  }
+  async getExistingTaskResult(run, handle, startOpts, input, existingTaskInfo) {
+    const existingTaskState = existingTaskInfo.state;
+    if (existingTaskState.status === "completed") {
+      return this.parse(handle, this.params.schema?.output, existingTaskState.output, run.logger);
+    }
+    if (existingTaskState.status === "failed") {
+      throw new TaskFailedError(
+        existingTaskInfo.id,
+        existingTaskState.attempts,
+        existingTaskState.error.message
+      );
+    }
+    existingTaskState.status;
+    const attempts = existingTaskState.attempts;
+    const retryStrategy = startOpts.retry ?? { type: "never" };
+    this.assertRetryAllowed(existingTaskInfo.id, attempts, retryStrategy, run.logger);
+    run.logger.debug("Retrying task", {
+      "aiki.taskName": this.name,
+      "aiki.taskId": existingTaskInfo.id,
+      "aiki.attempts": attempts,
+      "aiki.taskStatus": existingTaskState.status
+    });
+    return this.retryAndExecute(run, handle, input, existingTaskInfo.id, startOpts, retryStrategy, attempts);
+  }
+  async throwNonDeterminismError(run, handle, inputHash, manifest) {
+    const unconsumedManifestEntries = manifest.getUnconsumedEntries();
+    run.logger.error("Replay divergence", {
+      "aiki.taskName": this.name,
+      "aiki.inputHash": inputHash,
+      "aiki.unconsumedManifestEntries": unconsumedManifestEntries
+    });
+    const error = new NonDeterminismError(run.id, handle.run.attempts, unconsumedManifestEntries);
+    await handle[INTERNAL].transitionState({
+      status: "failed",
+      cause: "self",
+      error: createSerializableError(error)
+    });
+    throw error;
+  }
+  async retryAndExecute(run, handle, input, taskId, startOpts, retryStrategy, previousAttempts) {
+    const attempts = previousAttempts + 1;
+    const taskInfo = await handle[INTERNAL].transitionTaskState({
+      type: "retry",
       taskId,
+      options: startOpts,
+      taskState: { status: "running", attempts, input }
+    });
+    const logger = run.logger.child({
+      "aiki.component": "task-execution",
+      "aiki.taskName": this.name,
+      "aiki.taskId": taskInfo.id
+    });
+    logger.info("Task started", { "aiki.attempts": attempts });
+    const { output, lastAttempt } = await this.tryExecuteTask(
+      handle,
+      input,
+      taskInfo.id,
+      retryStrategy,
+      attempts,
+      run[INTERNAL].options.spinThresholdMs,
+      logger
+    );
+    await handle[INTERNAL].transitionTaskState({
+      taskId: taskInfo.id,
       taskState: { status: "completed", attempts: lastAttempt, output }
     });
     logger.info("Task complete", { "aiki.attempts": lastAttempt });
@@ -249,7 +300,7 @@ var TaskImpl = class {
         const output = await this.parse(handle, this.params.schema?.output, outputRaw, logger);
         return { output, lastAttempt: attempts };
       } catch (error) {
-        if (error instanceof WorkflowRunFailedError || error instanceof WorkflowRunSuspendedError || error instanceof WorkflowRunRevisionConflictError) {
+        if (error instanceof WorkflowRunSuspendedError || error instanceof WorkflowRunFailedError || error instanceof WorkflowRunRevisionConflictError) {
           throw error;
         }
         const serializableError = createSerializableError(error);
@@ -288,30 +339,6 @@ var TaskImpl = class {
       }
     }
   }
-  async assertUniqueTaskReferenceId(handle, existingTaskInfo, inputHash, reference, logger) {
-    if (existingTaskInfo.inputHash !== inputHash && reference) {
-      const conflictPolicy = reference.conflictPolicy ?? "error";
-      if (conflictPolicy !== "error") {
-        return;
-      }
-      logger.error("Reference ID already used by another task", {
-        "aiki.taskName": this.name,
-        "aiki.referenceId": reference.id,
-        "aiki.existingTaskId": existingTaskInfo.id
-      });
-      const error = new WorkflowRunFailedError(
-        handle.run.id,
-        handle.run.attempts,
-        `Reference ID "${reference.id}" already used by another task ${existingTaskInfo.id}`
-      );
-      await handle[INTERNAL].transitionState({
-        status: "failed",
-        cause: "self",
-        error: createSerializableError(error)
-      });
-      throw error;
-    }
-  }
   assertRetryAllowed(taskId, attempts, retryStrategy, logger) {
     const retryParams = getRetryParams(attempts, retryStrategy);
     if (!retryParams.retriesLeft) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/task",
-	"version": "0.16.0",
+	"version": "0.18.0",
 	"description": "Task SDK for Aiki - define reliable tasks with automatic retries, idempotency, and error handling",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -18,8 +18,8 @@
 		"build": "tsup"
 	},
 	"dependencies": {
-		"@aikirun/types": "0.16.0",
-		"@aikirun/workflow": "0.16.0",
+		"@aikirun/types": "0.18.0",
+		"@aikirun/workflow": "0.18.0",
 		"@standard-schema/spec": "^1.1.0"
 	},
 	"publishConfig": {