@sentry/junior 0.183.0 → 0.185.0

package/dist/{chunk-AYW7J6K4.js → chunk-MWOH6CIK.js}

@@ -1,36 +1,40 @@
 import {
   createWebAuthorization,
   deleteWebAuthorization
-} from "./chunk-4WGFWHWP.js";
+} from "./chunk-UUULGCKK.js";
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-W7GCLNIV.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
   finalizeFailedTurnReplyWithEvent,
   getTurnUserMessage
-} from "./chunk-WOKJRLM2.js";
+} from "./chunk-DAPC2HTM.js";
 import {
   processPluginTask,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-W5JMPEBO.js";
+} from "./chunk-FFHXG2FX.js";
 import {
   ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+} from "./chunk-6Q7YZLCL.js";
 import {
   coerceThreadConversationState,
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-PLZT45VC.js";
+} from "./chunk-Y5G23T2D.js";
 import {
   healthReportSchema
 } from "./chunk-UTL3MHPC.js";
 import {
   parseSlackThreadId
-} from "./chunk-SQHFVIMZ.js";
+} from "./chunk-X7NCJQAA.js";
 import {
   appendAndEnqueueExclusiveInboundMessage,
   appendAndEnqueueInboundMessage
-} from "./chunk-HUK5XIZL.js";
+} from "./chunk-D63IUQQE.js";
 import {
   TurnInputCommitLostError,
   buildDeterministicTurnId,
@@ -41,10 +45,11 @@ import {
   markTurnClosed,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-56XONJPF.js";
+} from "./chunk-U4CTAVWN.js";
 import {
   abandonTurnRecord,
   buildConversationContext,
+  commitAcceptedReply,
   getTurnRecord,
   hydrateConversationMessages,
   listTurnSummaries,
@@ -56,27 +61,27 @@ import {
   recordDeliveredAssistantMessage,
   saveTurnCheckpoint,
   upsertConversationMessage
-} from "./chunk-24OJZ5OU.js";
+} from "./chunk-WLKWN4CD.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-AHMWPFIW.js";
+} from "./chunk-VH4IU3UC.js";
 import {
   getConversationEventStore,
   getConversationStore,
   getDb
-} from "./chunk-AX3UDIMA.js";
+} from "./chunk-ABAX75GG.js";
 import {
   juniorConversationParticipants,
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-6UXDTPEN.js";
+} from "./chunk-LVK4WJKM.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   canExposeConversationPayload
-} from "./chunk-2ADFGSUS.js";
+} from "./chunk-EIJCPJOY.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -84,7 +89,7 @@ import {
   logException,
   setTags,
   withLogContext
