rename import payload to task input error

Author: nicktrn

packages/core/src/v3/errors.ts

@@ -165,14 +165,14 @@ export function shouldRetryError(error: TaskRunError): boolean {
         case "TASK_PROCESS_OOM_KILLED":
         case "TASK_PROCESS_MAYBE_OOM_KILLED":
         case "TASK_RUN_CANCELLED":
-        case "TASK_OUTPUT_ERROR":
         case "MAX_DURATION_EXCEEDED":
         case "DISK_SPACE_EXCEEDED":
           return false;
 
         case "GRACEFUL_EXIT_TIMEOUT":
         case "HANDLE_ERROR_ERROR":
-        case "IMPORT_PAYLOAD_ERROR":
+        case "TASK_INPUT_ERROR":
+        case "TASK_OUTPUT_ERROR":
         case "POD_EVICTED":
         case "POD_UNKNOWN_ERROR":
         case "TASK_EXECUTION_ABORTED":

packages/core/src/v3/schemas/common.ts

@@ -94,6 +94,7 @@ export const TaskRunInternalError = z.object({
     "TASK_PROCESS_OOM_KILLED",
     "TASK_PROCESS_MAYBE_OOM_KILLED",
     "TASK_RUN_CANCELLED",
+    "TASK_INPUT_ERROR",
     "TASK_OUTPUT_ERROR",
     "HANDLE_ERROR_ERROR",
     "GRACEFUL_EXIT_TIMEOUT",
@@ -103,7 +104,6 @@ export const TaskRunInternalError = z.object({
     "DISK_SPACE_EXCEEDED",
     "POD_EVICTED",
     "POD_UNKNOWN_ERROR",
-    "IMPORT_PAYLOAD_ERROR",
   ]),
   message: z.string().optional(),
   stackTrace: z.string().optional(),

packages/core/src/v3/workers/taskExecutor.ts

@@ -93,22 +93,22 @@ export class TaskExecutor {
           try {
             const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
             parsedPayload = await parsePacket(payloadPacket);
-          } catch (packetError) {
-            recordSpanException(span, packetError);
+          } catch (inputError) {
+            recordSpanException(span, inputError);
 
             return {
               ok: false,
               id: execution.run.id,
               error: {
                 type: "INTERNAL_ERROR",
-                code: TaskRunErrorCodes.IMPORT_PAYLOAD_ERROR,
+                code: TaskRunErrorCodes.TASK_INPUT_ERROR,
                 message:
-                  packetError instanceof Error
-                    ? `${packetError.name}: ${packetError.message}`
-                    : typeof packetError === "string"
-                    ? packetError
+                  inputError instanceof Error
+                    ? `${inputError.name}: ${inputError.message}`
+                    : typeof inputError === "string"
+                    ? inputError
                     : undefined,
-                stackTrace: packetError instanceof Error ? packetError.stack : undefined,
+                stackTrace: inputError instanceof Error ? inputError.stack : undefined,
               },
             } satisfies TaskRunExecutionResult;
           }
@@ -151,8 +151,8 @@ export class TaskExecutor {
                 output: finalOutput.data,
                 outputType: finalOutput.dataType,
               } satisfies TaskRunExecutionResult;
-            } catch (stringifyError) {
-              recordSpanException(span, stringifyError);
+            } catch (outputError) {
+              recordSpanException(span, outputError);
 
               return {
                 ok: false,
@@ -161,10 +161,10 @@ export class TaskExecutor {
                   type: "INTERNAL_ERROR",
                   code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
                   message:
-                    stringifyError instanceof Error
-                      ? stringifyError.message
-                      : typeof stringifyError === "string"
-                      ? stringifyError
+                    outputError instanceof Error
+                      ? outputError.message
+                      : typeof outputError === "string"
+                      ? outputError
                       : undefined,
                 },
               } satisfies TaskRunExecutionResult;