@aikirun/task 0.8.0 → 0.9.0

package/dist/index.js

@@ -182,19 +182,7 @@ var TaskImpl = class _TaskImpl {
     const handle = run[INTERNAL].handle;
     handle[INTERNAL].assertExecutionAllowed();
     const inputRaw = isNonEmptyArray(args) ? args[0] : void 0;
-    let input = inputRaw;
-    if (this.params.schema?.input) {
-      try {
-        input = this.params.schema.input.parse(inputRaw);
-      } catch (error) {
-        await handle[INTERNAL].transitionState({
-          status: "failed",
-          cause: "self",
-          error: createSerializableError(error)
-        });
-        throw new WorkflowRunFailedError(run.id, handle.run.attempts);
-      }
-    }
+    const input = await this.parse(handle, this.params.schema?.input, inputRaw);
     const inputHash = await hashInput(input);
     const reference = this.params.opts?.reference;
     const path = getTaskPath(this.name, reference?.id ?? inputHash);
@@ -203,7 +191,7 @@ var TaskImpl = class _TaskImpl {
       await this.assertUniqueTaskReferenceId(handle, existingTaskInfo, inputHash, reference, run.logger);
     }
     if (existingTaskInfo?.state.status === "completed") {
-      return existingTaskInfo.state.output;
+      return this.parse(handle, this.params.schema?.output, existingTaskInfo.state.output);
     }
     if (existingTaskInfo?.state.status === "failed") {
       const { state } = existingTaskInfo;
@@ -245,7 +233,15 @@ var TaskImpl = class _TaskImpl {
       "aiki.taskId": taskId
     });
     logger.info("Task started", { "aiki.attempts": attempts });
-    const { output, lastAttempt } = await this.tryExecuteTask(run, input, taskId, retryStrategy, attempts, logger);
+    const { output, lastAttempt } = await this.tryExecuteTask(
+      handle,
+      input,
+      taskId,
+      retryStrategy,
+      attempts,
+      run[INTERNAL].options.spinThresholdMs,
+      logger
+    );
     await handle[INTERNAL].transitionTaskState({
       taskId,
       taskState: { status: "completed", attempts: lastAttempt, output }
@@ -253,24 +249,12 @@ var TaskImpl = class _TaskImpl {
     logger.info("Task complete", { "aiki.attempts": lastAttempt });
     return output;
   }
-  async tryExecuteTask(run, input, taskId, retryStrategy, currentAttempt, logger) {
+  async tryExecuteTask(handle, input, taskId, retryStrategy, currentAttempt, spinThresholdMs, logger) {
     let attempts = currentAttempt;
     while (true) {
       try {
         const outputRaw = await this.params.handler(input);
-        let output = outputRaw;
-        if (this.params.schema?.output) {
-          try {
-            output = this.params.schema.output.parse(outputRaw);
-          } catch (error) {
-            await run[INTERNAL].handle[INTERNAL].transitionState({
-              status: "failed",
-              cause: "self",
-              error: createSerializableError(error)
-            });
-            throw new WorkflowRunFailedError(run.id, run[INTERNAL].handle.run.attempts);
-          }
-        }
+        const output = await this.parse(handle, this.params.schema?.output, outputRaw);
         return { output, lastAttempt: attempts };
       } catch (error) {
         if (error instanceof WorkflowRunFailedError || error instanceof WorkflowRunSuspendedError || error instanceof WorkflowRunConflictError) {
@@ -283,7 +267,7 @@ var TaskImpl = class _TaskImpl {
             "aiki.attempts": attempts,
             "aiki.reason": serializableError.message
           });
-          await run[INTERNAL].handle[INTERNAL].transitionTaskState({
+          await handle[INTERNAL].transitionTaskState({
             taskId,
             taskState: { status: "failed", attempts, error: serializableError }
           });
@@ -294,12 +278,12 @@ var TaskImpl = class _TaskImpl {
           "aiki.nextAttemptInMs": retryParams.delayMs,
           "aiki.reason": serializableError.message
         });
-        if (retryParams.delayMs <= run[INTERNAL].options.spinThresholdMs) {
+        if (retryParams.delayMs <= spinThresholdMs) {
           await delay(retryParams.delayMs);
           attempts++;
           continue;
         }
-        await run[INTERNAL].handle[INTERNAL].transitionTaskState({
+        await handle[INTERNAL].transitionTaskState({
           taskId,
           taskState: {
             status: "awaiting_retry",
@@ -308,7 +292,7 @@ var TaskImpl = class _TaskImpl {
             nextAttemptInMs: retryParams.delayMs
           }
         });
-        throw new WorkflowRunSuspendedError(run.id);
+        throw new WorkflowRunSuspendedError(handle.run.id);
       }
     }
   }
@@ -348,6 +332,21 @@ var TaskImpl = class _TaskImpl {
       throw new TaskFailedError(taskId, attempts, "Task retry not allowed");
     }
   }
+  async parse(handle, schema, data) {
+    if (!schema) {
+      return data;
+    }
+    try {
+      return schema.parse(data);
+    } catch (error) {
+      await handle[INTERNAL].transitionState({
+        status: "failed",
+        cause: "self",
+        error: createSerializableError(error)
+      });
+      throw new WorkflowRunFailedError(handle.run.id, handle.run.attempts);
+    }
+  }
 };
 export {
   task

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/task",
-	"version": "0.8.0",
+	"version": "0.9.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.8.0",
-		"@aikirun/workflow": "0.8.0"
+		"@aikirun/types": "0.9.0",
+		"@aikirun/workflow": "0.9.0"
 	},
 	"publishConfig": {
 		"access": "public"