@sentry/junior 0.114.0 → 0.116.0

package/dist/{chunk-ABPSDO6M.js → chunk-UEVLIYK5.js}

@@ -2,8 +2,9 @@ import {
   pluginTaskId,
   pluginTaskParamsSchema,
   sendVercelPluginTask
-} from "./chunk-KNFROR7R.js";
+} from "./chunk-5I6ORJUY.js";
 import {
+  buildDeterministicTurnId,
   clearPendingAuth,
   coerceThreadConversationState,
   getAgentTurnSessionRecord,
@@ -15,178 +16,65 @@ import {
   isToolResultError,
   isToolResultMessage,
   markConversationMessage,
+  markTurnClosed,
   markTurnCompleted,
   mergeArtifactsState,
   normalizeToolNameFromResult,
+  persistThreadStateById,
   stripRuntimeTurnContext,
   updateConversationStats
-} from "./chunk-6QWPVTMO.js";
+} from "./chunk-OF5FODBL.js";
 import {
   createPluginEmbedder,
   createPluginLogger,
   createPluginModel,
   createPluginState,
   getPlugins
-} from "./chunk-VNNBSKCO.js";
+} from "./chunk-VZCSLYCE.js";
 import {
   getStateAdapter
-} from "./chunk-YU6PO42Q.js";
+} from "./chunk-53ZKTQO6.js";
 import {
   getDb
-} from "./chunk-FIGAF6KL.js";
+} from "./chunk-KBNDFU6J.js";
 import {
   ProviderError,
   getProviderErrorAttributes,
   getProviderErrorUserMessage
-} from "./chunk-ZGXH3REA.js";
+} from "./chunk-PZGPCOSD.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-4FUEG3QY.js";
+} from "./chunk-3JOGUT46.js";
 import {
   parseSlackMessageTs
-} from "./chunk-42WRQLJ6.js";
+} from "./chunk-F3B2YJ76.js";
 
-// 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") {
-    return {
-      eventName: "agent_turn_provider_error",
-      error: reply.diagnostics.providerError ?? new Error(
-        reply.diagnostics.errorMessage ?? "Provider error without explicit message"
-      ),
-      attributes: reply.diagnostics.providerError instanceof ProviderError ? getProviderErrorAttributes(reply.diagnostics.providerError) : {},
-      body: "Agent turn failed with provider error"
-    };
-  }
-  const failureReason = getExecutionFailureReason(reply);
-  return {
-    eventName: "agent_turn_execution_failure",
-    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
-    } : {},
-    ...reply.diagnostics.stopReason ? {
-      "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason]
-    } : {},
-    ...reply.diagnostics.errorMessage && reply.diagnostics.outcome !== "provider_error" ? { "exception.message": reply.diagnostics.errorMessage } : {}
+// src/chat/runtime/delivered-turn-state.ts
+function buildDeliveredTurnStatePatch(args) {
+  const conversation = structuredClone(args.conversation);
+  const artifactStatePatch = {
+    ...args.reply.artifactStatePatch ?? {},
+    ...args.artifactStatePatch ?? {}
   };
-}
-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,
-      args.context,
-      {
-        ...getAgentTurnDiagnosticsAttributes(args.reply),
-        ...args.attributes,
-        ...capture.attributes
-      },
-      capture.body
-    ),
-    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);
+  const artifacts = Object.keys(artifactStatePatch).length > 0 ? mergeArtifactsState(args.artifacts, artifactStatePatch) : void 0;
+  clearPendingAuth(conversation, args.sessionId);
+  markConversationMessage(conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  markTurnCompleted({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId,
+    updateConversationStats
+  });
   return {
-    eventId,
-    reply: {
-      ...args.reply,
-      text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : failureText
-    }
+    artifacts,
+    conversation,
+    sandboxRef: args.reply.sandboxRef
   };
 }
 
-// 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 } : {}
-        }
-      }
-    ]);
-  }
-};
-
 // src/chat/plugins/task-runner.ts
 import {
   isPrivateSource,
@@ -497,38 +385,219 @@ async function processPluginTask(message, options = {}) {
   });
 }
 
-// src/chat/runtime/delivered-turn-state.ts
-function buildDeliveredTurnStatePatch(args) {
-  const conversation = structuredClone(args.conversation);
-  const artifactStatePatch = {
-    ...args.reply.artifactStatePatch ?? {},
-    ...args.artifactStatePatch ?? {}
+// 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") {
+    return {
+      eventName: "agent_turn_provider_error",
+      error: reply.diagnostics.providerError ?? new Error(
+        reply.diagnostics.errorMessage ?? "Provider error without explicit message"
+      ),
+      attributes: reply.diagnostics.providerError instanceof ProviderError ? getProviderErrorAttributes(reply.diagnostics.providerError) : {},
+      body: "Agent turn failed with provider error"
+    };
+  }
+  const failureReason = getExecutionFailureReason(reply);
+  return {
+    eventName: "agent_turn_execution_failure",
+    error: new Error(`Agent turn execution failure: ${failureReason}`),
+    attributes: {
+      "app.ai.execution_failure_reason": failureReason
+    },
+    body: "Agent turn completed with execution failure"
   };
-  const artifacts = Object.keys(artifactStatePatch).length > 0 ? mergeArtifactsState(args.artifacts, artifactStatePatch) : void 0;
-  clearPendingAuth(conversation, args.sessionId);
-  markConversationMessage(conversation, args.userMessageId, {
-    replied: true,
-    skippedReason: void 0
-  });
-  markTurnCompleted({
-    conversation,
+}
+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
+    } : {},
+    ...reply.diagnostics.stopReason ? {
+      "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason]
+    } : {},
+    ...reply.diagnostics.errorMessage && reply.diagnostics.outcome !== "provider_error" ? { "exception.message": reply.diagnostics.errorMessage } : {}
+  };
+}
+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,
+      args.context,
+      {
+        ...getAgentTurnDiagnosticsAttributes(args.reply),
+        ...args.attributes,
+        ...capture.attributes
+      },
+      capture.body
+    ),
+    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/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 } : {}
+        }
+      }
+    ]);
+  }
+};
+
+// 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 } : {},
+    ...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : {}
+  };
+}
+
+// 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,
     updateConversationStats
   });
-  return {
-    artifacts,
+}
+async function persistAuthPauseTurnState(args) {
+  const currentState = await getPersistedThreadState(args.threadStateId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
     conversation,
-    sandboxRef: args.reply.sandboxRef
-  };
+    conversationId: args.threadStateId
+  });
+  completeAuthPauseTurn({
+    conversation,
+    sessionId: args.sessionId
+  });
+  await persistThreadStateById(args.threadStateId, { conversation });
 }
 
 export {
+  buildDeliveredTurnStatePatch,
+  getTurnUserMessage,
+  getTurnUserMessageId,
+  getTurnUserSlackMessageTs,
+  getTurnUserReplyAttachmentContext,
+  scheduleSessionCompletedPluginTasks,
+  processPluginTask,
   requireTurnFailureEventId,
   getAgentTurnDiagnosticsAttributes,
   finalizeFailedTurnReplyWithEvent,
   ConversationTurnLifecycleService,
-  scheduleSessionCompletedPluginTasks,
-  processPluginTask,
-  buildDeliveredTurnStatePatch
+  completeAuthPauseTurn,
+  persistAuthPauseTurnState
 };