@sentry/junior 0.120.0 → 0.122.0

package/dist/{chunk-QOQPPRFS.js → chunk-4TGVC42X.js}

@@ -13,7 +13,7 @@ import {
   persistAuthPauseTurnState,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-BHXW734F.js";
+} from "./chunk-V6XPIKYA.js";
 import {
   buildSentryConversationUrl
 } from "./chunk-4CODA7P5.js";
@@ -40,7 +40,7 @@ import {
   resolveBaseUrl,
   resolvePluginOAuthAccount,
   truncateStatusText
-} from "./chunk-TKUCRFNX.js";
+} from "./chunk-VCC7XFX2.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
   TurnSliceLimitExceededError,
@@ -50,8 +50,10 @@ import {
   clearPendingAuth,
   coerceThreadArtifactsState,
   coerceThreadConversationState,
+  commitAcceptedReply,
   failAgentTurnSessionRecord,
   getAgentTurnSessionRecord,
+  getAssistantReplyText,
   getChannelConfigurationServiceById,
   getConversationPendingAuth,
   getPersistedSandboxState,
@@ -70,7 +72,7 @@ import {
   recordDeliveredAssistantMessage,
   turnHasReply,
   updateConversationStats
-} from "./chunk-JQWP6V22.js";
+} from "./chunk-NNGYYGX5.js";
 import {
   SlackActionError,
   getDashboardConversationLink,
@@ -79,19 +81,19 @@ import {
   getSlackClient,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-24B5R6OU.js";
+} from "./chunk-USKP7IM2.js";
 import {
   getConversationEventStore,
   getConversationStore,
   parseDestination,
   requireSlackDestination,
   sameDestination
-} from "./chunk-M243JMZH.js";
+} from "./chunk-DOB5RVMH.js";
 import {
   acquireActiveLock,
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-ALAKN7LR.js";
+} from "./chunk-TZVZCIYL.js";
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   botConfig,
@@ -100,24 +102,24 @@ import {
   getRuntimeMetadata,
   normalizeSlackEmojiName,
   standardModelId
-} from "./chunk-VURFJVFH.js";
+} from "./chunk-2RFM7STT.js";
 import {
   parseSlackThreadId,
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-HDFGNU5E.js";
+} from "./chunk-S7G34U75.js";
 import {
   discoverSkills
-} from "./chunk-EIVE6GL4.js";
+} from "./chunk-E5SRLZQV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-GNNV3UTY.js";
+} from "./chunk-OKUZIXQM.js";
 import {
   buildOAuthTokenRequest,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse
-} from "./chunk-XAI2HNAY.js";
+} from "./chunk-GN6WW7WR.js";
 import {
   createSlackResumeActor,
   isUserActor,
@@ -127,8 +129,10 @@ import {
   buildTurnFailureResponse,
   logException,
   logInfo,
-  logWarn
-} from "./chunk-ALYQOZG7.js";
+  logWarn,
+  setTags,
+  withLogContext
+} from "./chunk-4SPRQJOW.js";
 import {
   isRecord,
   toOptionalNumber,
@@ -463,18 +467,13 @@ async function runWithBoundSlackToken(adapter, token, task) {
   return await adapter.withBotToken(token, task);
 }
 function logAssistantStatusFailure(args) {
-  logWarn(
-    "assistant_status_update_failed",
-    {},
-    {
-      "app.slack.status_text": args.status || "(clear)",
-      "app.slack.channel_id_raw": args.channelId,
-      "app.slack.channel_id": args.normalizedChannelId,
-      "app.slack.thread_ts": args.threadTs,
-      "exception.message": args.error instanceof Error ? args.error.message : String(args.error)
-    },
-    `Failed to update assistant status channel=${args.normalizedChannelId} raw=${args.channelId} thread=${args.threadTs}`
-  );
+  logWarn("assistant.status.update.failed", {
+    "app.slack.status_text": args.status || "(clear)",
+    "app.slack.channel_id_raw": args.channelId,
+    "app.slack.channel_id": args.normalizedChannelId,
+    "app.slack.thread_ts": args.threadTs,
+    "exception.message": args.error instanceof Error ? args.error.message : String(args.error)
+  });
 }
 
 // src/chat/slack/assistant-thread/status.ts
@@ -954,8 +953,7 @@ async function startSlackProcessingReaction(args) {
   return startSlackProcessingReactionForMessage({
     channelId,
     timestamp: messageTs,
-    logException: args.logException,
-    logContext: args.logContext
+    logException: args.logException
   });
 }
 async function startSlackProcessingReactionForMessage(args) {
@@ -966,17 +964,11 @@ async function startSlackProcessingReactionForMessage(args) {
       emoji: getChatConfig().slack.processingReactionEmoji
     });
   } catch (error) {
-    args.logException(
-      error,
-      "slack_processing_reaction_add_failed",
-      args.logContext,
-      {
-        "app.slack.action": "reactions.add",
-        "messaging.message.id": args.timestamp,
-        ...getSlackErrorObservabilityAttributes(error)
-      },
-      "Failed to add Slack processing reaction"
-    );
+    args.logException(error, "slack.processing.reaction_add.failed", {
+      "app.slack.action": "reactions.add",
+      "messaging.message.id": args.timestamp,
+      ...getSlackErrorObservabilityAttributes(error)
+    });
     return noProcessingReaction;
   }
   let shouldRemove = true;
