@sentry/junior 0.179.0 → 0.181.0

package/dist/{chunk-GPLAT6H7.js → chunk-LCNPXLE7.js}

@@ -1,12 +1,11 @@
 import {
-  appendAndEnqueueInboundMessage
-} from "./chunk-5IRROPA5.js";
+  ConversationTurnLifecycleService
+} from "./chunk-M3QYTBQ6.js";
 import {
-  ConversationTurnLifecycleService,
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-CJLBLELR.js";
+} from "./chunk-FWILPBVQ.js";
 import {
   AgentInvocationBusyError,
   AgentInvocationLimitError,
@@ -15,27 +14,32 @@ import {
   agentBindingSchema,
   agentInvocationSchema,
   createAgentInvocationSchema
-} from "./chunk-3AFVR5UC.js";
+} from "./chunk-3X55QRAG.js";
+import {
+  appendAndEnqueueInboundMessage
+} from "./chunk-Q2KY27IX.js";
 import {
   TurnInputCommitLostError,
-  failTurnRecord,
   getAssistantReplyText,
   getConversationTurnBoundaryError,
+  isTurnInputCommitLostError
+} from "./chunk-HJ27A6YB.js";
+import {
+  failTurnRecord,
   getTerminalAssistantMessages,
   getTurnRecord,
-  isTurnInputCommitLostError,
   openConversationProjection,
   saveTurnCheckpoint
-} from "./chunk-FIDMHAO6.js";
+} from "./chunk-NQTA72Q3.js";
 import {
   getConversationEventStore,
   getConversationStore,
   getSqlExecutor
-} from "./chunk-VP4OVRDD.js";
+} from "./chunk-RNMASWLP.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations
-} from "./chunk-R6U7N4FS.js";
+} from "./chunk-KKSVCHDO.js";
 
 // src/chat/agent-invocations/work.ts
 import { z } from "zod";
@@ -84,22 +88,22 @@ function bindingFromRow(row) {
 function invocationFromRow(row) {
   return agentInvocationSchema.parse({
     actor: row.actor,
-    ...row.agentName ? { agentName: row.agentName } : {},
+    ...row.agentName ? { agentName: row.agentName } : void 0,
     childConversationId: row.childConversationId,
     createdAtMs: row.createdAt.getTime(),
-    ...row.credentialContext ? { credentialContext: row.credentialContext } : {},
+    ...row.credentialContext ? { credentialContext: row.credentialContext } : void 0,
     destination: row.destination,
-    ...row.destinationVisibility ? { destinationVisibility: row.destinationVisibility } : {},
-    ...row.errorMessage !== null ? { errorMessage: row.errorMessage } : {},
+    ...row.destinationVisibility ? { destinationVisibility: row.destinationVisibility } : void 0,
+    ...row.errorMessage !== null ? { errorMessage: row.errorMessage } : void 0,
     input: row.input,
     invocationId: row.invocationId,
     mailboxStatus: row.mailboxStatus,
     parentConversationId: row.parentConversationId,
-    ...row.reasoningLevel ? { reasoningLevel: row.reasoningLevel } : {},
-    ...row.result !== null ? { result: row.result } : {},
+    ...row.reasoningLevel ? { reasoningLevel: row.reasoningLevel } : void 0,
+    ...row.result !== null ? { result: row.result } : void 0,
     source: row.source,
     status: row.status,
-    ...row.terminalAt ? { terminalAtMs: row.terminalAt.getTime() } : {},
+    ...row.terminalAt ? { terminalAtMs: row.terminalAt.getTime() } : void 0,
     updatedAtMs: row.updatedAt.getTime()
   });
 }
@@ -619,7 +623,7 @@ function createAgentInvocationWorker(options) {
         destinationVisibility: invocation.destinationVisibility,
         ...failed ? {
           errorMessage: result.diagnostics.errorMessage ?? "Agent invocation failed"
-        } : {},
+        } : void 0,
         messages: result.piMessages,
         actor: invocation.actor,
         source: invocation.source,

package/dist/{chunk-2HIPYNQI.js → chunk-LG5MYY6U.js}

@@ -5,28 +5,28 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-3I7XE3PA.js";
+} from "./chunk-D6ZD7VXP.js";
 import {
   parseDestination
-} from "./chunk-VP4OVRDD.js";
+} from "./chunk-RNMASWLP.js";
 import {
   getStateAdapter
-} from "./chunk-3TM3FYLQ.js";
+} from "./chunk-PL57B6NC.js";
 import {
   normalizeSlackEmojiName
-} from "./chunk-GENV6KF2.js";
+} from "./chunk-XYTJUHRZ.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-YFNAMRGE.js";
+} from "./chunk-HEBMSITT.js";
 import {
   parseSlackMessageTs,
   parseSlackUserId
-} from "./chunk-M63DETLL.js";
+} from "./chunk-N7TMSOZH.js";
 import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-HQNE5APD.js";
