@sentry/junior 0.184.0 → 0.185.0

package/dist/{chunk-M3QYTBQ6.js → chunk-6Q7YZLCL.js}

@@ -33,7 +33,7 @@ var ConversationTurnLifecycleService = class {
       }
     ]);
   }
-  /** Record a classified failure once without accepting raw error details. */
+  /** Record a classified failure once. Do not store raw error text. */
   async fail(input) {
     await this.events.append(input.conversationId, [
       {
@@ -43,6 +43,7 @@ var ConversationTurnLifecycleService = class {
           type: "turn_failed",
           turnId: input.turnId,
           failureCode: input.failureCode,
+          ...input.failureReason ? { failureReason: input.failureReason } : void 0,
           ...input.eventId ? { eventId: input.eventId } : void 0
         }
       }

package/dist/{chunk-6VOYP4M6.js → chunk-7GAP2XG4.js}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@sentry/junior",
-  version: "0.184.0",
+  version: "0.185.0",
   private: false,
   publishConfig: {
     access: "public"

package/dist/{chunk-LHXIZLFF.js → chunk-7MHNIGHP.js}

@@ -12,7 +12,7 @@ import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/plugins/manifest.ts
 import { z } from "zod";

package/dist/{chunk-IZDYYYGP.js → chunk-ABAX75GG.js}

@@ -8,15 +8,19 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-BCHYQS4B.js";
+} from "./chunk-LVK4WJKM.js";
+import {
+  conversationEventDataSchema,
+  decodeStoredConversationEvent,
+  historyReplacementSchema,
+  newConversationEventSchema
+} from "./chunk-GFBR4S3Q.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
-  TURN_REASONING_LEVELS,
-  getChatConfig,
-  modelProfileSchema
-} from "./chunk-6UDPINOX.js";
+  getChatConfig
+} from "./chunk-LRI5IRGY.js";
 import {
   parseActorUserId,
   parseSlackChannelReferenceId,
@@ -24,7 +28,7 @@ import {
 } from "./chunk-N7TMSOZH.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -1059,377 +1063,6 @@ import {
   sql as sql6
 } from "drizzle-orm";
 
-// src/chat/conversations/history.ts
-import { z as z3 } from "zod";
-
-// src/chat/conversations/provenance.ts
-import { actorSchema } from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-var conversationMessageAuthoritySchema = z2.union([
-  z2.literal("instruction"),
-  z2.literal("context")
-]);
-var conversationMessageProvenanceSchema = z2.object({
-  authority: conversationMessageAuthoritySchema,
-  actor: actorSchema.optional()
-}).strict();
-function instructionProvenanceFor(actor) {
-  return actor ? { authority: "instruction", actor } : { authority: "instruction" };
-}
-var contextProvenance = {
-  authority: "context"
-};
-function actorIdentityKey(actor) {
-  if (actor.platform === "system") {
-    return `system ${actor.name}`;
-  }
-  return actor.platform === "slack" ? `slack\0${actor.teamId}\0${actor.userId}` : `${actor.platform}\0${actor.userId}`;
-}
-function sameActorIdentity(left, right) {
-  return Boolean(
-    left && right && actorIdentityKey(left) === actorIdentityKey(right)
-  );
-}
-function instructionActors(provenance) {
-  const seen = /* @__PURE__ */ new Set();
-  const actors = [];
-  for (const entry of provenance) {
-    if (entry.authority !== "instruction" || !entry.actor) {
-      continue;
-    }
-    const identity = actorIdentityKey(entry.actor);
-    if (seen.has(identity)) {
-      continue;
-    }
-    seen.add(identity);
-    actors.push(entry.actor);
-  }
-  return actors;
-}
-
-// src/chat/conversations/history.ts
-var userMessageEventDataSchema = z3.object({
-  type: z3.literal("user_message"),
-  role: z3.never().optional(),
-  provenance: conversationMessageProvenanceSchema
-}).passthrough();
-var assistantMessageEventDataSchema = z3.object({
-  type: z3.literal("assistant_message"),
-  role: z3.never().optional()
-}).passthrough();
-var toolResultEventDataSchema = z3.object({
-  type: z3.literal("tool_result"),
-  role: z3.never().optional()
-}).passthrough();
-var agentHistoryItemSchema = z3.discriminatedUnion("type", [
-  userMessageEventDataSchema,
-  assistantMessageEventDataSchema,
-  toolResultEventDataSchema
-]);
-var nativeReplacementHistoryItemSchema = z3.object({
-  item: agentHistoryItemSchema,
-  // Preserve the copied item's position when a turn resumes. Synthetic
-  // summary and handoff items have no source event.
-  sourceEventSeq: z3.number().int().nonnegative().optional()
-}).strict();
-var replacementHistorySchema = z3.array(nativeReplacementHistoryItemSchema);
-var compactionDetailsSchema = z3.object({
-  reason: z3.literal("capacity"),
-  estimatedInputTokens: z3.number().int().nonnegative(),
-  replacementInputTokens: z3.number().int().nonnegative().optional(),
-  triggerTokens: z3.number().int().nonnegative(),
-  inputLimitTokens: z3.number().int().positive(),
-  inputMessageCount: z3.number().int().nonnegative(),
-  retainedMessageCount: z3.number().int().nonnegative(),
-  summaryChars: z3.number().int().nonnegative()
-}).strict();
-var historyReplacementEventDataSchema = z3.discriminatedUnion("type", [
-  z3.object({
-    type: z3.literal("handoff"),
-    modelProfile: modelProfileSchema,
-    modelId: z3.string().min(1),
-    reasoningLevel: z3.string().min(1).optional(),
-    triggeringToolCallId: z3.string().min(1).optional(),
-    summary: z3.string().min(1).optional(),
-    replacementHistory: replacementHistorySchema
-  }).strict(),
-  z3.object({
-    type: z3.literal("compaction"),
-    modelProfile: modelProfileSchema,
-    modelId: z3.string().min(1),
-    details: compactionDetailsSchema.optional(),
-    summary: z3.string().min(1).optional(),
-    replacementHistory: replacementHistorySchema
-  }).strict()
-]);
-var historyReplacementSchema = z3.object({
-  data: historyReplacementEventDataSchema,
-  createdAtMs: z3.number().finite()
-}).strict();
-var mcpProviderConnectedEventDataSchema = z3.object({
-  type: z3.literal("mcp_provider_connected"),
-  provider: z3.string().min(1),
-  credentialSubjectId: z3.string().min(1)
-}).strict();
-var unownedMcpProviderConnectedEventDataSchema = z3.object({
-  type: z3.literal("mcp_provider_connected_unowned"),
-  provider: z3.string().min(1)
-}).strict();
-var authorizationKindSchema = z3.union([
-  z3.literal("plugin"),
-  z3.literal("mcp")
-]);
-var authorizationRequestedEventDataSchema = z3.object({
-  type: z3.literal("authorization_requested"),
-  kind: authorizationKindSchema,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1),
-  delivery: z3.union([
-    z3.literal("private_link_sent"),
-    z3.literal("private_link_reused")
-  ])
-}).strict();
-var authorizationCompletedEventDataSchema = z3.object({
-  type: z3.literal("authorization_completed"),
-  kind: authorizationKindSchema,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1)
-}).strict();
-var toolExecutionStartedEventDataSchema = z3.object({
-  type: z3.literal("tool_execution_started"),
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1)
-}).strict();
-var guardianActionReviewedEventDataSchema = z3.object({
-  type: z3.literal("guardian_action_reviewed"),
-  turnId: z3.string().min(1),
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1),
-  costUsd: z3.number().finite().nonnegative().optional(),
-  decision: z3.enum(["allow", "ask", "deny"]),
-  riskLevel: z3.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z3.enum(["high", "medium", "low", "unknown"])
-}).strict();
-var conversationMessageRoleSchema = z3.union([
-  z3.literal("user"),
-  z3.literal("assistant"),
-  z3.literal("system")
-]);
-var messageEventDataSchema = z3.object({
-  type: z3.literal("message"),
-  messageId: z3.string().min(1),
-  role: conversationMessageRoleSchema,
-  text: z3.string(),
-  authorIdentityId: z3.string().min(1).optional(),
-  meta: z3.record(z3.string(), z3.unknown()).optional()
-}).strict();
-var messageUpdatedEventDataSchema = messageEventDataSchema.extend({
-  type: z3.literal("message_updated")
-});
-var messageHandledEventDataSchema = z3.object({
-  type: z3.literal("message_handled"),
-  messageId: z3.string().min(1)
-}).strict();
-var messagesSummarizedEventDataSchema = z3.object({
-  type: z3.literal("messages_summarized"),
-  historyFromSeq: z3.number().int().nonnegative(),
-  compactions: z3.array(
-    z3.object({
-      coveredMessageCount: z3.number().int().nonnegative(),
-      createdAtMs: z3.number(),
-      id: z3.string().min(1),
-      summary: z3.string()
-    }).strict()
-  )
-}).strict();
-var conversationTurnSurfaceSchema = z3.enum([
-  "slack",
-  "api",
-  "scheduler",
-  "internal"
-]);
-var conversationTurnFailureCodeSchema = z3.enum([
-  "agent_run_failed",
-  "delivery_failed",
-  "model_execution_failed",
-  "persistence_failed"
-]);
-var turnStartedEventDataSchema = z3.object({
-  type: z3.literal("turn_started"),
-  turnId: z3.string().min(1),
-  inputMessageIds: z3.array(z3.string().min(1)).min(1),
-  surface: conversationTurnSurfaceSchema
-}).strict().refine(
-  (data) => new Set(data.inputMessageIds).size === data.inputMessageIds.length,
-  "turn input message ids must be unique"
-);
-var turnRoutedEventDataSchema = z3.object({
-  type: z3.literal("turn_routed"),
-  turnId: z3.string().min(1),
-  modelProfile: modelProfileSchema,
-  modelId: z3.string().min(1),
-  costUsd: z3.number().finite().nonnegative().optional(),
-  reasoningLevel: z3.enum(TURN_REASONING_LEVELS),
-  confidence: z3.number().min(0).max(1).optional(),
-  source: z3.enum(["configured", "inherited", "router"])
-}).strict();
-var turnContextEventDataSchema = z3.object({
-  type: z3.literal("turn_context"),
-  turnId: z3.string().min(1),
-  pluginName: z3.string().min(1),
-  kind: z3.string().min(1).max(64),
-  version: z3.number().int().positive(),
-  content: z3.record(z3.string(), z3.unknown())
-}).strict();
-var structuredConversationEventDataSchema = z3.object({
-  type: z3.literal("structured_event"),
-  namespace: z3.string().regex(/^[a-z][a-z0-9-]*$/),
-  name: z3.string().regex(/^[a-z][a-z0-9_]*$/),
-  version: z3.number().int().positive(),
-  turnId: z3.string().min(1).optional(),
-  content: z3.record(z3.string(), z3.unknown())
-}).strict();
-var deliveredAttachmentSchema = z3.object({
-  id: z3.string().min(1),
-  filename: z3.string().min(1),
-  contentType: z3.string().min(1),
-  bytes: z3.number().int().nonnegative()
-}).strict();
-var attachmentsDeliveredEventDataSchema = z3.object({
-  type: z3.literal("attachments_delivered"),
-  attachments: z3.array(deliveredAttachmentSchema).min(1),
-  toolCallId: z3.string().min(1).optional(),
-  turnId: z3.string().min(1).optional()
-}).strict();
-var turnCompletedEventDataSchema = z3.object({
-  type: z3.literal("turn_completed"),
-  turnId: z3.string().min(1),
-  outcome: z3.enum(["success", "no_reply", "cancelled"])
-}).strict();
-var turnFailedEventDataSchema = z3.object({
-  type: z3.literal("turn_failed"),
-  turnId: z3.string().min(1),
-  failureCode: conversationTurnFailureCodeSchema,
-  eventId: z3.string().regex(/^[a-f0-9]{32}$/i).optional()
-}).strict();
-var subagentStartedEventDataSchema = z3.object({
-  type: z3.literal("subagent_started"),
-  subagentInvocationId: z3.string().min(1),
-  subagentKind: z3.string().min(1),
-  modelId: z3.string().min(1).optional(),
-  parentToolCallId: z3.string().min(1).optional(),
-  reasoningLevel: z3.string().min(1).optional(),
-  childConversationId: z3.string().min(1)
-}).strict();
-var subagentEndedEventDataSchema = z3.object({
-  type: z3.literal("subagent_ended"),
-  subagentInvocationId: z3.string().min(1),
-  outcome: z3.union([
-    z3.literal("success"),
-    z3.literal("error"),
-    z3.literal("aborted")
-  ]),
-  errorCode: z3.string().min(1).optional()
-}).strict();
-var appendableConversationEventDataSchema = z3.union([
-  messageEventDataSchema,
-  messageUpdatedEventDataSchema,
-  agentHistoryItemSchema,
-  mcpProviderConnectedEventDataSchema,
-  authorizationRequestedEventDataSchema,
-  authorizationCompletedEventDataSchema,
-  toolExecutionStartedEventDataSchema,
-  guardianActionReviewedEventDataSchema,
-  messageHandledEventDataSchema,
-  messagesSummarizedEventDataSchema,
-  turnStartedEventDataSchema,
-  turnContextEventDataSchema,
-  structuredConversationEventDataSchema,
-  attachmentsDeliveredEventDataSchema,
-  turnRoutedEventDataSchema,
-  turnCompletedEventDataSchema,
-  turnFailedEventDataSchema,
-  subagentStartedEventDataSchema,
-  subagentEndedEventDataSchema
-]);
-var conversationEventDataSchema = z3.union([
-  appendableConversationEventDataSchema,
-  historyReplacementEventDataSchema,
-  unownedMcpProviderConnectedEventDataSchema
-]);
-var KNOWN_CONVERSATION_EVENT_TYPES = [
-  "message",
-  "message_updated",
-  "user_message",
-  "assistant_message",
-  "tool_result",
-  "mcp_provider_connected",
-  "mcp_provider_connected_unowned",
-  "authorization_requested",
-  "authorization_completed",
-  "tool_execution_started",
-  "guardian_action_reviewed",
-  "message_handled",
-  "messages_summarized",
-  "turn_started",
-  "turn_context",
-  "structured_event",
-  "attachments_delivered",
-  "turn_routed",
-  "turn_completed",
-  "turn_failed",
-  "subagent_started",
-  "subagent_ended",
-  "handoff",
-  "compaction"
-];
-var knownConversationEventTypeSchema = z3.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var unknownConversationEventDataSchema = z3.object({
-  type: z3.literal("unknown"),
-  originalType: z3.string().min(1),
-  payload: z3.unknown()
-}).strict();
-var conversationEventEnvelopeSchema = z3.object({
-  schemaVersion: z3.number().int().nonnegative(),
-  seq: z3.number().int().nonnegative(),
-  historyVersion: z3.number().int().nonnegative(),
-  idempotencyKey: z3.string().min(1).optional(),
-  createdAtMs: z3.number().finite()
-}).strict();
-var conversationEventSchema = z3.union([
-  conversationEventEnvelopeSchema.extend({
-    schemaVersion: z3.literal(1),
-    data: conversationEventDataSchema
-  }),
-  conversationEventEnvelopeSchema.extend({
-    data: unknownConversationEventDataSchema
-  })
-]);
-var storedConversationEventSchema = conversationEventEnvelopeSchema.extend({
-  type: z3.string().min(1),
-  payload: z3.unknown()
-});
-function decodeStoredConversationEvent(value) {
-  const stored = storedConversationEventSchema.parse(value);
-  const { type, payload, ...envelope } = stored;
-  const knownType = knownConversationEventTypeSchema.safeParse(type).success;
-  if (stored.schemaVersion === 1 && knownType) {
-    const data = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? { ...payload, type } : { type };
-    return conversationEventSchema.parse({ ...envelope, data });
-  }
-  return conversationEventSchema.parse({
-    ...envelope,
-    data: { type: "unknown", originalType: type, payload }
-  });
-}
-var newConversationEventSchema = z3.object({
-  data: appendableConversationEventDataSchema,
-  idempotencyKey: z3.string().min(1).optional(),
-  createdAtMs: z3.number().finite()
-}).strict();
-
 // src/chat/conversations/sql/conversation-row.ts
 import { sql as sql4 } from "drizzle-orm";
 async function ensureConversationRow(executor, conversationId, atMs, options = {}) {
@@ -2150,13 +1783,6 @@ export {
   bindProviderConversation,
   locationFromRow,
   withConversationMutationLock,
-  instructionProvenanceFor,
-  contextProvenance,
-  sameActorIdentity,
-  instructionActors,
-  agentHistoryItemSchema,
-  KNOWN_CONVERSATION_EVENT_TYPES,
-  decodeStoredConversationEvent,
   sanitizePostgresJson,
   withConversationEventLock,
   createSqlConversationEventStore,

package/dist/{chunk-WQFEWULF.js → chunk-ATUWN6Z3.js}

@@ -1,12 +1,12 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
+} from "./chunk-GJTIZQGJ.js";
 import {
   skillRoots
 } from "./chunk-TXKUKMVO.js";
 import {
   logWarn
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";

package/dist/{chunk-4RONS3WR.js → chunk-C6TS47CQ.js}

@@ -19,23 +19,23 @@ import {
   releaseConversationWork,
   requestAnotherSlice,
   startConversationWork
-} from "./chunk-Z3QAXJR7.js";
+} from "./chunk-D63IUQQE.js";
 import {
   ConversationQueueMessageRejectedError
 } from "./chunk-JAL3CH4G.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-MLSQX2EX.js";
+} from "./chunk-FTVMXDNN.js";
 import {
   getChatConfig,
   isProviderRetryError
-} from "./chunk-6UDPINOX.js";
+} from "./chunk-LRI5IRGY.js";
 import {
   logException,
   logInfo,
   logWarn,
   withLogContext
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;

package/dist/chunk-D4YV5TDV.js

@@ -0,0 +1,45 @@
+// src/chat/reasoning-level.ts
+import { z } from "zod";
+var TURN_REASONING_LEVELS = [
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+function parseTurnReasoningLevel(value) {
+  return z.enum(TURN_REASONING_LEVELS).parse(value);
+}
+
+// src/chat/model-profile.ts
+import { z as z2 } from "zod";
+var modelProfileSchema = z2.string().regex(/^[a-z][a-z0-9_-]*$/);
+var ModelProfileNotConfiguredError = class extends Error {
+  constructor(profile) {
+    super(`Model profile "${profile}" is not configured`);
+    this.name = "ModelProfileNotConfiguredError";
+  }
+};
+function modelIdForProfile(config, profile) {
+  return profileConfig(config, profile).modelId;
+}
+function defaultModelId(config) {
+  return modelIdForProfile(config, config.defaultProfile);
+}
+function profileConfig(config, profile) {
+  const profileConfig2 = Object.hasOwn(config.profiles, profile) ? config.profiles[profile] : void 0;
+  if (!profileConfig2) {
+    throw new ModelProfileNotConfiguredError(profile);
+  }
+  return profileConfig2;
+}
+
+export {
+  TURN_REASONING_LEVELS,
+  parseTurnReasoningLevel,
+  modelProfileSchema,
+  ModelProfileNotConfiguredError,
+  modelIdForProfile,
+  defaultModelId,
+  profileConfig
+};

package/dist/{chunk-Z3QAXJR7.js → chunk-D63IUQQE.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-IZDYYYGP.js";
+} from "./chunk-ABAX75GG.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-DUKIDPF6.js";
+} from "./chunk-PNYJOEVV.js";
 import {
   getChatConfig
-} from "./chunk-6UDPINOX.js";
+} from "./chunk-LRI5IRGY.js";
 import {
   parseStoredSlackActor
 } from "./chunk-N7TMSOZH.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-M5YWNMTE.js → chunk-DAPC2HTM.js}

