@trigger.dev/core 0.0.0-python-preview-20250226140121 → 0.0.0-rc-4-8-0-20261021151928

package/dist/esm/v3/errors.js

@@ -1,5 +1,5 @@
 import { ImportTaskFileErrors } from "./schemas/build.js";
-import { TaskRunErrorCodes, } from "./schemas/common.js";
+import { TaskRunErrorCodes } from "./schemas/common.js";
 import { TaskMetadataFailedToParseData } from "./schemas/messages.js";
 import { links } from "./links.js";
 import { assertExhaustive } from "../utils.js";
@@ -48,6 +48,47 @@ export function isManualOutOfMemoryError(error) {
     }
     return false;
 }
+export function isOOMRunError(error) {
+    if (error.type === "INTERNAL_ERROR") {
+        if (error.code === "TASK_PROCESS_OOM_KILLED" ||
+            error.code === "TASK_PROCESS_MAYBE_OOM_KILLED") {
+            return true;
+        }
+        // For the purposes of retrying on a larger machine, we're going to treat this is an OOM error.
+        // This is what they look like if we're executing using k8s. They then get corrected later, but it's too late.
+        // {"code": "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE", "type": "INTERNAL_ERROR", "message": "Process exited with code -1 after signal SIGKILL."}
+        if (error.code === "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE" &&
+            error.message &&
+            error.message.includes("-1")) {
+            if (error.message.includes("SIGKILL")) {
+                return true;
+            }
+            if (error.message.includes("SIGABRT") && error.stackTrace) {
+                const oomIndicators = [
+                    "JavaScript heap out of memory",
+                    "Reached heap limit",
+                    "FATAL ERROR: Reached heap limit Allocation failed",
+                ];
+                if (oomIndicators.some((indicator) => error.stackTrace.includes(indicator))) {
+                    return true;
+                }
+            }
+        }
+    }
+    if (error.type === "BUILT_IN_ERROR") {
+        // ffmpeg also does weird stuff
+        // { "name": "Error", "type": "BUILT_IN_ERROR", "message": "ffmpeg was killed with signal SIGKILL" }
+        if (error.message && error.message.includes("ffmpeg was killed with signal SIGKILL")) {
+            return true;
+        }
+    }
+    // Special `OutOfMemoryError` for doing a manual OOM kill.
+    // Useful if a native library does an OOM but doesn't actually crash the run and you want to manually
+    if (isManualOutOfMemoryError(error)) {
+        return true;
+    }
+    return false;
+}
 export class TaskPayloadParsedError extends Error {
     cause;
     constructor(cause) {
@@ -57,21 +98,186 @@ export class TaskPayloadParsedError extends Error {
         this.cause = cause;
     }
 }
+export class CompleteTaskWithOutput extends Error {
+    output;
+    constructor(output) {
+        super("Complete task with output");
+        this.name = "CompleteTaskWithOutput";
+        this.output = output;
+    }
+}
+export function isCompleteTaskWithOutput(error) {
+    return error instanceof Error && error.name === "CompleteTaskWithOutput";
+}
+const MAX_STACK_FRAMES = 50;
+const KEEP_TOP_FRAMES = 5;
+const MAX_STACK_LINE_LENGTH = 1024;
+const MAX_MESSAGE_LENGTH = 1_000;
+const MAX_ERROR_CAUSES = 5;
+/** Causes are supplementary, and there can be MAX_ERROR_CAUSES of them, so they get a
+ *  much tighter frame budget than the error that was actually thrown. */
+const MAX_CAUSE_STACK_FRAMES = 10;
+/** An error name is a class name in practice, so anything longer is junk that
+ *  would otherwise ride along untruncated, once per cause. */
+const MAX_ERROR_NAME_LENGTH = 256;
+function truncateName(name) {
+    if (!name)
+        return undefined;
+    return name.length > MAX_ERROR_NAME_LENGTH ? name.slice(0, MAX_ERROR_NAME_LENGTH) : name;
+}
+/** Truncate a stack trace to at most MAX_STACK_FRAMES frames, keeping
+ *  the top (closest to throw) and bottom (entry points) frames.
+ *  Individual lines (including message lines) are capped at MAX_STACK_LINE_LENGTH
+ *  to prevent OOM from huge error messages embedded in the stack. */
+export function truncateStack(stack, maxFrames = MAX_STACK_FRAMES) {
+    if (!stack)
+        return "";
+    const lines = stack.split("\n");
+    // First line(s) before the first frame are the error message
+    const messageLines = [];
+    const frameLines = [];
+    for (const line of lines) {
+        const safe = line.length > MAX_STACK_LINE_LENGTH
+            ? line.slice(0, MAX_STACK_LINE_LENGTH) + "...[truncated]"
+            : line;
+        if (frameLines.length === 0 && !line.trimStart().startsWith("at ")) {
+            messageLines.push(safe);
+        }
+        else {
+            frameLines.push(safe);
+        }
+    }
+    if (frameLines.length <= maxFrames) {
+        return [...messageLines, ...frameLines].join("\n");
+    }
+    const keepTop = Math.min(KEEP_TOP_FRAMES, maxFrames);
+    const keepBottom = maxFrames - keepTop;
+    const omitted = frameLines.length - maxFrames;
+    return [
+        ...messageLines,
+        ...frameLines.slice(0, keepTop),
+        `    ... ${omitted} frames omitted ...`,
+        ...(keepBottom > 0 ? frameLines.slice(-keepBottom) : []),
+    ].join("\n");
+}
+export function truncateMessage(message) {
+    if (!message)
+        return "";
+    return message.length > MAX_MESSAGE_LENGTH
+        ? message.slice(0, MAX_MESSAGE_LENGTH) + "...[truncated]"
+        : message;
+}
+/** Serialize one `cause` value. A cause is arbitrary user data, so every step here
+ *  can throw: `instanceof` and property reads run Proxy traps, and JSON.stringify
+ *  and String both throw on some values. Losing a cause is acceptable; throwing
+ *  would lose the whole error report. Returns undefined for a cause that carries
+ *  nothing worth rendering. */
+function serializeErrorCause(cause) {
+    try {
+        if (cause instanceof Error) {
+            const name = truncateName(cause.name);
+            const message = truncateMessage(cause.message);
+            const stackTrace = truncateStack(cause.stack, MAX_CAUSE_STACK_FRAMES) || undefined;
+            return name || message || stackTrace ? { name, message, stackTrace } : undefined;
+        }
+        if (typeof cause === "string") {
+            return cause ? { message: truncateMessage(cause) } : undefined;
+        }
+        try {
+            const json = JSON.stringify(cause);
+            if (json !== undefined) {
+                return { message: truncateMessage(json) };
+            }
+        }
+        catch (_e) {
+            /** fall through to the coercion attempt */
+        }
+        return { message: truncateMessage(String(cause)) };
+    }
+    catch (_e) {
+        return { message: `[unserializable ${typeof cause} cause]` };
+    }
+}
+/** Reading `.cause` runs `instanceof` and a property get, either of which can throw
+ *  on a hostile or revoked Proxy. Stop the walk instead of aborting the report. */
+function readErrorCause(value) {
+    try {
+        return value instanceof Error ? value.cause : undefined;
+    }
+    catch (_e) {
+        return undefined;
+    }
+}
+/** Flatten an error's `cause` chain, outermost first. Bounded by MAX_ERROR_CAUSES
+ *  and guarded against cycles, since a cause chain is attacker- (or accident-) shaped. */
+function extractErrorCauses(error) {
+    const causes = [];
+    const seen = new Set([error]);
+    let current = readErrorCause(error);
+    /** Every link visited counts against the cap, including ones that serialize to
+     *  nothing, so a chain of empty causes cannot extend the walk. */
+    for (let i = 0; i < MAX_ERROR_CAUSES && current !== undefined && current !== null; i++) {
+        if (typeof current === "object") {
+            if (seen.has(current)) {
+                break;
+            }
+            seen.add(current);
+        }
+        const cause = serializeErrorCause(current);
+        if (cause) {
+            causes.push(cause);
+        }
+        current = readErrorCause(current);
+    }
+    return causes.length > 0 ? causes : undefined;
+}
+/** Rebuild a native `cause` chain from the flattened form, innermost first. */
+export function createErrorFromCauses(causes) {
+    let current;
+    for (let i = causes.length - 1; i >= 0; i--) {
+        const cause = causes[i];
+        const error = new Error(cause.message, current ? { cause: current } : undefined);
+        if (cause.name) {
+            error.name = cause.name;
+        }
+        error.stack = cause.stackTrace || [cause.name, cause.message].filter(Boolean).join(": ");
+        current = error;
+    }
+    return current;
+}
+/** Render a flattened cause chain the way Node prints one. `stackTrace` opts into the
+ *  full frames; without it each cause is a single "Caused by:" line. */
+export function formatErrorCauses(causes, options) {
+    if (!causes || causes.length === 0) {
+        return "";
+    }
+    return causes
+        .map((cause) => {
+        if (options?.stackTrace && cause.stackTrace) {
+            return `\n\nCaused by: ${cause.stackTrace}`;
+        }
+        const label = [cause.name, cause.message].filter(Boolean).join(": ");
+        return label ? `\nCaused by: ${label}` : "";
+    })
+        .join("");
+}
 export function parseError(error) {
     if (isInternalError(error)) {
         return {
             type: "INTERNAL_ERROR",
             code: error.code,
-            message: error.message,
-            stackTrace: error.stack ?? "",
+            message: truncateMessage(error.message),
+            stackTrace: truncateStack(error.stack),
         };
     }
     if (error instanceof Error) {
+        const causes = extractErrorCauses(error);
         return {
             type: "BUILT_IN_ERROR",
             name: error.name,
-            message: error.message,
-            stackTrace: error.stack ?? "",
+            message: truncateMessage(error.message),
+            stackTrace: truncateStack(error.stack),
+            ...(causes ? { causes } : {}),
         };
     }
     if (typeof error === "string") {
@@ -86,7 +292,7 @@ export function parseError(error) {
             raw: JSON.stringify(error),
         };
     }
-    catch (e) {
+    catch (_e) {
         return {
             type: "CUSTOM_ERROR",
             raw: String(error),
@@ -96,7 +302,8 @@ export function parseError(error) {
 export function createErrorTaskError(error) {
     switch (error.type) {
         case "BUILT_IN_ERROR": {
-            const e = new Error(error.message);
+            const cause = error.causes?.length ? createErrorFromCauses(error.causes) : undefined;
+            const e = new Error(error.message, cause ? { cause } : undefined);
             e.name = error.name;
             e.stack = error.stackTrace;
             return e;
@@ -123,6 +330,7 @@ export function createJsonErrorObject(error) {
                 name: enhancedError.name,
                 message: enhancedError.message,
                 stackTrace: enhancedError.stackTrace,
+                ...(enhancedError.causes?.length ? { causes: enhancedError.causes } : {}),
             };
         }
         case "STRING_ERROR": {
@@ -142,35 +350,59 @@ export function createJsonErrorObject(error) {
         }
     }
 }
-// Removes any null characters from the error message
+function sanitizeErrorCauses(causes) {
+    if (!causes || causes.length === 0) {
+        return undefined;
+    }
+    return causes.slice(0, MAX_ERROR_CAUSES).map((cause) => ({
+        name: truncateName(cause.name?.replace(/\0/g, "")),
+        message: truncateMessage(cause.message?.replace(/\0/g, "")),
+        stackTrace: cause.stackTrace
+            ? truncateStack(cause.stackTrace.replace(/\0/g, ""), MAX_CAUSE_STACK_FRAMES) || undefined
+            : undefined,
+    }));
+}
+// Removes null characters and truncates oversized fields to prevent OOM
 export function sanitizeError(error) {
     switch (error.type) {
         case "BUILT_IN_ERROR": {
+            const causes = sanitizeErrorCauses(error.causes);
             return {
                 type: "BUILT_IN_ERROR",
-                message: error.message?.replace(/\0/g, ""),
+                message: truncateMessage(error.message?.replace(/\0/g, "")),
                 name: error.name?.replace(/\0/g, ""),
-                stackTrace: error.stackTrace?.replace(/\0/g, ""),
+                stackTrace: truncateStack(error.stackTrace?.replace(/\0/g, "")),
+                ...(causes ? { causes } : {}),
             };
         }
         case "STRING_ERROR": {
             return {
                 type: "STRING_ERROR",
-                raw: error.raw.replace(/\0/g, ""),
+                raw: truncateMessage(error.raw.replace(/\0/g, "")),
             };
         }
         case "CUSTOM_ERROR": {
+            // CUSTOM_ERROR.raw holds JSON.stringify(error) which is later parsed by
+            // JSON.parse in createErrorTaskError. Naive truncation would cut mid-token
+            // and produce invalid JSON — wrap the preview in a valid JSON envelope.
+            const clean = error.raw.replace(/\0/g, "");
+            const safeRaw = clean.length > MAX_MESSAGE_LENGTH
+                ? JSON.stringify({ truncated: true, preview: clean.slice(0, MAX_MESSAGE_LENGTH) })
+                : clean;
             return {
                 type: "CUSTOM_ERROR",
-                raw: error.raw.replace(/\0/g, ""),
+                raw: safeRaw,
             };
         }
         case "INTERNAL_ERROR": {
+            // message and stackTrace are optional for INTERNAL_ERROR — preserve
+            // `undefined` so the `error.message ?? "Internal error (CODE)"` fallback
+            // in createErrorTaskError still kicks in (empty string is not nullish).
             return {
                 type: "INTERNAL_ERROR",
                 code: error.code,
-                message: error.message?.replace(/\0/g, ""),
-                stackTrace: error.stackTrace?.replace(/\0/g, ""),
+                message: error.message != null ? truncateMessage(error.message.replace(/\0/g, "")) : undefined,
+                stackTrace: error.stackTrace != null ? truncateStack(error.stackTrace.replace(/\0/g, "")) : undefined,
             };
         }
     }
@@ -185,28 +417,42 @@ export function shouldRetryError(error) {
                 case "CONFIGURED_INCORRECTLY":
                 case "TASK_ALREADY_RUNNING":
                 case "TASK_PROCESS_SIGKILL_TIMEOUT":
-                case "TASK_PROCESS_SIGSEGV":
                 case "TASK_PROCESS_OOM_KILLED":
                 case "TASK_PROCESS_MAYBE_OOM_KILLED":
                 case "TASK_RUN_CANCELLED":
                 case "MAX_DURATION_EXCEEDED":
                 case "DISK_SPACE_EXCEEDED":
-                case "TASK_RUN_HEARTBEAT_TIMEOUT":
                 case "OUTDATED_SDK_VERSION":
+                case "TASK_RUN_HEARTBEAT_TIMEOUT":
                 case "TASK_DID_CONCURRENT_WAIT":
                 case "RECURSIVE_WAIT_DEADLOCK":
+                // run engine errors
+                case "TASK_DEQUEUED_INVALID_STATE":
+                case "TASK_DEQUEUED_QUEUE_NOT_FOUND":
+                case "TASK_HAS_N0_EXECUTION_SNAPSHOT":
+                case "TASK_RUN_DEQUEUED_MAX_RETRIES":
+                case "BATCH_ITEM_COULD_NOT_TRIGGER":
+                case "PAYLOAD_TOO_LARGE":
+                case "UNSPECIFIED_ERROR":
                     return false;
+                //new heartbeat error
+                //todo
+                case "TASK_RUN_STALLED_EXECUTING":
+                case "TASK_RUN_STALLED_EXECUTING_WITH_WAITPOINTS":
                 case "GRACEFUL_EXIT_TIMEOUT":
                 case "HANDLE_ERROR_ERROR":
                 case "TASK_INPUT_ERROR":
                 case "TASK_OUTPUT_ERROR":
+                case "TASK_MIDDLEWARE_ERROR":
                 case "POD_EVICTED":
                 case "POD_UNKNOWN_ERROR":
                 case "TASK_EXECUTION_ABORTED":
                 case "TASK_EXECUTION_FAILED":
                 case "TASK_RUN_CRASHED":
+                case "TASK_RUN_UNCAUGHT_EXCEPTION":
                 case "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE":
                 case "TASK_PROCESS_SIGTERM":
+                case "TASK_PROCESS_SIGSEGV":
                     return true;
                 default:
                     assertExhaustive(error.code);
@@ -226,6 +472,34 @@ export function shouldRetryError(error) {
         }
     }
 }
+export function shouldLookupRetrySettings(error) {
+    switch (error.type) {
+        case "INTERNAL_ERROR": {
+            switch (error.code) {
+                case "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE":
+                case "TASK_PROCESS_SIGTERM":
+                case "TASK_PROCESS_SIGSEGV":
+                case "TASK_RUN_UNCAUGHT_EXCEPTION":
+                case "TASK_MIDDLEWARE_ERROR":
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        case "STRING_ERROR": {
+            return false;
+        }
+        case "BUILT_IN_ERROR": {
+            return false;
+        }
+        case "CUSTOM_ERROR": {
+            return false;
+        }
+        default: {
+            assertExhaustive(error);
+        }
+    }
+}
 export function correctErrorStackTrace(stackTrace, projectDir, options) {
     const [errorLine, ...traceLines] = stackTrace.split("\n");
     return [
@@ -322,6 +596,93 @@ export class TaskIndexingImportError extends Error {
         this.name = "TaskIndexingImportError";
     }
 }
+function formatDuplicateTaskIds(collisions) {
+    const lines = collisions.map(({ id, filePaths }) => {
+        const distinct = Array.from(new Set(filePaths));
+        if (distinct.length === 1) {
+            return `  - "${id}" found more than once in ${distinct[0]}`;
+        }
+        const last = distinct[distinct.length - 1];
+        const head = distinct.slice(0, -1).join(", ");
+        return `  - "${id}" found in ${head} and ${last}`;
+    });
+    return [
+        "Duplicate task ids detected:",
+        "",
+        ...lines,
+        "",
+        "Task ids must be unique across your project (including scheduled tasks). Please rename one of them.",
+    ].join("\n");
+}
+export class DuplicateTaskIdsError extends Error {
+    collisions;
+    constructor(collisions) {
+        super(formatDuplicateTaskIds(collisions));
+        this.collisions = collisions;
+        this.name = "DuplicateTaskIdsError";
+    }
+}
+function formatWebhookIndexingErrors(collisions, problems) {
+    const lines = collisions.map(({ id, filePaths }) => {
+        const distinct = Array.from(new Set(filePaths));
+        if (distinct.length === 1) {
+            return `  - endpoint "${id}" defined more than once in ${distinct[0]}`;
+        }
+        const last = distinct[distinct.length - 1];
+        const head = distinct.slice(0, -1).join(", ");
+        return `  - endpoint "${id}" defined in ${head} and ${last}`;
+    });
+    return [
+        "Webhook endpoints could not be indexed:",
+        "",
+        ...lines,
+        ...problems.map((problem) => `  - ${problem}`),
+    ].join("\n");
+}
+/**
+ * Webhook declarations the indexer refuses: an endpoint id defined twice, a subscriber whose
+ * endpoint isn't defined, or two subscribers with the same id on one endpoint.
+ */
+export class WebhookIndexingError extends Error {
+    collisions;
+    problems;
+    constructor(collisions, problems = []) {
+        super(formatWebhookIndexingErrors(collisions, problems));
+        this.collisions = collisions;
+        this.problems = problems;
+        this.name = "WebhookIndexingError";
+    }
+}
+/** A webhook waiter was cancelled before a delivery matched it. */
+export class WebhookWaiterCancelledError extends Error {
+    constructor(message = "The webhook waiter was cancelled") {
+        super(message);
+        this.name = "WebhookWaiterCancelledError";
+    }
+}
+/** `webhooks.waiter.create` hit a waiter limit. Nothing was created. */
+export class WebhookWaiterLimitError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = "WebhookWaiterLimitError";
+    }
+}
+/** The endpoint isn't in this environment's current deployment. */
+export class WebhookEndpointNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WebhookEndpointNotFoundError";
+    }
+}
+/** A waiter's filter didn't compile on the server. */
+export class WebhookFilterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WebhookFilterError";
+    }
+}
 export class UnexpectedExitError extends Error {
     code;
     signal;
@@ -340,6 +701,12 @@ export class CleanupProcessError extends Error {
         this.name = "CleanupProcessError";
     }
 }
+export class SuspendedProcessError extends Error {
+    constructor() {
+        super("Suspended");
+        this.name = "SuspendedProcessError";
+    }
+}
 export class CancelledProcessError extends Error {
     constructor() {
         super("Cancelled");
@@ -358,16 +725,44 @@ export class GracefulExitTimeoutError extends Error {
         this.name = "GracefulExitTimeoutError";
     }
 }
+export class ChatChunkTooLargeError extends Error {
+    chunkSize;
+    maxSize;
+    chunkType;
+    constructor(chunkSize, maxSize, chunkType) {
+        super(`chat.agent chunk${chunkType ? ` of type "${chunkType}"` : ""} is ${chunkSize} bytes, ` +
+            `over the realtime stream's per-record cap of ${maxSize} bytes. ` +
+            `For oversized payloads (e.g. large tool outputs), write the value to your own store and ` +
+            `emit only an id/url through the chat stream — see https://trigger.dev/docs/ai-chat/patterns/large-payloads.`);
+        this.chunkSize = chunkSize;
+        this.maxSize = maxSize;
+        this.chunkType = chunkType;
+        this.name = "ChatChunkTooLargeError";
+    }
+}
+export function isChatChunkTooLargeError(error) {
+    return error instanceof Error && error.name === "ChatChunkTooLargeError";
+}
+export class MaxDurationExceededError extends Error {
+    maxDurationInSeconds;
+    elapsedTimeInSeconds;
+    constructor(maxDurationInSeconds, elapsedTimeInSeconds) {
+        super(`Run exceeded maximum compute time (maxDuration) of ${maxDurationInSeconds} seconds`);
+        this.maxDurationInSeconds = maxDurationInSeconds;
+        this.elapsedTimeInSeconds = elapsedTimeInSeconds;
+        this.name = "MaxDurationExceededError";
+    }
+}
 const prettyInternalErrors = {
     TASK_PROCESS_OOM_KILLED: {
-        message: "Your task ran out of memory. Try increasing the machine specs. If this doesn't fix it there might be a memory leak.",
+        message: "Your run was terminated due to exceeding the machine's memory limit. Try increasing the machine preset in your task options or replay using a larger machine.",
         link: {
             name: "Machines",
             href: links.docs.machines.home,
         },
     },
     TASK_PROCESS_MAYBE_OOM_KILLED: {
-        message: "We think your task ran out of memory, but we can't be certain. If this keeps happening, try increasing the machine specs.",
+        message: "Your run was terminated due to exceeding the machine's memory limit. Try increasing the machine preset in your task options or replay using a larger machine.",
         link: {
             name: "Machines",
             href: links.docs.machines.home,
@@ -410,6 +805,24 @@ const prettyInternalErrors = {
             href: links.docs.concurrency.recursiveDeadlock,
         },
     },
+    TASK_RUN_STALLED_EXECUTING: {
+        link: {
+            name: "Read our troubleshooting guide",
+            href: links.docs.troubleshooting.stalledExecution,
+        },
+    },
+    // Link only — we deliberately do NOT set `message`, so the original
+    // error message (e.g. "read ECONNRESET") is preserved in the dashboard.
+    // Common cause: an EventEmitter (node-redis, pg, etc.) emitted "error"
+    // with no listener attached, which Node escalates to uncaughtException.
+    // The docs page explains how to attach .on("error") listeners and how
+    // unhandled rejections route through the same path.
+    TASK_RUN_UNCAUGHT_EXCEPTION: {
+        link: {
+            name: "Read our troubleshooting guide",
+            href: links.docs.troubleshooting.uncaughtException,
+        },
+    },
 };
 const getPrettyTaskRunError = (code) => {
     return {
@@ -438,6 +851,9 @@ const findSignalInMessage = (message, truncateLength = 100) => {
     else if (trunc.includes("SIGKILL")) {
         return "SIGKILL";
     }
+    else if (trunc.includes("SIGABRT")) {
+        return "SIGABRT";
+    }
     else {
         return;
     }
@@ -461,6 +877,10 @@ export function taskRunErrorEnhancer(error) {
                             return {
                                 ...getPrettyTaskRunError("TASK_PROCESS_MAYBE_OOM_KILLED"),
                             };
+                        case "SIGABRT":
+                            return {
+                                ...getPrettyTaskRunError("TASK_PROCESS_MAYBE_OOM_KILLED"),
+                            };
                         default:
                             return {
                                 ...getPrettyTaskRunError("TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE"),
@@ -482,6 +902,21 @@ export function taskRunErrorEnhancer(error) {
                     ...getPrettyTaskRunError("TASK_PROCESS_OOM_KILLED"),
                 };
             }
+            if (error.name === "TriggerApiError") {
+                if (error.message.startsWith("Deadlock detected:")) {
+                    return {
+                        type: "BUILT_IN_ERROR",
+                        name: "Concurrency Deadlock Error",
+                        message: error.message,
+                        stackTrace: "",
+                        ...(error.causes?.length ? { causes: error.causes } : {}),
+                        link: {
+                            name: "Read the docs",
+                            href: links.docs.concurrency.deadlock,
+                        },
+                    };
+                }
+            }
             break;
         }
         case "STRING_ERROR": {
@@ -506,6 +941,10 @@ export function taskRunErrorEnhancer(error) {
                         return {
                             ...getPrettyTaskRunError("TASK_PROCESS_MAYBE_OOM_KILLED"),
                         };
+                    case "SIGABRT":
+                        return {
+                            ...getPrettyTaskRunError("TASK_PROCESS_MAYBE_OOM_KILLED"),
+                        };
                     default: {
                         return {
                             ...getPrettyTaskRunError("TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE"),
@@ -553,6 +992,11 @@ export function exceptionEventEnhancer(exception) {
                             ...exception,
                             ...getPrettyExceptionEvent("TASK_PROCESS_MAYBE_OOM_KILLED"),
                         };
+                    case "SIGABRT":
+                        return {
+                            ...exception,
+                            ...getPrettyExceptionEvent("TASK_PROCESS_MAYBE_OOM_KILLED"),
+                        };
                     default:
                         return exception;
                 }
@@ -739,6 +1183,8 @@ export function createTaskMetadataFailedErrorStack(data) {
     const stack = [];
     const groupedIssues = groupTaskMetadataIssuesByTask(data.tasks, data.zodIssues);
     for (const key in groupedIssues) {
+        if (!Object.hasOwn(groupedIssues, key))
+            continue;
         const taskWithIssues = groupedIssues[key];
         if (!taskWithIssues) {
             continue;
@@ -773,7 +1219,7 @@ export function taskRunErrorToString(error) {
             return `Internal error [${error.code}]${error.message ? `: ${error.message}` : ""}`;
         }
         case "BUILT_IN_ERROR": {
-            return `${error.name}: ${error.message}`;
+            return `${error.name}: ${error.message}${formatErrorCauses(error.causes)}`;
         }
         case "STRING_ERROR": {
             return error.raw;