+} from "./chunk-EBMRB6Z6.js";
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
@@ -101,16 +101,17 @@ async function postSlackMessage(input) {
       unfurl_links: false,
       unfurl_media: false,
       ...input.blocks?.length ? {
+        // @ts-expect-error non-overlapping boundary cast; rule forbids as-unknown-as chains
         blocks: input.blocks
-      } : {},
-      ...threadTs ? { thread_ts: threadTs } : {}
+      } : void 0,
+      ...threadTs ? { thread_ts: threadTs } : void 0
     }),
     3,
     {
       action: "chat.postMessage",
       spanAttributes: {
         "app.slack.channel_id": channelId,
-        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
+        ...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
       }
     }
   );
@@ -125,7 +126,7 @@ async function postSlackMessage(input) {
         channelId,
         messageTs
       })
-    } : {}
+    } : void 0
   };
 }
 async function postSlackEphemeralMessage(input) {
@@ -150,7 +151,7 @@ async function postSlackEphemeralMessage(input) {
       channel: channelId,
       user: userId,
       text,
-      ...threadTs ? { thread_ts: threadTs } : {}
+      ...threadTs ? { thread_ts: threadTs } : void 0
     }),
     3,
     {
@@ -158,7 +159,7 @@ async function postSlackEphemeralMessage(input) {
       spanAttributes: {
         "app.slack.channel_id": channelId,
         "app.slack.user_id": userId,
-        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
+        ...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
       }
     }
   );