-} from "./chunk-LZBPGX5A.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/handlers/health.ts
 function readHealthReport() {
@@ -196,6 +201,35 @@ import {
   localDestinationSchema
 } from "@sentry/junior-plugin-api";
 
+// src/chat/api-turns/accepted-reply.ts
+async function commitWebAcceptedReply(args) {
+  const conversationMessageId = recordDeliveredAssistantMessage({
+    conversation: args.conversation,
+    sessionId: args.sessionId,
+    source: "web",
+    text: args.text,
+    userMessageId: args.userMessageId
+  });
+  try {
+    await persistWithRetry(
+      () => commitAcceptedReply({
+        ...args.agentMessage ? { agentMessage: args.agentMessage } : void 0,
+        conversation: args.conversation,
+        conversationMessageId,
+        conversationId: args.conversationId
+      })
+    );
+  } catch (error) {
+    logException(
+      new Error("Accepted assistant message persistence failed"),
+      "api.assistant.message_post_delivery_persist.failed",
+      {
+        "error.type": error instanceof Error ? error.name : typeof error
+      }
+    );
+  }
+}
+
 // src/chat/api-turns/cancellation.ts
 function createApiTurnCancellation() {
   const active = /* @__PURE__ */ new Map();
@@ -217,7 +251,7 @@ function createApiTurnCancellation() {
       if (!entry) {
         return false;
       }
-      entry.controller.abort(new Error("API Turn cancelled"));
+      entry.controller.abort(new DOMException("Turn cancelled", "AbortError"));
       return true;
     },
     disconnect(conversationId, signal) {
@@ -257,7 +291,7 @@ async function completeCancelledApiTurn(args) {
     await abandonTurnRecord({
       conversationId: args.conversationId,
       turnId: args.turnId,
-      errorMessage: "API Turn cancelled"
+      errorMessage: "Turn cancelled"
     });
     clearPendingAuth(args.conversation, args.turnId);
     markConversationMessage(args.conversation, args.userMessageId, {
@@ -279,7 +313,9 @@ async function completeCancelledApiTurn(args) {
       conversation: args.conversation,
       sandboxRef: args.sandboxRef
     });
-    await args.lifecycle.complete({
+    await new ConversationTurnLifecycleService(
+      getConversationEventStore()
+    ).complete({
       conversationId: args.conversationId,
       createdAtMs: Date.now(),
       outcome: "cancelled",
@@ -504,20 +540,22 @@ function hasLostTurnInputCommit(error) {
   const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
   return isTurnInputCommitLostError(error) || isTurnInputCommitLostError(cause);
 }
-function createApiTurnWorker(options) {
+function createApiTurnWorker(agentRunner, cancellation) {
   return async (context) => {
     const resolved = await resolveApiTurnWork(context);
     if (!resolved) {
       throw new Error(
-        `API turn worker received non-API work for ${context.conversationId}`
+        `Conversation API worker received other work for ${context.conversationId}`
       );
     }
     if (context.publishExternally) {
       throw new Error(
-        `API turn work must not publish externally for ${context.conversationId}`
+        `Conversation API work cannot publish to a provider for ${context.conversationId}`
       );
     }
-    const lifecycle = options.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore());
+    const lifecycle = new ConversationTurnLifecycleService(
+      getConversationEventStore()
+    );
     const isResume = resolved.kind === "resume";
     let actor;
     let text;
@@ -543,7 +581,7 @@ function createApiTurnWorker(options) {
       );
       if (!resumedActor) {
         throw new Error(
-          `API turn resume missing actor for ${context.conversationId}`
+          `Conversation API resume missing actor for ${context.conversationId}`
         );
       }
       actor = resumedActor;
@@ -577,7 +615,7 @@ function createApiTurnWorker(options) {
             await context.attempt.ack();
           } catch {
             throw new TurnInputCommitLostError(
-              `Conversation work lease lost before API turn inbox ack for ${context.conversationId}`
+              `Conversation work lease lost before Conversation API message acknowledgement for ${context.conversationId}`
             );
           }
           acknowledged = true;
@@ -590,12 +628,12 @@ function createApiTurnWorker(options) {
         });
         let sandboxRef = getPersistedSandboxState(persisted);
         const initialSandboxRef = sandboxRef;
-        const appSignal = options.cancellation?.signal(context.conversationId);
+        const appSignal = cancellation?.signal(context.conversationId);
         const stopSignal = context.stopSignal?.();
         const cancellationSignal = appSignal && stopSignal ? AbortSignal.any([appSignal, stopSignal]) : appSignal ?? stopSignal;
         const finishCancellation = () => {
           if (appSignal) {
-            options.cancellation?.finish(context.conversationId, appSignal);
+            cancellation?.finish(context.conversationId, appSignal);
           }
         };
         const completeCancelledTurn = async () => {
@@ -603,10 +641,9 @@ function createApiTurnWorker(options) {
             await completeCancelledApiTurn({
               acknowledge,
               actorId: actor.userId,
-              cancellation: options.cancellation,
+              cancellation,
               conversation,
               conversationId: context.conversationId,
-              lifecycle,
               sandboxRef,
               signal: appSignal,
               turnId,
@@ -624,7 +661,7 @@ function createApiTurnWorker(options) {
           const userMessage = getTurnUserMessage(conversation, turnId);
           if (!userMessage) {
             throw new Error(
-              `Unable to locate the persisted user message for API turn "${turnId}"`
+              `Unable to locate the persisted user message for Turn "${turnId}"`
             );
           }
           userMessageId = userMessage.id;
@@ -676,37 +713,23 @@ function createApiTurnWorker(options) {
         let failureCode = "persistence_failed";
         let modelFailureEventId;
         let modelFailureCaptureAttempted = false;
-        let reply;
+        let completedSuccessfully = false;
         const deliverAssistantMessage = async (value) => {
+          const agentMessage = typeof value === "string" ? void 0 : value;
           const replyText = typeof value === "string" ? value : getAssistantReplyText(value);
           if (!replyText?.trim()) {
             return;
           }
           failureCode = "delivery_failed";
           assistantMessageDelivered = true;
-          recordDeliveredAssistantMessage({
+          await commitWebAcceptedReply({
+            ...agentMessage ? { agentMessage } : void 0,
             conversation,
+            conversationId: context.conversationId,
             sessionId: turnId,
-            source: "web",
             text: replyText,
             userMessageId
           });
-          try {
-            await persistWithRetry(
-              () => persistConversationMessages({
-                conversation,
-                conversationId: context.conversationId
-              })
-            );
-          } catch (error) {
-            logException(
-              new Error("Accepted assistant message persistence failed"),
-              "api.assistant.message_post_delivery_persist.failed",
-              {
-                "error.type": error instanceof Error ? error.name : typeof error
-              }
-            );
-          }
           failureCode = "agent_run_failed";
         };
         try {
@@ -751,53 +774,112 @@ function createApiTurnWorker(options) {
           failureCode = "agent_run_failed";
           currentRunId = `api-run:${stableHex(turnId, String(startedAtMs))}`;
           setTags({ runId: currentRunId });
-          const outcome = await options.agentRunner.run({
-            conversationId: context.conversationId,
-            turnId,
-            runId: currentRunId,
-            instruction: {
-              text,
-              context: buildConversationContext(conversation, {
-                excludeMessageId: userMessageId
-              })
-            },
-            history: piMessages,
-            actor,
-            credentialContext: credentialContextForActor(actor),
-            destination,
-            publishExternally: false,
-            source,
-            surface: "api",
-            ...cancellationSignal ? { signal: cancellationSignal } : void 0,
-            authorization: createWebAuthorization({
-              actorId: actor.userId,
-              conversationId: context.conversationId
-            }),
-            state: {
-              pendingAuth: conversation.processing.pendingAuth,
-              sandboxRef
-            },
-            delivery: deliverAssistantMessage,
-            durability: {
-              onInputCommitted: acknowledge,
-              shouldYield: context.shouldYield,
-              onSandboxRefChanged: async (nextSandboxRef) => {
-                sandboxRef = nextSandboxRef;
-                await persistThreadStateById(context.conversationId, {
-                  conversation,
-                  sandboxRef
-                });
+          const outcome = await executeTurn(
+            agentRunner,
+            {
+              conversationId: context.conversationId,
+              turnId,
+              runId: currentRunId,
+              instruction: {
+                text,
+                context: buildConversationContext(conversation, {
+                  excludeMessageId: userMessageId
+                })
+              },
+              history: piMessages,
+              actor,
+              credentialContext: credentialContextForActor(actor),
+              destination,
+              publishExternally: false,
+              source,
+              surface: "api",
+              ...cancellationSignal ? { signal: cancellationSignal } : void 0,
+              authorization: createWebAuthorization({
+                actorId: actor.userId,
+                conversationId: context.conversationId
+              }),
+              state: {
+                pendingAuth: conversation.processing.pendingAuth,
+                sandboxRef
               },
-              recordPendingAuth: async (pendingAuth) => {
-                conversation.processing.pendingAuth = pendingAuth;
-                await persistThreadStateById(context.conversationId, {
-                  conversation,
-                  sandboxRef
+              delivery: deliverAssistantMessage,
+              durability: {
+                onInputCommitted: acknowledge,
+                shouldYield: context.shouldYield,
+                onSandboxRefChanged: async (nextSandboxRef) => {
+                  sandboxRef = nextSandboxRef;
+                  await persistThreadStateById(context.conversationId, {
+                    conversation,
+                    sandboxRef
+                  });
+                },
+                recordPendingAuth: async (pendingAuth) => {
+                  conversation.processing.pendingAuth = pendingAuth;
+                  await persistThreadStateById(context.conversationId, {
+                    conversation,
+                    sandboxRef
+                  });
+                }
+              }
+            },
+            async (result) => {
+              if (cancellationSignal?.aborted) {
+                throw cancellationSignal.reason ?? new DOMException("Turn cancelled", "AbortError");
+              }
+              finishCancellation();
+              modelFailureCaptureAttempted = result.diagnostics.outcome !== "success";
+              const finalized = finalizeFailedTurnReplyWithEvent({
+                reply: result,
+                logException
+              });
+              const modelFailureReason = finalized.failureReason;
+              const reply = finalized.reply;
+              modelFailureEventId = finalized.eventId;
+              if (reply.diagnostics.outcome !== "success") {
+                await deliverAssistantMessage(reply.text);
+              }
+              const completedState = buildDeliveredTurnStatePatch({
+                conversation,
+                reply,
+                sessionId: turnId,
+                userMessageId
+              });
+              await persistThreadStateById(context.conversationId, {
+                conversation: completedState.conversation,
+                sandboxRef: reply.sandboxRef ?? sandboxRef
+              });
+              if (reply.piMessages?.length) {
+                const latest = await getTurnRecord(
+                  context.conversationId,
+                  turnId
+                );
+                await saveTurnCheckpoint({
+                  mode: "completed",
+                  conversationId: context.conversationId,
+                  turnId,
+                  sliceId: latest?.sliceId ?? 1,
+                  messages: reply.piMessages,
+                  durationMs: reply.diagnostics.durationMs,
+                  usage: reply.diagnostics.usage,
+                  destination,
+                  publishExternally: false,
+                  source,
+                  actor,
+                  surface: "api"
                 });
               }
+              completedSuccessfully = reply.diagnostics.outcome === "success";
+              return completedSuccessfully ? {
+                outcome: assistantMessageDelivered ? "success" : "no_reply"
+              } : {
+                ...modelFailureEventId ? { eventId: modelFailureEventId } : void 0,
+                failureCode: "model_execution_failed",
+                ...modelFailureReason ? { failureReason: modelFailureReason } : void 0,
+                outcome: "failed"
+              };
             }
-          });
-          if (cancellationSignal?.aborted) {
+          );
+          if (outcome.status !== "completed" && cancellationSignal?.aborted) {
             return await completeCancelledTurn();
           }
           if (outcome.status === "suspended") {
@@ -813,57 +895,12 @@ function createApiTurnWorker(options) {
               sandboxRef
             });
             if (appSignal) {
-              options.cancellation?.park(context.conversationId, appSignal);
+              cancellation?.park(context.conversationId, appSignal);
             }
             await acknowledge();
             return { status: "paused" };
           }
-          finishCancellation();
-          reply = outcome.result;
-          modelFailureCaptureAttempted = reply.diagnostics.outcome !== "success";
-          const finalized = finalizeFailedTurnReplyWithEvent({
-            reply,
-            logException
-          });
-          reply = finalized.reply;
-          modelFailureEventId = finalized.eventId;
-          if (reply.diagnostics.outcome !== "success") {
-            await deliverAssistantMessage(reply.text);
-          }
-          const completedState = buildDeliveredTurnStatePatch({
-            conversation,
-            reply,
-            sessionId: turnId,
-            userMessageId
-          });
-          await persistThreadStateById(context.conversationId, {
-            conversation: completedState.conversation,
-            sandboxRef: reply.sandboxRef ?? sandboxRef
-          });
-          if (reply.piMessages?.length) {
-            const latest = await getTurnRecord(context.conversationId, turnId);
-            await saveTurnCheckpoint({
-              mode: "completed",
-              conversationId: context.conversationId,
-              turnId,
-              sliceId: latest?.sliceId ?? 1,
-              messages: reply.piMessages,
-              durationMs: reply.diagnostics.durationMs,
-              usage: reply.diagnostics.usage,
-              destination,
-              publishExternally: false,
-              source,
-              actor,
-              surface: "api"
-            });
-          }
-          if (reply.diagnostics.outcome === "success") {
-            await lifecycle.complete({
-              conversationId: context.conversationId,
-              createdAtMs: Date.now(),
-              outcome: assistantMessageDelivered ? "success" : "no_reply",
-              turnId
-            });
+          if (completedSuccessfully) {
             try {
               await scheduleSessionCompletedPluginTasks(
                 {
@@ -895,30 +932,23 @@ function createApiTurnWorker(options) {
                 turnId
               });
             }
-          } else {
-            await lifecycle.fail({
-              conversationId: context.conversationId,
-              createdAtMs: Date.now(),
-              ...modelFailureEventId ? { eventId: modelFailureEventId } : void 0,
-              failureCode: "model_execution_failed",
-              turnId
-            });
           }
           await acknowledge();
           return { status: "completed" };
         } catch (error) {
-          if (hasLostTurnInputCommit(error)) {
+          const failure = error instanceof AgentRunError ? error.cause : error;
+          if (hasLostTurnInputCommit(failure)) {
             return { status: "lost_lease" };
           }
           if (cancellationSignal?.aborted) {
             return await completeCancelledTurn();
           }
           if (!context.attempt.isFinalAttempt) {
-            throw error;
+            throw failure;
           }
           const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureApiBoundaryFailure({
             conversationId: context.conversationId,
-            error,
+            error: failure,
             failureCode,
             runId: currentRunId,
             turnId

package/dist/{chunk-LZBPGX5A.js → chunk-OMQ2J6F6.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-W46NIB5H.js";
+} from "./chunk-7GAP2XG4.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-G2B2XZQW.js → chunk-PNYJOEVV.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-LMNMMESF.js";
+} from "./chunk-LRI5IRGY.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/{chunk-37IQ6DGU.js → chunk-QCT4226Q.js}

@@ -6,14 +6,14 @@ import {
   isStale,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-X52ESOBP.js";
+} from "./chunk-EJYP3NQ4.js";
 import {
   getStateAdapter
-} from "./chunk-G2B2XZQW.js";
+} from "./chunk-PNYJOEVV.js";
 import {
   setSpanAttributes,
   withSpan
-} from "./chunk-LZBPGX5A.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/sandbox/resources.ts
 var configuredResources;

package/dist/{chunk-R767Y7QV.js → chunk-QZKHHG3B.js}

@@ -1,11 +1,13 @@
 import {
-  ToolInputError,
-  canRouteResourceEvents,
-  getPlugins
-} from "./chunk-AHMWPFIW.js";
+  ToolInputError
+} from "./chunk-WLKWN4CD.js";
+import {
+  getPlugins,
+  getSlackClient
+} from "./chunk-VH4IU3UC.js";
 import {
   getDb
-} from "./chunk-AX3UDIMA.js";
+} from "./chunk-ABAX75GG.js";
 import {
   juniorAttachments,
   juniorConversations,
@@ -13,16 +15,38 @@ import {
   juniorSchedulerRuns,
   juniorSchedulerTasks,
   juniorStats
-} from "./chunk-6UXDTPEN.js";
+} from "./chunk-LVK4WJKM.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   getSlackBotToken
-} from "./chunk-LMNMMESF.js";
+} from "./chunk-LRI5IRGY.js";
 import {
   logWarn
-} from "./chunk-LZBPGX5A.js";
+} from "./chunk-OMQ2J6F6.js";
+
+// src/chat/resource-events/workspace.ts
+function canRouteResourceEvents() {
+  return Boolean(getSlackBotToken());
+}
+function createResourceEventTeamIdResolver() {
+  let pending;
+  return async () => {
+    if (!canRouteResourceEvents()) return void 0;
+    pending ??= getSlackClient().auth.test().then((result) => {
+      const teamId = result.team_id?.trim();
+      if (!teamId) {
+        throw new Error("Slack auth.test did not return a workspace team id");
+      }
+      return teamId;
+    }).catch((error) => {
+      pending = void 0;
+      throw error;
+    });
+    return await pending;
+  };
+}
 
 // src/chat/event-tasks/store.ts
 import {
@@ -1250,6 +1274,8 @@ export {
   registeredResourceEventMatchSchema,
   requireSupportedResourceEventMatch,
   normalizeEventIdentifier,
+  canRouteResourceEvents,
+  createResourceEventTeamIdResolver,
   getResourceEventCatalog,
   getEventTask,
   createEventTask,

package/dist/{chunk-VOV3SCM3.js → chunk-TVVAMOLS.js}

@@ -1,10 +1,10 @@
 import {
   createAndEnqueueAgentInvocation
-} from "./chunk-IO6KFXYE.js";
+} from "./chunk-HJPC32TQ.js";
 import {
   actorFromRun,
   toolInvocationDestination
-} from "./chunk-RF6J3DIO.js";
+} from "./chunk-INQHUE72.js";
 
 // src/chat/agent-invocations/spawn.ts
 function bindSpawnAgent(run, options) {

package/dist/{chunk-56XONJPF.js → chunk-U4CTAVWN.js}

@@ -1,7 +1,7 @@
 import {
   abandonTurnRecord,
   extractAssistantText
-} from "./chunk-24OJZ5OU.js";
+} from "./chunk-WLKWN4CD.js";
 
 // src/chat/state/turn-id.ts
 function buildDeterministicTurnId(messageId) {

package/dist/{chunk-4WGFWHWP.js → chunk-UUULGCKK.js}

@@ -1,6 +1,6 @@
 import {
   getStateAdapter
-} from "./chunk-G2B2XZQW.js";
+} from "./chunk-PNYJOEVV.js";
 import {
   getClient
 } from "./chunk-PEQXYSSE.js";