@@ -992,17 +984,11 @@ async function startSlackProcessingReactionForMessage(args) {
       });
       return true;
     } catch (error) {
-      args.logException(
-        error,
-        "slack_processing_reaction_remove_failed",
-        args.logContext,
-        {
-          "app.slack.action": "reactions.remove",
-          "messaging.message.id": args.timestamp,
-          ...getSlackErrorObservabilityAttributes(error)
-        },
-        "Failed to remove Slack processing reaction"
-      );
+      args.logException(error, "slack.processing.reaction_remove.failed", {
+        "app.slack.action": "reactions.remove",
+        "messaging.message.id": args.timestamp,
+        ...getSlackErrorObservabilityAttributes(error)
+      });
       return false;
     }
   };
@@ -1020,17 +1006,11 @@ async function startSlackProcessingReactionForMessage(args) {
           emoji: getChatConfig().slack.completedReactionEmoji
         });
       } catch (error) {
-        args.logException(
-          error,
-          "slack_processing_reaction_complete_failed",
-          args.logContext,
-          {
-            "app.slack.action": "reactions.add",
-            "messaging.message.id": args.timestamp,
-            ...getSlackErrorObservabilityAttributes(error)
-          },
-          "Failed to add Slack completed reaction"
-        );
+        args.logException(error, "slack.processing.reaction_complete.failed", {
+          "app.slack.action": "reactions.add",
+          "messaging.message.id": args.timestamp,
+          ...getSlackErrorObservabilityAttributes(error)
+        });
       }
     },
     keep: () => {
@@ -1175,14 +1155,7 @@ async function postResumeFailureReply(args) {
   });
 }
 async function handleResumeFailure(args) {
-  const logContext = getResumeLogContext(args.resumeArgs, args.lockKey);
-  const capturedEventId = logException(
-    args.error,
-    args.eventName,
-    logContext,
-    {},
-    args.body
-  );
+  const capturedEventId = logException(args.error, args.eventName);
   const eventId = requireTurnFailureEventId(capturedEventId, args.eventName);
   let failureStatePersistError;
   try {
@@ -1190,10 +1163,8 @@ async function handleResumeFailure(args) {
   } catch (persistError) {
     const persistEventId = logException(
       persistError,
-      "slack_resume_failure_state_persist_failed",
-      logContext,
-      { "app.error.original_event_id": eventId },
-      "Failed to persist resumed turn failure state"
+      "slack.resume.failure_state_persist.failed",
+      { "app.error.original_event_id": eventId }
     );
     try {
       await args.turnLifecycle.fail({
@@ -1206,10 +1177,8 @@ async function handleResumeFailure(args) {
     } catch (lifecycleError) {
       logException(
         lifecycleError,
-        "slack_resume_failure_lifecycle_persist_failed",
-        logContext,
-        { "app.error.original_event_id": eventId },
-        "Failed to record resumed turn persistence failure"
+        "slack.resume.failure_lifecycle_persist.failed",
+        { "app.error.original_event_id": eventId }
       );
     }
     failureStatePersistError = persistError;
@@ -1224,10 +1193,8 @@ async function handleResumeFailure(args) {
   } catch (deliveryError) {
     const deliveryEventId = logException(
       deliveryError,
-      "slack_resume_failure_delivery_failed",
-      logContext,
-      { "app.error.original_event_id": eventId },
-      "Failed to deliver resumed turn failure state"
+      "slack.resume.failure_delivery.failed",
+      { "app.error.original_event_id": eventId }
     );
     try {
       await args.turnLifecycle.fail({
@@ -1240,10 +1207,8 @@ async function handleResumeFailure(args) {
     } catch (lifecycleError) {
       logException(
         lifecycleError,
-        "slack_resume_failure_lifecycle_persist_failed",
-        logContext,
-        { "app.error.original_event_id": eventId },
-        "Failed to record resumed turn delivery failure"
+        "slack.resume.failure_lifecycle_persist.failed",
+        { "app.error.original_event_id": eventId }
       );
     }
     throw deliveryError;
@@ -1319,6 +1284,13 @@ function createResumeReplyContext(args, statusSession, delivery) {
   };
 }
 async function resumeSlackTurn(args) {
+  const lockKey = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
+  return withLogContext(
+    getResumeLogContext(args, lockKey),
+    () => resumeSlackTurnInContext(args)
+  );
+}
+async function resumeSlackTurnInContext(args) {
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
   const lockKey = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
@@ -1348,6 +1320,7 @@ async function resumeSlackTurn(args) {
     if (preparedArgs) {
       runArgs = { ...args, ...preparedArgs };
     }
+    setTags(getResumeLogContext(runArgs, lockKey));
     const activeReplyContext = runArgs.replyContext;
     if (!activeReplyContext) {
       throw new Error("Resumed turn requires replyContext");
@@ -1377,8 +1350,7 @@ async function resumeSlackTurn(args) {
       processingReaction = await startSlackProcessingReactionForMessage({
         channelId: runArgs.channelId,
         timestamp: runArgs.messageTs,
-        logException,
-        logContext: { ...getResumeLogContext(runArgs, lockKey) }
+        logException
       });
     }
     if (runArgs.initialText) {
@@ -1422,8 +1394,10 @@ async function resumeSlackTurn(args) {
         ...userMessageId ? { userMessageId } : {}
       };
     };
-    const deliverAssistantMessage = async (assistantMessage) => {
-      if (!assistantMessage.text.trim()) {
+    const deliverAssistantMessage = async (reply) => {
+      const message = typeof reply === "string" ? void 0 : reply;
+      const text = typeof reply === "string" ? reply : getAssistantReplyText(reply);
+      if (!text?.trim()) {
         return;
       }
       failureCode = "delivery_failed";
@@ -1433,7 +1407,7 @@ async function resumeSlackTurn(args) {
         messageTs = await sendSlackReply({
           channelId: runArgs.channelId,
           conversationId: runArgs.conversationId,
-          text: assistantMessage.text,
+          text,
           threadTs: runArgs.threadTs
         });
       } catch (error) {
@@ -1447,7 +1421,7 @@ async function resumeSlackTurn(args) {
       const recordedMessageId = recordDeliveredAssistantMessage({
         conversation: deliveryState2.conversation,
         sessionId: deliveryState2.sessionId,
-        text: assistantMessage.text,
+        text,
         userMessageId: deliveryState2.userMessageId
       });
       if (messageTs) {
@@ -1457,7 +1431,12 @@ async function resumeSlackTurn(args) {
       }
       try {
         await persistWithRetry(
-          () => persistConversationMessages({
+          () => message ? commitAcceptedReply({
+            agentMessage: message,
+            conversation: deliveryState2.conversation,
+            conversationMessageId: recordedMessageId,
+            conversationId
+          }) : persistConversationMessages({
             conversation: deliveryState2.conversation,
             conversationId
           })
@@ -1465,10 +1444,8 @@ async function resumeSlackTurn(args) {
       } catch (error) {
         logException(
           new Error("Accepted assistant message persistence failed"),
-          "slack_resume_assistant_message_post_delivery_persist_failed",
-          getResumeLogContext(runArgs, lockKey),
-          { "error.type": error instanceof Error ? error.name : typeof error },
-          "Failed to persist an accepted resumed assistant message"
+          "slack.resume.assistant_message_post_delivery_persist.failed",
+          { "error.type": error instanceof Error ? error.name : typeof error }
         );
       }
       const routing = runArgs.replyContext?.routing;
@@ -1490,13 +1467,7 @@ async function resumeSlackTurn(args) {
             })
           );
         } catch (error) {
-          logException(
-            error,
-            "agent_turn_delivery_receipt_persist_failed",
-            getResumeLogContext(runArgs, lockKey),
-            {},
-            "Failed to persist accepted resumed turn delivery receipt"
-          );
+          logException(error, "agent.turn.delivery_receipt_persist.failed");
         }
       }
       failureCode = "agent_run_failed";
@@ -1506,9 +1477,11 @@ async function resumeSlackTurn(args) {
       deliveryState.conversation,
       sessionId
     );
-    const replyContext = createResumeReplyContext(runArgs, status, {
-      onAssistantMessage: deliverAssistantMessage
-    });
+    const replyContext = createResumeReplyContext(
+      runArgs,
+      status,
+      deliverAssistantMessage
+    );
     if (runArgs.inputMessageIds?.length) {
       await turnLifecycle.start({
         conversationId: runArgs.conversationId,
@@ -1559,7 +1532,7 @@ async function resumeSlackTurn(args) {
             error: new Error(
               `Resumed run ended ${outcome.status} without a pause handler`
             ),
-            eventName: "slack_resume_turn_failed",
+            eventName: "slack.resume.turn.failed",
             failureCode: "agent_run_failed",
             turnLifecycle,
             lockKey,
@@ -1570,13 +1543,12 @@ async function resumeSlackTurn(args) {
     } else {
       const finalized = finalizeFailedTurnReplyWithEvent({
         reply: outcome.result,
-        logException,
-        context: getResumeLogContext(runArgs, lockKey)
+        logException
       });
       const reply = finalized.reply;
       const dispatchErrorMessage = replyContext.routing.dispatch && reply.diagnostics.outcome !== "success" ? reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.` : void 0;
       if (reply.diagnostics.outcome !== "success") {
-        await deliverAssistantMessage({ text: reply.text });
+        await deliverAssistantMessage(reply.text);
       }
       runResultHandled = true;
       await status.clear();
@@ -1646,10 +1618,7 @@ async function resumeSlackTurn(args) {
         } catch (scheduleError) {
           logException(
             scheduleError,
-            "plugin_session_completed_task_schedule_failed",
-            getResumeLogContext(runArgs, lockKey),
-            {},
-            "Plugin session.completed task scheduling failed"
+            "plugin.session.completed_task_schedule.failed"
           );
         }
       }
@@ -1663,10 +1632,7 @@ async function resumeSlackTurn(args) {
       } catch (terminalizeError) {
         logException(
           terminalizeError,
-          "slack_resume_post_delivery_terminalize_failed",
-          getResumeLogContext(runArgs, lockKey),
-          {},
-          "Failed to terminalize resumed turn after post-delivery commit failure"
+          "slack.resume.post_delivery_terminalize.failed"
         );
       }
     } else {
@@ -1674,7 +1640,7 @@ async function resumeSlackTurn(args) {
         await handleResumeFailure({
           body: "Failed to resume Slack turn",
           error,
-          eventName: "slack_resume_turn_failed",
+          eventName: "slack.resume.turn.failed",
           failureCode,
           turnLifecycle,
           lockKey,
@@ -1693,10 +1659,7 @@ async function resumeSlackTurn(args) {
   if (postDeliveryCommitError) {
     const eventId = logException(
       postDeliveryCommitError,
-      "slack_resume_success_handler_failed",
-      getResumeLogContext(runArgs, lockKey),
-      {},
-      "Failed to persist resumed turn state after assistant output handling"
+      "slack.resume.success_handler.failed"
     );
     await turnLifecycle.fail({
       conversationId: runArgs.conversationId,
@@ -1727,7 +1690,7 @@ async function resumeSlackTurn(args) {
       await handleResumeFailure({
         body: "Failed to handle resumed turn pause",
         error: pauseError,
-        eventName: "slack_resume_pause_handler_failed",
+        eventName: "slack.resume.pause_handler.failed",
         failureCode: "persistence_failed",
         turnLifecycle,
         lockKey,
@@ -3296,13 +3259,11 @@ async function failSessionRecordBestEffort(args) {
   } catch (error) {
     logException(
       error,
-      "mcp_oauth_callback_session_record_fail_persist_failed",
-      {},
+      "mcp.oauth_callback.session_record.failure_persistence.failed",
       {
         "app.ai.conversation_id": args.conversationId,
         "app.ai.session_id": args.sessionId
-      },
-      "Failed to mark MCP OAuth-resumed turn session record failed"
+      }
     );
   }
 }
@@ -3536,10 +3497,8 @@ async function resumeAuthorizedMcpTurn(args) {
           } catch (persistError) {
             logException(
               persistError,
-              "mcp_oauth_callback_resume_failure_persist_failed",
-              {},
-              { "app.credential.provider": provider },
-              "Failed to persist failed MCP resume state"
+              "mcp.oauth_callback.resume_failure_persist.failed",
+              { "app.credential.provider": provider }
             );
           }
         },
@@ -3548,12 +3507,9 @@ async function resumeAuthorizedMcpTurn(args) {
             sessionId: lockedSessionId,
             threadStateId: threadId
           });
-          logWarn(
-            "mcp_oauth_callback_resume_reparked_for_auth",
-            {},
-            { "app.credential.provider": provider },
-            "Resumed MCP turn requested another authorization flow"
-          );
+          logWarn("mcp.oauth_callback.resume.reparked_for_auth", {
+            "app.credential.provider": provider
+          });
         },
         onSuspend: async (resumeVersion) => {
           await scheduleAgentContinue({
@@ -3652,13 +3608,9 @@ async function GET(request, provider, waitUntil, options) {
     try {
       await deleteMcpAuthSession(authSession.authSessionId);
     } catch (cleanupError) {
-      logException(
-        cleanupError,
-        "mcp_oauth_callback_session_cleanup_failed",
-        {},
-        { "app.credential.provider": provider },
-        "Failed to delete completed MCP auth session"
-      );
+      logException(cleanupError, "mcp.oauth_callback.session_cleanup.failed", {
+        "app.credential.provider": provider
+      });
     }
     if (authSession.destination?.platform !== "local") {
       waitUntil(
@@ -3677,16 +3629,10 @@ async function GET(request, provider, waitUntil, options) {
       await deleteMcpAuthSession(state);
       return htmlResponse("expired");
     }
-    logException(
-      callbackError,
-      "mcp_oauth_callback_failed",
-      {},
-      {
-        "app.credential.provider": provider,
-        ...getMcpProviderErrorAttributes(callbackError)
-      },
-      "Failed to process MCP OAuth callback"
-    );
+    logException(callbackError, "mcp.oauth_callback.failed", {
+      "app.credential.provider": provider,
+      ...getMcpProviderErrorAttributes(callbackError)
+    });
     return htmlResponse("failure");
   }
 }
@@ -3892,13 +3838,11 @@ async function failSessionRecordBestEffort2(args) {
   } catch (error) {
     logException(
       error,
-      "oauth_callback_session_record_fail_persist_failed",
-      {},
+      "oauth.callback.session_record.failure_persistence.failed",
       {
         "app.ai.conversation_id": args.conversationId,
         "app.ai.session_id": args.sessionId
-      },
-      "Failed to mark OAuth-resumed turn session record failed"
+      }
     );
   }
 }
@@ -4137,16 +4081,11 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
           }
         },
         commitResult: async (reply) => {
-          logInfo(
-            "oauth_callback_resume_complete",
-            {},
-            {
-              "app.credential.provider": stored.provider,
-              "app.ai.outcome": reply.diagnostics.outcome,
-              "app.ai.tool_calls": reply.diagnostics.toolCalls.length
-            },
-            "OAuth callback auto-resumed session record finished replying"
-          );
+          logInfo("oauth.callback.resume.completed", {
+            "app.credential.provider": stored.provider,
+            "app.ai.outcome": reply.diagnostics.outcome,
+            "app.ai.tool_calls": reply.diagnostics.toolCalls.length
+          });
           await persistCompletedOAuthReplyState({
             conversationId: stored.resumeConversationId,
             sessionId: lockedSessionId,
@@ -4286,10 +4225,8 @@ async function GET2(request, provider, waitUntil, options) {
     });
   } catch {
     logWarn(
-      "oauth_token_exchange_failed",
-      {},
-      oauthTokenErrorAttributes(provider, providerConfig.tokenEndpoint),
-      "OAuth token exchange request failed"
+      "oauth.token_exchange.failed",
+      oauthTokenErrorAttributes(provider, providerConfig.tokenEndpoint)
     );
     return htmlErrorResponse(
       "Connection failed",
@@ -4299,14 +4236,12 @@ async function GET2(request, provider, waitUntil, options) {
   }
   if (!tokenResponse.ok) {
     logWarn(
-      "oauth_token_exchange_failed",
-      {},
+      "oauth.token_exchange.failed",
       oauthTokenErrorAttributes(
         provider,
         providerConfig.tokenEndpoint,
         tokenResponse.status
-      ),
-      "OAuth token exchange was rejected"
+      )
     );
     return htmlErrorResponse(
       "Connection failed",
@@ -4322,14 +4257,12 @@ async function GET2(request, provider, waitUntil, options) {
     });
   } catch {
     logWarn(
-      "oauth_token_exchange_failed",
-      {},
+      "oauth.token_exchange.failed",
       oauthTokenErrorAttributes(
         provider,
         providerConfig.tokenEndpoint,
         tokenResponse.status
-      ),
-      "OAuth token exchange returned an invalid response"
+      )
     );
     return htmlErrorResponse(
       "Connection failed",
@@ -4378,33 +4311,27 @@ async function GET2(request, provider, waitUntil, options) {
     stored.destination?.platform !== "local" && stored.resumeConversationId && stored.resumeSessionId
   );
   if (resumesAgentTurn) {
-    waitUntil(async () => {
-      try {
-        await resumeOAuthSessionRecordTurn(stored, options);
-      } catch (error) {
-        if (error instanceof ResumeTurnBusyError) {
-          logWarn(
-            "oauth_callback_resume_busy",
-            {
-              ...stored.resumeConversationId && {
-                conversationId: stored.resumeConversationId
-              },
-              ...stored.userId && { actorId: stored.userId },
-              ...stored.channelId && { channelId: stored.channelId }
-            },
-            {
-              "app.credential.provider": stored.provider,
-              ...stored.resumeSessionId && {
-                "app.ai.session_id": stored.resumeSessionId
-              }
-            },
-            "OAuth callback resume was busy; user must send another message to continue"
-          );
-          return;
+    waitUntil(
+      () => withLogContext(
+        { conversationId: stored.resumeConversationId },
+        async () => {
+          try {
+            await resumeOAuthSessionRecordTurn(stored, options);
+          } catch (error) {
+            if (error instanceof ResumeTurnBusyError) {
+              logWarn("oauth.callback.resume.busy", {
+                "app.credential.provider": stored.provider,
+                ...stored.resumeSessionId && {
+                  "app.ai.session_id": stored.resumeSessionId
+                }
+              });
+              return;
+            }
+            throw error;
+          }
         }
-        throw error;
-      }
-    });
+      )
+    );
   } else if (stored.channelId && stored.threadTs) {
     const { channelId, threadTs } = stored;
     waitUntil(