@@ -190,7 +191,7 @@ async function uploadFilesToConversation(input) {
   const response = await withSlackRetries(
     () => getSlackClient().filesUploadV2({
       channel_id: channelId,
-      ...threadTs ? { thread_ts: threadTs } : {},
+      ...threadTs ? { thread_ts: threadTs } : void 0,
       file_uploads: fileUploads
     }),
     3,
@@ -198,7 +199,7 @@ async function uploadFilesToConversation(input) {
       action: "filesUploadV2",
       spanAttributes: {
         "app.slack.channel_id": channelId,
-        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
+        ...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
       }
     }
   );
@@ -534,14 +535,14 @@ function parseOAuthStatePayload(value) {
   return {
     userId: value.userId,
     provider: value.provider,
-    ...actor?.success ? { actor: actor.data } : {},
-    ...optionalString(value.channelId) ? { channelId: optionalString(value.channelId) } : {},
-    ...destination ? { destination } : {},
-    ...source?.success ? { source: source.data } : {},
-    ...optionalString(value.threadTs) ? { threadTs: optionalString(value.threadTs) } : {},
-    ...optionalString(value.resumeConversationId) ? { resumeConversationId: optionalString(value.resumeConversationId) } : {},
-    ...optionalString(value.resumeSessionId) ? { resumeSessionId: optionalString(value.resumeSessionId) } : {},
-    ...optionalString(value.scope) ? { scope: optionalString(value.scope) } : {}
+    ...actor?.success ? { actor: actor.data } : void 0,
+    ...optionalString(value.channelId) ? { channelId: optionalString(value.channelId) } : void 0,
+    ...destination ? { destination } : void 0,
+    ...source?.success ? { source: source.data } : void 0,
+    ...optionalString(value.threadTs) ? { threadTs: optionalString(value.threadTs) } : void 0,
+    ...optionalString(value.resumeConversationId) ? { resumeConversationId: optionalString(value.resumeConversationId) } : void 0,
+    ...optionalString(value.resumeSessionId) ? { resumeSessionId: optionalString(value.resumeSessionId) } : void 0,
+    ...optionalString(value.scope) ? { scope: optionalString(value.scope) } : void 0
   };
 }
 function formatProviderLabel(provider) {
@@ -657,14 +658,14 @@ async function startOAuthFlow(provider, input) {
     {
       userId: input.actorId,
       provider,
-      ...input.actor ? { actor: input.actor } : {},
-      ...input.channelId ? { channelId: input.channelId } : {},
-      ...input.destination ? { destination: input.destination } : {},
-      ...input.source ? { source: input.source } : {},
-      ...input.threadTs ? { threadTs: input.threadTs } : {},
-      ...input.resumeConversationId ? { resumeConversationId: input.resumeConversationId } : {},
-      ...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {},
-      ...requestedScope ? { scope: requestedScope } : {}
+      ...input.actor ? { actor: input.actor } : void 0,
+      ...input.channelId ? { channelId: input.channelId } : void 0,
+      ...input.destination ? { destination: input.destination } : void 0,
+      ...input.source ? { source: input.source } : void 0,
+      ...input.threadTs ? { threadTs: input.threadTs } : void 0,
+      ...input.resumeConversationId ? { resumeConversationId: input.resumeConversationId } : void 0,
+      ...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : void 0,
+      ...requestedScope ? { scope: requestedScope } : void 0
     },
     OAUTH_STATE_TTL_MS
   );
@@ -684,7 +685,7 @@ async function startOAuthFlow(provider, input) {
   }
   logInfo("jr_rpc.oauth.started", {
     "app.credential.provider": provider,
-    ...input.activeSkillName ? { "app.skill.name": input.activeSkillName } : {}
+    ...input.activeSkillName ? { "app.skill.name": input.activeSkillName } : void 0
   });
   const authorizationUrl = `${providerConfig.authorizeEndpoint}?${authorizeParams.toString()}`;
   const authorizationRequest = {

package/dist/chunk-LZOQFC5F.js

@@ -0,0 +1,209 @@
+import {
+  coerceThreadConversationState,
+  getPersistedThreadState,
+  persistThreadStateById
+} from "./chunk-FWILPBVQ.js";
+import {
+  buildDeterministicTurnId,
+  clearPendingAuth,
+  markTurnClosed,
+  markTurnCompleted
+} from "./chunk-HJ27A6YB.js";
+import {
+  hydrateConversationMessages,
+  markConversationMessage
+} from "./chunk-NQTA72Q3.js";
+import {
+  ProviderError,
+  findProviderError,
+  getProviderErrorAttributes,
+  getProviderErrorUserMessage
+} from "./chunk-XYTJUHRZ.js";
+import {
+  parseSlackMessageTs
+} from "./chunk-N7TMSOZH.js";
+import {
+  buildTurnFailureResponse
+} from "./chunk-EBMRB6Z6.js";
+
+// src/chat/runtime/delivered-turn-state.ts
+function buildDeliveredTurnStatePatch(args) {
+  const conversation = structuredClone(args.conversation);
+  clearPendingAuth(conversation, args.sessionId);
+  markConversationMessage(conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  markTurnCompleted({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId
+  });
+  return {
+    conversation,
+    sandboxRef: args.reply.sandboxRef
+  };
+}
+
+// src/chat/interruption-marker.ts
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+function getInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+
+// src/chat/services/turn-failure-response.ts
+function requireTurnFailureEventId(eventId, eventName) {
+  if (!eventId) {
+    throw new Error(`Sentry did not return an event ID for ${eventName}`);
+  }
+  return eventId;
+}
+function getExecutionFailureReason(reply) {
+  const errorMessage = reply.diagnostics.errorMessage?.trim();
+  if (errorMessage) {
+    return errorMessage;
+  }
+  if (reply.diagnostics.toolErrorCount > 0) {
+    return `${reply.diagnostics.toolErrorCount} tool result error(s)`;
+  }
+  if (reply.diagnostics.assistantMessageCount > 0) {
+    return "assistant returned no text";
+  }
+  return "empty assistant turn";
+}
+function getFailureCapture(reply) {
+  if (reply.diagnostics.outcome === "provider_error") {
+    const providerError = findProviderError(reply.diagnostics.providerError);
+    return {
+      eventName: "agent.turn.provider_error",
+      error: reply.diagnostics.providerError ?? new Error(
+        reply.diagnostics.errorMessage ?? "Provider error without explicit message"
+      ),
+      attributes: providerError ? getProviderErrorAttributes(providerError) : {},
+      body: "Agent turn failed with provider error"
+    };
+  }
+  const failureReason = getExecutionFailureReason(reply);
+  return {
+    eventName: "agent.turn.execution.failed",
+    error: new Error(`Agent turn execution failure: ${failureReason}`),
+    attributes: {
+      "app.ai.execution_failure_reason": failureReason
+    },
+    body: "Agent turn completed with execution failure"
+  };
+}
+function getAgentTurnDiagnosticsAttributes(reply) {
+  return {
+    "app.ai.outcome": reply.diagnostics.outcome,
+    "app.ai.assistant_messages": reply.diagnostics.assistantMessageCount,
+    "app.ai.tool_results": reply.diagnostics.toolResultCount,
+    "app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
+    "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
+    "app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
+    ...reply.diagnostics.reasoningLevel ? {
+      "gen_ai.request.reasoning.level": reply.diagnostics.reasoningLevel
+    } : void 0,
+    ...reply.diagnostics.stopReason ? {
+      "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason]
+    } : void 0,
+    ...reply.diagnostics.errorMessage && reply.diagnostics.outcome !== "provider_error" ? { "exception.message": reply.diagnostics.errorMessage } : void 0
+  };
+}
+function finalizeFailedTurnReplyWithEvent(args) {
+  if (args.reply.diagnostics.outcome === "success") {
+    return { reply: args.reply };
+  }
+  const capture = getFailureCapture(args.reply);
+  const eventId = requireTurnFailureEventId(
+    args.logException(capture.error, capture.eventName, {
+      ...getAgentTurnDiagnosticsAttributes(args.reply),
+      ...args.attributes,
+      ...capture.attributes
+    }),
+    capture.eventName
+  );
+  const providerPartialText = args.reply.diagnostics.outcome === "provider_error" && args.reply.diagnostics.assistantMessageCount > 0 ? args.reply.text.trim() : "";
+  const providerUserMessage = args.reply.diagnostics.providerError instanceof ProviderError ? getProviderErrorUserMessage(args.reply.diagnostics.providerError) : "";
+  const failureText = providerUserMessage ? `${providerUserMessage} Reference: \`event_id=${eventId}\`.` : buildTurnFailureResponse(eventId);
+  return {
+    eventId,
+    reply: {
+      ...args.reply,
+      text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : failureText
+    }
+  };
+}
+
+// src/chat/runtime/turn-user-message.ts
+function getTurnUserMessage(conversation, sessionId) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    if (buildDeterministicTurnId(message.id) === sessionId) {
+      return message;
+    }
+  }
+  return void 0;
+}
+function getTurnUserMessageId(conversation, sessionId) {
+  return getTurnUserMessage(conversation, sessionId)?.id;
+}
+function getTurnUserSlackMessageTs(message) {
+  return parseSlackMessageTs(message?.meta?.slackTs);
+}
+function getTurnUserReplyAttachmentContext(message) {
+  const inboundAttachmentCount = message?.meta?.attachmentCount ?? 0;
+  const imageAttachmentCount = message?.meta?.imageAttachmentCount ?? 0;
+  const imagesHydrated = message?.meta?.imagesHydrated === true;
+  return {
+    ...inboundAttachmentCount > 0 ? { inboundAttachmentCount } : void 0,
+    ...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : void 0
+  };
+}
+
+// src/chat/runtime/auth-pause-state.ts
+function completeAuthPauseTurn(args) {
+  markConversationMessage(
+    args.conversation,
+    getTurnUserMessageId(args.conversation, args.sessionId),
+    {
+      replied: true,
+      skippedReason: void 0
+    }
+  );
+  markTurnClosed({
+    conversation: args.conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId
+  });
+}
+async function persistAuthPauseTurnState(args) {
+  const currentState = await getPersistedThreadState(args.threadStateId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.threadStateId
+  });
+  completeAuthPauseTurn({
+    conversation,
+    sessionId: args.sessionId
+  });
+  await persistThreadStateById(args.threadStateId, { conversation });
+}
+
+export {
+  buildDeliveredTurnStatePatch,
+  getTurnUserMessage,
+  getTurnUserMessageId,
+  getTurnUserSlackMessageTs,
+  getTurnUserReplyAttachmentContext,
+  getInterruptionMarker,
+  requireTurnFailureEventId,
+  getAgentTurnDiagnosticsAttributes,
+  finalizeFailedTurnReplyWithEvent,
+  completeAuthPauseTurn,
+  persistAuthPauseTurnState
+};

package/dist/chunk-M3QYTBQ6.js

@@ -0,0 +1,55 @@
+// src/chat/conversations/turn-lifecycle.ts
+var ConversationTurnLifecycleService = class {
+  constructor(events) {
+    this.events = events;
+  }
+  events;
+  /** Record the turn start once after every input message is durable. */
+  async start(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:started`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_started",
+          turnId: input.turnId,
+          inputMessageIds: input.inputMessageIds,
+          surface: input.surface
+        }
+      }
+    ]);
+  }
+  /** Record successful or intentional-silence completion once. */
+  async complete(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_completed",
+          turnId: input.turnId,
+          outcome: input.outcome
+        }
+      }
+    ]);
+  }
+  /** Record a classified failure once without accepting raw error details. */
+  async fail(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_failed",
+          turnId: input.turnId,
+          failureCode: input.failureCode,
+          ...input.eventId ? { eventId: input.eventId } : void 0
+        }
+      }
+    ]);
+  }
+};
+
+export {
+  ConversationTurnLifecycleService
+};

package/dist/{chunk-M63DETLL.js → chunk-N7TMSOZH.js}

@@ -138,15 +138,15 @@ function createActor(input, context) {
   }
   const canUseInputProfile = (!contextUserId || !inputUserId || contextUserId === inputUserId) && (platform !== "slack" || !contextTeamId || !inputTeamId || contextTeamId === inputTeamId);
   const actor = {
-    ...canUseInputProfile && cleanActorEmail(input?.email) ? { email: cleanActorEmail(input?.email) } : {},
+    ...canUseInputProfile && cleanActorEmail(input?.email) ? { email: cleanActorEmail(input?.email) } : void 0,
     ...canUseInputProfile && cleanActorDisplayName(input?.fullName, actorUserId) ? {
       fullName: cleanActorDisplayName(input?.fullName, actorUserId)
-    } : {},
+    } : void 0,
     platform,
     userId: actorUserId,
     ...canUseInputProfile && cleanActorDisplayName(input?.userName, actorUserId) ? {
       userName: cleanActorDisplayName(input?.userName, actorUserId)
-    } : {}
+    } : void 0
   };
   if (platform === "slack") {
     return { ...actor, platform, teamId: actorTeamId };
@@ -193,11 +193,11 @@ function parseStoredSlackActor(value) {
 }
 function toStoredSlackActor(actor) {
   return {
-    ...actor.email ? { email: actor.email } : {},
-    ...actor.fullName ? { fullName: actor.fullName } : {},
+    ...actor.email ? { email: actor.email } : void 0,
+    ...actor.fullName ? { fullName: actor.fullName } : void 0,
     platform: actor.platform,
     slackUserId: actor.userId,
-    ...actor.userName ? { slackUserName: actor.userName } : {},
+    ...actor.userName ? { slackUserName: actor.userName } : void 0,
     teamId: actor.teamId
   };
 }