@@ -2,29 +2,29 @@ import {
   coerceThreadConversationState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-E57WPXWY.js";
+} from "./chunk-Y5G23T2D.js";
 import {
   buildDeterministicTurnId,
   clearPendingAuth,
   markTurnClosed,
   markTurnCompleted
-} from "./chunk-JA43DV4Y.js";
+} from "./chunk-U4CTAVWN.js";
 import {
   hydrateConversationMessages,
   markConversationMessage
-} from "./chunk-2ZQPVX7C.js";
+} from "./chunk-WLKWN4CD.js";
 import {
   ProviderError,
   findProviderError,
   getProviderErrorAttributes,
   getProviderErrorUserMessage
-} from "./chunk-6UDPINOX.js";
+} from "./chunk-LRI5IRGY.js";
 import {
   parseSlackMessageTs
 } from "./chunk-N7TMSOZH.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/runtime/delivered-turn-state.ts
 function buildDeliveredTurnStatePatch(args) {
@@ -71,6 +71,21 @@ function getExecutionFailureReason(reply) {
   }
   return "empty assistant turn";
 }
+function getTurnFailureReason(reply) {
+  if (reply.diagnostics.outcome === "success") {
+    return void 0;
+  }
+  if (reply.diagnostics.outcome === "provider_error") {
+    return findProviderError(reply.diagnostics.providerError)?.kind ?? "unknown";
+  }
+  if (reply.diagnostics.toolErrorCount > 0) {
+    return "tool_errors";
+  }
+  if (reply.diagnostics.usedPrimaryText && reply.diagnostics.assistantMessageCount > 0) {
+    return "suppressed_output";
+  }
+  return "empty_output";
+}
 function getFailureCapture(reply) {
   if (reply.diagnostics.outcome === "provider_error") {
     const providerError = findProviderError(reply.diagnostics.providerError);
@@ -114,12 +129,14 @@ function finalizeFailedTurnReplyWithEvent(args) {
   if (args.reply.diagnostics.outcome === "success") {
     return { reply: args.reply };
   }
+  const failureReason = getTurnFailureReason(args.reply);
   const capture = getFailureCapture(args.reply);
   const eventId = requireTurnFailureEventId(
     args.logException(capture.error, capture.eventName, {
       ...getAgentTurnDiagnosticsAttributes(args.reply),
       ...args.attributes,
-      ...capture.attributes
+      ...capture.attributes,
+      ...failureReason ? { "app.ai.failure_reason": failureReason } : void 0
     }),
     capture.eventName
   );
@@ -128,6 +145,7 @@ function finalizeFailedTurnReplyWithEvent(args) {
   const failureText = providerUserMessage ? `${providerUserMessage} Reference: \`event_id=${eventId}\`.` : buildTurnFailureResponse(eventId);
   return {
     eventId,
+    ...failureReason ? { failureReason } : void 0,
     reply: {
       ...args.reply,
       text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : failureText

package/dist/{chunk-BHYRYYLY.js → chunk-EIJCPJOY.js}

@@ -1,6 +1,6 @@
 import {
   logWarn
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/conversation-privacy.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-SHJK75Z2.js → chunk-EJYP3NQ4.js}

@@ -1,13 +1,13 @@
 import {
   toOptionalTrimmed
-} from "./chunk-6UDPINOX.js";
+} from "./chunk-LRI5IRGY.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
+} from "./chunk-GJTIZQGJ.js";
 import {
   setSpanAttributes,
   setSpanStatus
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {
@@ -591,7 +591,7 @@ function isAbortError(error) {
     if (!(candidate instanceof Error)) return false;
     if (candidate.name === "AbortError") return true;
     const message = candidate.message.toLowerCase();
-    return message === "api turn cancelled" || message === "api turn canceled" || message.startsWith("executeagentrun timed out after");
+    return message.startsWith("executeagentrun timed out after");
   });
 }
 function isSandboxApiTransientError(error) {