@sentry/junior 0.70.0 → 0.71.0

package/dist/app.js

@@ -13951,6 +13951,7 @@ var CONVERSATION_WORK_MUTATION_RETRY_MS = 25;
 var CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
 var CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
 var CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
+var CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES = 5;
 function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
   return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
 }
@@ -14072,14 +14073,18 @@ function normalizeWorkState(conversationId, value) {
     messages,
     needsRun: value.needsRun === true,
     updatedAtMs,
+    consecutiveFailureCount: toOptionalNumber(value.consecutiveFailureCount) ?? 0,
     lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
-    lease: normalizeLease(value.lease)
+    lastFailureAtMs: toOptionalNumber(value.lastFailureAtMs),
+    lease: normalizeLease(value.lease),
+    terminallyFailedAtMs: toOptionalNumber(value.terminallyFailedAtMs)
   };
 }
 function emptyWorkState(args) {
   return {
     schemaVersion: CONVERSATION_WORK_SCHEMA_VERSION,
     conversationId: args.conversationId,
+    consecutiveFailureCount: 0,
     destination: args.destination,
     messages: [],
     needsRun: false,
@@ -14093,6 +14098,9 @@ function pendingMessages(state) {
   return state.messages.filter((message) => message.injectedAtMs === void 0).sort(compareMessages);
 }
 function shouldKeepIndexed(state) {
+  if (state.terminallyFailedAtMs !== void 0) {
+    return false;
+  }
   return state.needsRun || Boolean(state.lease) || pendingMessages(state).length > 0;
 }
 async function getConnectedState(stateAdapter) {
@@ -14217,6 +14225,9 @@ async function writeWorkState(state, work) {
   }
 }
 function hasRunnableWork(state) {
+  if (state.terminallyFailedAtMs !== void 0) {
+    return false;
+  }
   return state.needsRun || pendingMessages(state).length > 0;
 }
 function assertSameConversationDestination(args) {
@@ -14266,8 +14277,11 @@ async function appendInboundMessage(args) {
       }
       const next = {
         ...current,
+        consecutiveFailureCount: 0,
+        lastFailureAtMs: void 0,
         messages: [...current.messages, args.message].sort(compareMessages),
         needsRun: true,
+        terminallyFailedAtMs: void 0,
         updatedAtMs: nowMs
       };
       await writeWorkState(state, next);
@@ -14435,6 +14449,8 @@ async function drainConversationMailbox(args) {
     );
     await writeWorkState(state, {
       ...current,
+      consecutiveFailureCount: 0,
+      lastFailureAtMs: void 0,
       messages,
       needsRun: hasPending,
       updatedAtMs: nowMs
@@ -14466,6 +14482,8 @@ async function markConversationMessagesInjected(args) {
     }
     await writeWorkState(state, {
       ...current,
+      consecutiveFailureCount: 0,
+      lastFailureAtMs: void 0,
       messages,
       updatedAtMs: nowMs
     });
@@ -14518,6 +14536,8 @@ async function completeConversationWork(args) {
     const hasRunnableWork2 = current.needsRun || hasPending;
     await writeWorkState(state, {
       ...current,
+      consecutiveFailureCount: 0,
+      lastFailureAtMs: void 0,
       lease: void 0,
       needsRun: hasRunnableWork2,
       updatedAtMs: nowMs
@@ -14541,6 +14561,53 @@ async function clearExpiredConversationLease(args) {
     return true;
   });
 }
+async function recordConversationWorkFailure(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const current = await readWorkState(state, args.conversationId);
+    if (!current) {
+      return {
+        abandoned: false,
+        consecutiveFailureCount: 0,
+        releasedLease: false
+      };
+    }
+    const consecutiveFailureCount = current.consecutiveFailureCount + 1;
+    const abandoned = consecutiveFailureCount >= CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES;
+    if (!abandoned) {
+      await writeWorkState(state, {
+        ...current,
+        consecutiveFailureCount,
+        lastFailureAtMs: nowMs,
+        updatedAtMs: nowMs
+      });
+      return {
+        abandoned: false,
+        consecutiveFailureCount,
+        releasedLease: false
+      };
+    }
+    const releasedLease = Boolean(current.lease);
+    const drainedMessages = current.messages.filter(
+      (message) => message.injectedAtMs !== void 0
+    );
+    await writeWorkState(state, {
+      ...current,
+      consecutiveFailureCount,
+      lastFailureAtMs: nowMs,
+      lease: void 0,
+      messages: drainedMessages,
+      needsRun: false,
+      terminallyFailedAtMs: nowMs,
+      updatedAtMs: nowMs
+    });
+    return {
+      abandoned: true,
+      consecutiveFailureCount,
+      releasedLease
+    };
+  });
+}
 async function listConversationWorkIds(args = {}) {
   const state = await getConnectedState(args.state);
   const ids = uniqueStrings(await state.get(indexKey()) ?? []);
@@ -23299,24 +23366,50 @@ async function processConversationWork(message, options) {
     );
   }
   const destination = initial.destination;
-  const lease = await startConversationWork({
-    conversationId,
-    nowMs: now2(options),
-    state: options.state
-  });
+  let lease;
+  try {
+    lease = await startConversationWork({
+      conversationId,
+      nowMs: now2(options),
+      state: options.state
+    });
+  } catch (error) {
+    logException(
+      error,
+      "conversation_work_lease_acquire_failed",
+      { conversationId },
+      {},
+      "Conversation work lease acquisition failed; heartbeat will recover"
+    );
+    return { status: "no_work" };
+  }
   if (lease.status === "no_work") {
     return { status: "no_work" };
   }
   if (lease.status === "active") {
     const nudgeNowMs = now2(options);
-    await sendWakeNudge({
-      conversationId,
-      destination,
-      delayMs: CONVERSATION_WORK_DEFER_DELAY_MS,
-      idempotencyKey: nudgeIdempotencyKey("active", conversationId, nudgeNowMs),
-      nowMs: nudgeNowMs,
-      options
-    });
+    try {
+      await sendWakeNudge({
+        conversationId,
+        destination,
+        delayMs: CONVERSATION_WORK_DEFER_DELAY_MS,
+        idempotencyKey: nudgeIdempotencyKey(
+          "active",
+          conversationId,
+          nudgeNowMs
+        ),
+        nowMs: nudgeNowMs,
+        options
+      });
+    } catch (error) {
+      logException(
+        error,
+        "conversation_work_active_nudge_failed",
+        { conversationId },
+        {},
+        "Conversation work active-lease nudge failed; heartbeat will recover"
+      );
+    }
     logInfo(
       "conversation_work_nudge_deferred_for_active_lease",
       { conversationId },
@@ -23470,35 +23563,97 @@ async function processConversationWork(message, options) {
     return { status: "completed" };
   } catch (error) {
     const errorNowMs = now2(options);
+    let failure2;
     try {
-      const continuationMarked = await requestConversationContinuation({
+      failure2 = await recordConversationWorkFailure({
         conversationId,
-        destination,
-        leaseToken: lease.leaseToken,
         nowMs: errorNowMs,
         state: options.state
       });
-      if (continuationMarked) {
-        await sendWakeNudge({
+    } catch (recordError) {
+      logException(
+        recordError,
+        "conversation_work_failure_record_failed",
+        { conversationId },
+        {},
+        "Conversation work failure counter update failed"
+      );
+    }
+    if (!isProviderRetryError(error)) {
+      logException(
+        error,
+        "conversation_work_failed",
+        { conversationId },
+        {
+          "app.worker.consecutive_failure_count": failure2?.consecutiveFailureCount ?? null,
+          "app.worker.elapsed_ms": now2(options) - startedAtMs
+        },
+        "Conversation work failed"
+      );
+    }
+    if (failure2?.abandoned) {
+      logWarn(
+        "conversation_work_abandoned",
+        { conversationId },
+        {
+          "app.worker.consecutive_failure_count": failure2.consecutiveFailureCount,
+          "app.worker.max_consecutive_failures": CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES
+        },
+        "Conversation work abandoned after repeated failures; stopping retries"
+      );
+      if (!failure2.releasedLease) {
+        try {
+          await releaseConversationWork({
+            conversationId,
+            leaseToken: lease.leaseToken,
+            nowMs: errorNowMs,
+            state: options.state
+          });
+        } catch (releaseError) {
+          logException(
+            releaseError,
+            "conversation_work_release_failed",
+            { conversationId },
+            {},
+            "Conversation work release failed after abandoning"
+          );
+        }
+      }
+      return { status: "abandoned" };
+    }
+    let requeueSucceeded = false;
+    if (failure2) {
+      try {
+        const continuationMarked = await requestConversationContinuation({
           conversationId,
           destination,
-          idempotencyKey: nudgeIdempotencyKey(
-            "error",
-            conversationId,
-            errorNowMs
-          ),
+          leaseToken: lease.leaseToken,
           nowMs: errorNowMs,
-          options
+          state: options.state
         });
+        if (continuationMarked) {
+          await sendWakeNudge({
+            conversationId,
+            destination,
+            idempotencyKey: nudgeIdempotencyKey(
+              "error",
+              conversationId,
+              errorNowMs
+            ),
+            nowMs: errorNowMs,
+            options
+          });
+          requeueSucceeded = true;
+        }
+      } catch (requeueError) {
+        logException(
+          requeueError,
+          "conversation_work_requeue_failed",
+          { conversationId },
+          {},
+          "Conversation work requeue failed after runner error"
+        );
       }
-    } catch (requeueError) {
-      logException(
-        requeueError,
-        "conversation_work_requeue_failed",
-        { conversationId },
-        {},
-        "Conversation work requeue failed after runner error"
-      );
     }
     try {
       await releaseConversationWork({
@@ -23516,16 +23671,8 @@ async function processConversationWork(message, options) {
         "Conversation work release failed after runner error"
       );
     }
-    if (!isProviderRetryError(error)) {
-      logException(
-        error,
-        "conversation_work_failed",
-        { conversationId },
-        {
-          "app.worker.elapsed_ms": now2(options) - startedAtMs
-        },
-        "Conversation work failed"
-      );
+    if (requeueSucceeded) {
+      return { status: "pending_requeued" };
     }
     throw error;
   } finally {

package/dist/chat/task-execution/store.d.ts

@@ -4,6 +4,7 @@ import type { ConversationWorkQueue } from "./queue";
 export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
+export declare const CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES = 5;
 export type InboundMessageSource = "plugin" | "scheduler" | "slack";
 export interface AgentInputMessage {
     attachments?: unknown[];
@@ -28,13 +29,16 @@ export interface ConversationLease {
     leaseToken: string;
 }
 export interface ConversationWorkState {
+    consecutiveFailureCount: number;
     conversationId: string;
     destination: Destination;
     lastEnqueuedAtMs?: number;
+    lastFailureAtMs?: number;
     lease?: ConversationLease;
     messages: InboundMessageRecord[];
     needsRun: boolean;
     schemaVersion: 1;
+    terminallyFailedAtMs?: number;
     updatedAtMs: number;
 }
 export interface ConversationLeaseAcquired {
@@ -151,6 +155,25 @@ export declare function clearExpiredConversationLease(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
+export interface RecordConversationWorkFailureResult {
+    abandoned: boolean;
+    consecutiveFailureCount: number;
+    releasedLease: boolean;
+}
+/**
+ * Increment the durable failure counter after a caught worker error so
+ * deterministic poison work cannot churn the queue forever. When the counter
+ * crosses {@link CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES}, the conversation
+ * is marked terminally failed: the lease is cleared, pending mailbox messages
+ * are dropped, and the conversation drops out of the recovery index so neither
+ * the worker nor heartbeat will requeue it again. A later inbound message
+ * resets the counter and gives the conversation a fresh attempt.
+ */
+export declare function recordConversationWorkFailure(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<RecordConversationWorkFailureResult>;
 /** List bounded conversation ids that may need heartbeat recovery. */
 export declare function listConversationWorkIds(args?: {
     limit?: number;

package/dist/chat/task-execution/worker.d.ts

@@ -16,7 +16,7 @@ export interface ConversationWorkerResult {
     status: "completed" | "lost_lease" | "yielded";
 }
 export interface ConversationWorkProcessResult {
-    status: "active" | "completed" | "lost_lease" | "no_work" | "pending_requeued" | "yielded";
+    status: "abandoned" | "active" | "completed" | "lost_lease" | "no_work" | "pending_requeued" | "yielded";
 }
 export interface ProcessConversationWorkOptions {
     checkInIntervalMs?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.70.0",
+  "version": "0.71.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -65,7 +65,7 @@
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.70.0"
+    "@sentry/junior-plugin-api": "0.71.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -78,7 +78,7 @@
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
     "vitest": "^4.1.7",
-    "@sentry/junior-scheduler": "0.70.0"
+    "@sentry/junior-scheduler": "0.71.0"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",