@aikirun/task 0.23.1 → 0.24.1

package/dist/index.d.ts

@@ -1,8 +1,12 @@
+import { DistributiveOmit, RequireAtLeastOneProp } from '@aikirun/types/property';
 import { Serializable } from '@aikirun/types/serializable';
-import { TaskName, TaskStartOptions, TaskDefinitionOptions } from '@aikirun/types/task';
-import { WorkflowRunContext } from '@aikirun/workflow';
+import { TaskInfo, TaskName, TaskStartOptions, TaskDefinitionOptions } from '@aikirun/types/task';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { RequireAtLeastOneProp } from '@aikirun/types/utils';
+import { Logger } from '@aikirun/types/logger';
+import { ReplayManifest } from '@aikirun/types/replay-manifest';
+import { INTERNAL } from '@aikirun/types/symbols';
+import { WorkflowRunId, WorkflowRun } from '@aikirun/types/workflow-run';
+import { WorkflowRunStateRequest, WorkflowRunTransitionTaskStateRequestV1 } from '@aikirun/types/workflow-run-api';
 
 type NonEmptyArray<T> = [T, ...T[]];
 
@@ -20,11 +24,25 @@ type PathFromObjectInternal<T, IncludeArrayKeys extends boolean> = And<[IsSubtyp
 type ExtractObjectType<T> = T extends object ? T : never;
 type TypeOfValueAtPath<T extends object, Path extends PathFromObject<T>> = Path extends keyof T ? T[Path] : Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? undefined extends T[First] ? Rest extends PathFromObject<ExtractObjectType<T[First]>> ? TypeOfValueAtPath<ExtractObjectType<T[First]>, Rest> | undefined : never : Rest extends PathFromObject<ExtractObjectType<T[First]>> ? TypeOfValueAtPath<ExtractObjectType<T[First]>, Rest> : never : never : never;
 
-interface EventDefinition<Data> {
-    _type: Data;
-    schema?: StandardSchemaV1<Data>;
+interface WorkflowRunContext {
+    id: WorkflowRunId;
+    logger: Logger;
+    [INTERNAL]: {
+        handle: WorkflowRunHandle;
+        replayManifest: ReplayManifest;
+        options: {
+            spinThresholdMs: number;
+        };
+    };
+}
+interface WorkflowRunHandle {
+    run: Readonly<WorkflowRun>;
+    [INTERNAL]: {
+        transitionState: (state: WorkflowRunStateRequest) => Promise<void>;
+        transitionTaskState: (request: DistributiveOmit<WorkflowRunTransitionTaskStateRequestV1, "id" | "expectedWorkflowRunRevision">) => Promise<TaskInfo>;
+        assertExecutionAllowed: () => void;
+    };
 }
-type EventsDefinition = Record<string, EventDefinition<unknown>>;
 
 /**
  * Defines a durable task with deterministic execution and automatic retries.
@@ -56,7 +74,7 @@ type EventsDefinition = Record<string, EventDefinition<unknown>>;
  *   handler(input: { cardId: string; amount: number }) {
  *     return paymentService.charge(input.cardId, input.amount);
  *   },
- *   opts: {
+ *   options: {
  *     retry: {
  *       type: "fixed",
  *       maxAttempts: 3,
@@ -73,7 +91,7 @@ declare function task<Input extends Serializable, Output extends Serializable>(p
 interface TaskParams<Input, Output> {
     name: string;
     handler: (input: Input) => Promise<Output>;
-    opts?: TaskDefinitionOptions;
+    options?: TaskDefinitionOptions;
     schema?: RequireAtLeastOneProp<{
         input?: StandardSchemaV1<Input>;
         output?: StandardSchemaV1<Output>;
@@ -82,7 +100,7 @@ interface TaskParams<Input, Output> {
 interface Task<Input, Output> {
     name: TaskName;
     with(): TaskBuilder<Input, Output>;
-    start: (run: WorkflowRunContext<unknown, unknown, EventsDefinition>, ...args: Input extends void ? [] : [Input]) => Promise<Output>;
+    start: (run: WorkflowRunContext, ...args: Input extends void ? [] : [Input]) => Promise<Output>;
 }
 interface TaskBuilder<Input, Output> {
     opt<Path extends PathFromObject<TaskStartOptions>>(path: Path, value: TypeOfValueAtPath<TaskStartOptions, Path>): TaskBuilder<Input, Output>;

package/dist/index.js

@@ -154,13 +154,13 @@ function getRetryParams(attempts, strategy) {
 
 // task.ts
 import { INTERNAL } from "@aikirun/types/symbols";
-import { TaskFailedError } from "@aikirun/types/task";
+import { TaskFailedError } from "@aikirun/types/task-error";
 import {
   NonDeterminismError,
   WorkflowRunFailedError,
   WorkflowRunRevisionConflictError,
   WorkflowRunSuspendedError
-} from "@aikirun/types/workflow-run";
+} from "@aikirun/types/workflow-run-error";
 function task(params) {
   return new TaskImpl(params);
 }
@@ -171,14 +171,14 @@ var TaskImpl = class {
   }
   name;
   with() {
-    const startOpts = this.params.opts ?? {};
-    const startOptsOverrider = objectOverrider(startOpts);
-    return new TaskBuilderImpl(this, startOptsOverrider());
+    const startOptions = this.params.options ?? {};
+    const startOptionsOverrider = objectOverrider(startOptions);
+    return new TaskBuilderImpl(this, startOptionsOverrider());
   }
   async start(run, ...args) {
-    return this.startWithOpts(run, this.params.opts ?? {}, ...args);
+    return this.startWithOptions(run, this.params.options ?? {}, ...args);
   }
-  async startWithOpts(run, startOpts, ...args) {
+  async startWithOptions(run, startOptions, ...args) {
     const handle = run[INTERNAL].handle;
     handle[INTERNAL].assertExecutionAllowed();
     const inputRaw = args[0];
@@ -189,20 +189,19 @@ var TaskImpl = class {
     if (replayManifest.hasUnconsumedEntries()) {
       const existingTaskInfo = replayManifest.consumeNextTask(address);
       if (existingTaskInfo) {
-        return this.getExistingTaskResult(run, handle, startOpts, input, existingTaskInfo);
+        return this.getExistingTaskResult(run, handle, startOptions, input, existingTaskInfo);
       }
-      await this.throwNonDeterminismError(run, handle, inputHash, replayManifest);
+      await this.throwNonDeterminismError(run, handle, inputHash, replayManifest.getUnconsumedEntries());
     }
     const attempts = 1;
-    const retryStrategy = startOpts.retry ?? { type: "never" };
+    const retryStrategy = startOptions.retry ?? { type: "never" };
     const taskInfo = await handle[INTERNAL].transitionTaskState({
       type: "create",
       taskName: this.name,
-      options: startOpts,
+      options: startOptions,
       taskState: { status: "running", attempts, input }
     });
     const logger = run.logger.child({
-      "aiki.component": "task-execution",
       "aiki.taskName": this.name,
       "aiki.taskId": taskInfo.id
     });
@@ -223,7 +222,7 @@ var TaskImpl = class {
     logger.info("Task complete", { "aiki.attempts": lastAttempt });
     return output;
   }
-  async getExistingTaskResult(run, handle, startOpts, input, existingTaskInfo) {
+  async getExistingTaskResult(run, handle, startOptions, input, existingTaskInfo) {
     const existingTaskState = existingTaskInfo.state;
     if (existingTaskState.status === "completed") {
       return this.parse(handle, this.params.schema?.output, existingTaskState.output, run.logger);
@@ -237,7 +236,7 @@ var TaskImpl = class {
     }
     existingTaskState.status;
     const attempts = existingTaskState.attempts;
-    const retryStrategy = startOpts.retry ?? { type: "never" };
+    const retryStrategy = startOptions.retry ?? { type: "never" };
     this.assertRetryAllowed(existingTaskInfo.id, attempts, retryStrategy, run.logger);
     run.logger.debug("Retrying task", {
       "aiki.taskName": this.name,
@@ -245,10 +244,9 @@ var TaskImpl = class {
       "aiki.attempts": attempts,
       "aiki.taskStatus": existingTaskState.status
     });
-    return this.retryAndExecute(run, handle, input, existingTaskInfo.id, startOpts, retryStrategy, attempts);
+    return this.retryAndExecute(run, handle, input, existingTaskInfo.id, startOptions, retryStrategy, attempts);
   }
-  async throwNonDeterminismError(run, handle, inputHash, manifest) {
-    const unconsumedManifestEntries = manifest.getUnconsumedEntries();
+  async throwNonDeterminismError(run, handle, inputHash, unconsumedManifestEntries) {
     run.logger.error("Replay divergence", {
       "aiki.taskName": this.name,
       "aiki.inputHash": inputHash,
@@ -262,16 +260,15 @@ var TaskImpl = class {
     });
     throw error;
   }
-  async retryAndExecute(run, handle, input, taskId, startOpts, retryStrategy, previousAttempts) {
+  async retryAndExecute(run, handle, input, taskId, startOptions, retryStrategy, previousAttempts) {
     const attempts = previousAttempts + 1;
     const taskInfo = await handle[INTERNAL].transitionTaskState({
       type: "retry",
       taskId,
-      options: startOpts,
+      options: startOptions,
       taskState: { status: "running", attempts, input }
     });
     const logger = run.logger.child({
-      "aiki.component": "task-execution",
       "aiki.taskName": this.name,
       "aiki.taskId": taskInfo.id
     });
@@ -372,15 +369,15 @@ var TaskImpl = class {
   }
 };
 var TaskBuilderImpl = class _TaskBuilderImpl {
-  constructor(task2, startOptsBuilder) {
+  constructor(task2, startOptionsBuilder) {
     this.task = task2;
-    this.startOptsBuilder = startOptsBuilder;
+    this.startOptionsBuilder = startOptionsBuilder;
   }
   opt(path, value) {
-    return new _TaskBuilderImpl(this.task, this.startOptsBuilder.with(path, value));
+    return new _TaskBuilderImpl(this.task, this.startOptionsBuilder.with(path, value));
   }
   start(run, ...args) {
-    return this.task.startWithOpts(run, this.startOptsBuilder.build(), ...args);
+    return this.task.startWithOptions(run, this.startOptionsBuilder.build(), ...args);
   }
 };
 export {

package/package.json

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