@sentry/junior 0.70.0 → 0.71.1

package/dist/app.js

@@ -93,8 +93,8 @@ import {
   pluginCatalogConfigFromPluginSet,
   pluginHookRegistrationsFromPluginSet,
   resolveConversationWorkQueueTopic,
-  verifySignedConversationQueueMessage
-} from "./chunk-IGLNC5H6.js";
+  verifyConversationQueueMessage
+} from "./chunk-XE2VFQQN.js";
 import {
   SlackActionError,
   createSlackDestination,
@@ -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()) ?? []);
@@ -23192,6 +23259,21 @@ import {
   registerDevConsumer
 } from "@vercel/queue";
 
+// src/chat/task-execution/queue.ts
+var ConversationQueueMessageRejectedError = class extends Error {
+  conversationId;
+  reason;
+  constructor(reason, message, options = {}) {
+    super(message);
+    this.name = "ConversationQueueMessageRejectedError";
+    this.reason = reason;
+    this.conversationId = options.conversationId;
+  }
+};
+function isConversationQueueMessageRejectedError(error) {
+  return error instanceof ConversationQueueMessageRejectedError;
+}
+
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
 var CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 24e4;
@@ -23212,11 +23294,21 @@ async function sendWakeNudge(args) {
       idempotencyKey: args.idempotencyKey
     }
   );
-  await markConversationWorkEnqueued({
-    conversationId: args.conversationId,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
+  try {
+    await markConversationWorkEnqueued({
+      conversationId: args.conversationId,
+      nowMs: args.nowMs,
+      state: args.options.state
+    });
+  } catch (error) {
+    logException(
+      error,
+      "conversation_work_enqueue_marker_failed",
+      { conversationId: args.conversationId },
+      {},
+      "Conversation work enqueue marker failed after queue acceptance"
+    );
+  }
 }
 async function requestLostLeaseRecovery(args) {
   const continuationMarked = await requestConversationContinuation({
@@ -23294,29 +23386,57 @@ async function processConversationWork(message, options) {
     return { status: "no_work" };
   }
   if (!sameDestination(initial.destination, message.destination)) {
-    throw new Error(
-      `Conversation work queue destination changed for ${conversationId}`
+    throw new ConversationQueueMessageRejectedError(
+      "destination_mismatch",
+      `Conversation work queue destination changed for ${conversationId}`,
+      { conversationId }
     );
   }
   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 +23590,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 +23698,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 {
@@ -23565,18 +23739,45 @@ async function processConversationQueueMessage(message, options) {
   });
 }
 async function handleConversationQueueMessage(message, options) {
-  const verified = verifySignedConversationQueueMessage(message);
-  if (!verified) {
-    throw new Error("Unauthorized conversation queue message");
+  const verification = verifyConversationQueueMessage(message);
+  if (verification.status === "rejected") {
+    throw new ConversationQueueMessageRejectedError(
+      verification.reason,
+      "Unauthorized conversation queue message"
+    );
+  }
+  if (verification.status === "unavailable") {
+    throw new Error(
+      `Conversation queue message verification unavailable: ${verification.reason}`
+    );
   }
   await runWithTurnRequestDeadline(
-    () => processConversationQueueMessage(verified, options)
+    () => processConversationQueueMessage(verification.message, options)
+  );
+}
+function handleConversationQueueRetry(error, metadata) {
+  if (!isConversationQueueMessageRejectedError(error)) {
+    return void 0;
+  }
+  logWarn(
+    "conversation_queue_message_rejected",
+    error.conversationId ? { conversationId: error.conversationId } : {},
+    {
+      "app.queue.consumer_group": metadata.consumerGroup,
+      "app.queue.delivery_count": metadata.deliveryCount,
+      "app.queue.message_id": metadata.messageId,
+      "app.queue.reject_reason": error.reason,
+      "app.queue.topic_name": metadata.topicName
+    },
+    "Conversation queue message rejected without retry"
   );
+  return { acknowledge: true };
 }
 function createVercelConversationWorkCallback(options) {
   return handleCallback(
     (message) => handleConversationQueueMessage(message, options),
     {
+      retry: handleConversationQueueRetry,
       visibilityTimeoutSeconds: options.visibilityTimeoutSeconds ?? resolveConversationWorkVisibilityTimeoutSeconds()
     }
   );
@@ -23589,6 +23790,7 @@ function registerVercelConversationWorkDevConsumer(options) {
     client: new QueueClient(),
     consumerGroup: CONVERSATION_WORK_DEV_CONSUMER_GROUP,
     handler: (message) => handleConversationQueueMessage(message, options),
+    retry: handleConversationQueueRetry,
     topic: resolveConversationWorkQueueTopic(options),
     visibilityTimeoutSeconds: options.visibilityTimeoutSeconds ?? resolveConversationWorkVisibilityTimeoutSeconds()
   });

package/dist/chat/task-execution/queue-signing.d.ts

@@ -1,12 +1,25 @@
 import type { ConversationQueueMessage } from "./queue";
 declare const CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION = "v1";
+export declare const CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS: number;
 interface SignedConversationQueueMessage extends ConversationQueueMessage {
     signature: string;
     signatureVersion: typeof CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION;
     signedAtMs: number;
 }
+export type ConversationQueueMessageVerificationResult = {
+    message: ConversationQueueMessage;
+    status: "verified";
+} | {
+    reason: "expired" | "malformed" | "signature_mismatch";
+    status: "rejected";
+} | {
+    reason: "invalid_clock" | "missing_secret";
+    status: "unavailable";
+};
 /** Sign a conversation queue payload before it crosses the public callback route. */
 export declare function signConversationQueueMessage(message: ConversationQueueMessage, nowMs?: number): SignedConversationQueueMessage;
+/** Explain whether a queue payload is verified, rejected, or temporarily unverifiable. */
+export declare function verifyConversationQueueMessage(value: unknown, nowMs?: number): ConversationQueueMessageVerificationResult;
 /** Verify a signed conversation queue payload from the Vercel Queue callback. */
 export declare function verifySignedConversationQueueMessage(value: unknown, nowMs?: number): ConversationQueueMessage | undefined;
 export {};

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

@@ -3,6 +3,16 @@ export interface ConversationQueueMessage {
     conversationId: string;
     destination: Destination;
 }
+export type ConversationQueueMessageRejectReason = "destination_mismatch" | "expired" | "malformed" | "signature_mismatch" | "unauthorized";
+export declare class ConversationQueueMessageRejectedError extends Error {
+    conversationId?: string;
+    reason: ConversationQueueMessageRejectReason;
+    constructor(reason: ConversationQueueMessageRejectReason, message: string, options?: {
+        conversationId?: string;
+    });
+}
+/** Return whether a queue payload was permanently rejected at the message boundary. */
+export declare function isConversationQueueMessageRejectedError(error: unknown): error is ConversationQueueMessageRejectedError;
 export interface ConversationQueueSendOptions {
     delayMs?: number;
     idempotencyKey?: string;

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/vercel-callback.d.ts

@@ -1,5 +1,5 @@
 import type { StateAdapter } from "chat";
-import type { ConversationWorkQueue } from "./queue";
+import { type ConversationWorkQueue } from "./queue";
 import { type ConversationWorkProcessResult, type ConversationWorkerResult, type ConversationWorkerContext } from "./worker";
 export declare const CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS = 30;
 export declare const CONVERSATION_WORK_DEV_CONSUMER_GROUP = "junior_conversation_work_dev";

package/dist/chat/task-execution/vercel-queue.d.ts

@@ -1,6 +1,7 @@
 import type { SendOptions, SendResult } from "@vercel/queue";
 import type { ConversationWorkQueue } from "./queue";
 export declare const DEFAULT_CONVERSATION_WORK_QUEUE_TOPIC = "junior_conversation_work";
+export declare const CONVERSATION_WORK_QUEUE_RETENTION_SECONDS: number;
 interface QueueSender {
     send<T = unknown>(topicName: string, payload: T, options?: SendOptions): Promise<SendResult>;
 }

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

@@ -1,6 +1,6 @@
 import type { StateAdapter } from "chat";
 import type { Destination } from "@sentry/junior-plugin-api";
-import type { ConversationQueueMessage, ConversationWorkQueue } from "./queue";
+import { type ConversationQueueMessage, type ConversationWorkQueue } from "./queue";
 import { type InboundMessageRecord } from "./store";
 export declare const CONVERSATION_WORK_DEFER_DELAY_MS = 15000;
 export declare const CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 240000;
@@ -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/dist/{chunk-IGLNC5H6.js → chunk-XE2VFQQN.js}

@@ -163,24 +163,37 @@ function signConversationQueueMessage(message, nowMs = Date.now()) {
     signature: signPayload(message, nowMs, secret)
   };
 }
-function verifySignedConversationQueueMessage(value, nowMs = Date.now()) {
+function verifyConversationQueueMessage(value, nowMs = Date.now()) {
   const message = parseSignedConversationQueueMessage(value);
+  if (!message) {
+    return { status: "rejected", reason: "malformed" };
+  }
   const secret = getConversationWorkQueueSecret();
-  if (!message || !secret || !Number.isFinite(nowMs) || Math.abs(nowMs - message.signedAtMs) > CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS) {
-    return void 0;
+  if (!secret) {
+    return { status: "unavailable", reason: "missing_secret" };
+  }
+  if (!Number.isFinite(nowMs)) {
+    return { status: "unavailable", reason: "invalid_clock" };
+  }
+  if (Math.abs(nowMs - message.signedAtMs) > CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS) {
+    return { status: "rejected", reason: "expired" };
   }
   const expected = signPayload(message, message.signedAtMs, secret);
   if (!timingSafeMatch(expected, message.signature)) {
-    return void 0;
+    return { status: "rejected", reason: "signature_mismatch" };
   }
   return {
-    conversationId: message.conversationId,
-    destination: message.destination
+    status: "verified",
+    message: {
+      conversationId: message.conversationId,
+      destination: message.destination
+    }
   };
 }
 
 // src/chat/task-execution/vercel-queue.ts
 var DEFAULT_CONVERSATION_WORK_QUEUE_TOPIC = "junior_conversation_work";
+var CONVERSATION_WORK_QUEUE_RETENTION_SECONDS = CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS / 1e3;
 var defaultQueue;
 function resolveConversationWorkQueueTopic(options = {}) {
   const topic = options.topic?.trim();
@@ -203,7 +216,7 @@ function createVercelConversationWorkQueue(options = {}) {
         {
           idempotencyKey: sendOptions?.idempotencyKey,
           delaySeconds: toDelaySeconds(sendOptions),
-          retentionSeconds: options.retentionSeconds
+          retentionSeconds: options.retentionSeconds ?? CONVERSATION_WORK_QUEUE_RETENTION_SECONDS
         }
       );
       return result.messageId ? { messageId: result.messageId } : {};
@@ -219,7 +232,7 @@ export {
   defineJuniorPlugins,
   pluginCatalogConfigFromPluginSet,
   pluginHookRegistrationsFromPluginSet,
-  verifySignedConversationQueueMessage,
+  verifyConversationQueueMessage,
   resolveConversationWorkQueueTopic,
   getVercelConversationWorkQueue
 };

package/dist/nitro.js

@@ -2,7 +2,7 @@ import {
   pluginCatalogConfigFromPluginSet,
   pluginHookRegistrationsFromPluginSet,
   resolveConversationWorkQueueTopic
-} from "./chunk-IGLNC5H6.js";
+} from "./chunk-XE2VFQQN.js";
 import "./chunk-76YMBKW7.js";
 import {
   JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.70.0",
+  "version": "0.71.1",
   "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.1"
   },
   "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.1"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",