@sentry/junior 0.184.0 → 0.186.0

package/dist/{chunk-ACPDVEJO.js → chunk-O6GQO7VP.js}

@@ -4,7 +4,11 @@ import {
 import {
   buildSentryConversationUrl,
   deleteWebAuthorization
-} from "./chunk-LCP4EDKR.js";
+} from "./chunk-PZZOGHVR.js";
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-GQMQCY7H.js";
 import {
   buildDeliveredTurnStatePatch,
   finalizeFailedTurnReplyWithEvent,
@@ -15,14 +19,14 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-M5YWNMTE.js";
+} from "./chunk-OZG7E22Y.js";
 import {
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-6WGC3SO4.js";
+} from "./chunk-MCLWOBPN.js";
 import {
-  ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+  getTurnLifecycle
+} from "./chunk-STOCCPWH.js";
 import {
   coerceThreadConversationState,
   configValueSchema,
@@ -30,7 +34,7 @@ import {
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-E57WPXWY.js";
+} from "./chunk-CM6RTYSO.js";
 import {
   createUserTokenStore,
   deleteMcpAuthSession,
@@ -39,12 +43,8 @@ import {
   getMcpProviderErrorAttributes,
   getMcpStoredOAuthCredentials,
   lookupSlackUserProfile,
-  resolvePluginOAuthAccount,
-  runAgentWithTimeout
-} from "./chunk-FKEZZMXS.js";
-import {
-  RetryableDeliveryError
-} from "./chunk-RF6J3DIO.js";
+  resolvePluginOAuthAccount
+} from "./chunk-QU3URVWG.js";
 import {
   addReactionToMessage,
   escapeSlackMrkdwnText,
@@ -57,17 +57,20 @@ import {
   removeReactionFromMessage,
   resolveBaseUrl,
   truncateStatusText
-} from "./chunk-JM2COLGC.js";
+} from "./chunk-VQZYIVYN.js";
 import {
   parseSlackThreadId,
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-YKX6MTLU.js";
+} from "./chunk-7EOWT62G.js";
+import {
+  RetryableDeliveryError
+} from "./chunk-INQHUE72.js";
 import {
   ensureConversationWake,
   requestConversationWork
-} from "./chunk-Z3QAXJR7.js";
+} from "./chunk-2IBDVE62.js";
 import {
   CooperativeTurnYieldError,
   clearPendingAuth,
@@ -76,7 +79,7 @@ import {
   isCooperativeTurnYieldError,
   isPendingAuthLatestRequest,
   markTurnFailed
-} from "./chunk-JA43DV4Y.js";
+} from "./chunk-VOGOTEW7.js";
 import {
   TurnSliceLimitExceededError,
   abandonTurnRecord,
@@ -96,13 +99,13 @@ import {
   recordTurnSummary,
   saveTurnCheckpoint,
   turnHasReply
-} from "./chunk-2ZQPVX7C.js";
+} from "./chunk-H7X2G2KS.js";
 import {
   getVercelConversationWorkQueue
 } from "./chunk-DKIJ2RP5.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-MLSQX2EX.js";
+} from "./chunk-BRKB5R7P.js";
 import {
   SlackActionError,
   getDashboardConversationLink,
@@ -111,37 +114,38 @@ import {
   getSlackClient,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-4CNDGK25.js";
+} from "./chunk-JFPY6XFF.js";
 import {
-  getConversationEventStore,
   getSqlExecutor,
   requireSlackDestination,
   upsertIdentity,
   upsertLinkedIdentity
-} from "./chunk-IZDYYYGP.js";
+} from "./chunk-43LODHJM.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-DUKIDPF6.js";
+} from "./chunk-DOP3FIQC.js";
 import {
   botConfig,
-  defaultModelId,
   escapeXml,
   getChatConfig,
   getRuntimeMetadata,
   normalizeSlackEmojiName
-} from "./chunk-6UDPINOX.js";
+} from "./chunk-AD64YMEC.js";
+import {
+  defaultModelId
+} from "./chunk-D4YV5TDV.js";
 import {
   discoverSkills
-} from "./chunk-WQFEWULF.js";
+} from "./chunk-HKFLRIBD.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
+} from "./chunk-NRMAOGRS.js";
 import {
   buildOAuthTokenRequest,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse
-} from "./chunk-LHXIZLFF.js";
+} from "./chunk-64WF2GQ3.js";
 import {
   createSlackResumeActor,
   isUserActor,
@@ -160,7 +164,7 @@ import {
   setTags,
   toOptionalString,
   withLogContext
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/slack/assistant-thread/status-render.ts
 var DEFAULT_STATUS_CONTEXTS = {
@@ -970,7 +974,7 @@ function getMessageTs(message) {
   return void 0;
 }
 
-// src/chat/runtime/processing-reaction.ts
+// src/chat/providers/slack/processing-reaction.ts
 var noProcessingReaction = {
   complete: async () => void 0,
   keep: () => void 0,
@@ -982,7 +986,7 @@ function isProcessingReactionEmoji(value) {
 function shouldKeepProcessingReactionForToolInvocation(input) {
   return input.toolName === "addReaction" && isProcessingReactionEmoji(input.params.emoji);
 }
-async function startSlackProcessingReaction(args) {
+async function startProcessingReaction(args) {
   if (args.message.author.isMe) {
     return noProcessingReaction;
   }
@@ -991,13 +995,12 @@ async function startSlackProcessingReaction(args) {
   if (!channelId || !messageTs) {
     return noProcessingReaction;
   }
-  return startSlackProcessingReactionForMessage({
+  return startProcessingReactionForMessage({
     channelId,
-    timestamp: messageTs,
-    logException: args.logException
+    timestamp: messageTs
   });
 }
-async function startSlackProcessingReactionForMessage(args) {
+async function startProcessingReactionForMessage(args) {
   try {
     await addReactionToMessage({
       channelId: args.channelId,
@@ -1005,7 +1008,7 @@ async function startSlackProcessingReactionForMessage(args) {
       emoji: getChatConfig().slack.processingReactionEmoji
     });
   } catch (error) {
-    args.logException(error, "slack.processing.reaction_add.failed", {
+    logException(error, "slack.processing.reaction_add.failed", {
       "app.slack.action": "reactions.add",
       "messaging.message.id": args.timestamp,
       ...getSlackErrorObservabilityAttributes(error)
@@ -1025,7 +1028,7 @@ async function startSlackProcessingReactionForMessage(args) {
       });
       return true;
     } catch (error) {
-      args.logException(error, "slack.processing.reaction_remove.failed", {
+      logException(error, "slack.processing.reaction_remove.failed", {
         "app.slack.action": "reactions.remove",
         "messaging.message.id": args.timestamp,
         ...getSlackErrorObservabilityAttributes(error)
@@ -1047,7 +1050,7 @@ async function startSlackProcessingReactionForMessage(args) {
           emoji: getChatConfig().slack.completedReactionEmoji
         });
       } catch (error) {
-        args.logException(error, "slack.processing.reaction_complete.failed", {
+        logException(error, "slack.processing.reaction_complete.failed", {
           "app.slack.action": "reactions.add",
           "messaging.message.id": args.timestamp,
           ...getSlackErrorObservabilityAttributes(error)
@@ -1086,11 +1089,8 @@ function buildAuthPauseResponse(slackUserId, providerDisplayName, requestText) {
 I sent you a link.`;
 }
 
-// src/chat/runtime/slack-resume.ts
-function resolveReplyTimeoutMs(explicitTimeoutMs) {
-  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
-    return explicitTimeoutMs;
-  }
+// src/chat/providers/slack/resume.ts
+function resolveReplyTimeoutMs() {
   const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
   if (!raw) {
     return void 0;
@@ -1130,7 +1130,7 @@ function createReadOnlyConfigService(rawValues) {
   return {
     get: async (key) => entries.find((entry) => entry.key === key),
     set: async () => {
-      throw new Error("Read-only configuration in resumed context");
+      throw new Error("Configuration is read-only for a resumed Run");
     },
     unset: async () => false,
     list: async ({ prefix } = {}) => entries.filter((entry) => !prefix || entry.key.startsWith(prefix)),
@@ -1148,7 +1148,7 @@ function createReadOnlyConfigService(rawValues) {
 }
 var ResumeTurnBusyError = class extends Error {
   constructor(lockKey) {
-    super(`A turn already owns resume lock "${lockKey}"`);
+    super(`Another worker is already resuming Slack Turn "${lockKey}"`);
     this.name = "ResumeTurnBusyError";
   }
 };
@@ -1156,7 +1156,7 @@ function getDefaultLockKey(channelId, threadTs) {
   return threadTs ? `slack:${channelId}:${threadTs}` : `slack:${channelId}`;
 }
 function getResumeLogContext(args, lockKey) {
-  const actor = args.replyContext?.actor;
+  const actor = args.run?.actor;
   return {
     conversationId: args.conversationId,
     messageConversationId: lockKey,
@@ -1175,11 +1175,12 @@ async function postResumeFailureReply(args) {
   });
 }
 async function handleResumeFailure(args) {
+  const turnLifecycle = getTurnLifecycle();
   const capturedEventId = logException(args.error, args.eventName);
   const eventId = requireTurnFailureEventId(capturedEventId, args.eventName);
   let failureStatePersistError;
   try {
-    await args.resumeArgs.onFailure?.(args.error);
+    await args.resume.onFailure?.(args.error);
   } catch (persistError) {
     const persistEventId = logException(
       persistError,
@@ -1187,9 +1188,9 @@ async function handleResumeFailure(args) {
       { "app.error.original_event_id": eventId }
     );
     try {
-      await args.turnLifecycle.fail({
-        conversationId: args.resumeArgs.conversationId,
-        turnId: args.resumeArgs.turnId,
+      await turnLifecycle.fail({
+        conversationId: args.resume.conversationId,
+        turnId: args.resume.turnId,
         createdAtMs: Date.now(),
         failureCode: "persistence_failed",
         ...persistEventId ? { eventId: persistEventId } : void 0
@@ -1205,8 +1206,8 @@ async function handleResumeFailure(args) {
   }
   try {
     await postResumeFailureReply({
-      channelId: args.resumeArgs.channelId,
-      threadTs: args.resumeArgs.threadTs,
+      channelId: args.resume.channelId,
+      threadTs: args.resume.threadTs,
       eventId,
       error: args.error
     });
@@ -1217,9 +1218,9 @@ async function handleResumeFailure(args) {
       { "app.error.original_event_id": eventId }
     );
     try {
-      await args.turnLifecycle.fail({
-        conversationId: args.resumeArgs.conversationId,
-        turnId: args.resumeArgs.turnId,
+      await turnLifecycle.fail({
+        conversationId: args.resume.conversationId,
+        turnId: args.resume.turnId,
         createdAtMs: Date.now(),
         failureCode: "delivery_failed",
         ...deliveryEventId ? { eventId: deliveryEventId } : void 0
@@ -1236,36 +1237,36 @@ async function handleResumeFailure(args) {
   if (failureStatePersistError) {
     throw failureStatePersistError;
   }
-  await args.turnLifecycle.fail({
-    conversationId: args.resumeArgs.conversationId,
-    turnId: args.resumeArgs.turnId,
+  await turnLifecycle.fail({
+    conversationId: args.resume.conversationId,
+    turnId: args.resume.turnId,
     createdAtMs: Date.now(),
     failureCode: args.failureCode,
     eventId
   });
 }
-function createResumeReplyContext(args, statusSession, delivery) {
-  const replyContext = args.replyContext;
-  if (!replyContext) {
-    throw new TypeError("Slack resume requires a reply context");
+function buildResumedRun(args, statusSession, delivery) {
+  const savedRun = args.run;
+  if (!savedRun) {
+    throw new TypeError("Slack resume requires a saved Run");
   }
-  if (!replyContext.source) {
-    throw new TypeError("Slack resume requires a reply context source");
+  if (!savedRun.source) {
+    throw new TypeError("Slack resume requires a Run Source");
   }
-  const source = replyContext.source;
-  if (replyContext.destination.platform !== "slack") {
-    throw new TypeError("Slack resume requires a Slack destination");
+  const source = savedRun.source;
+  if (savedRun.destination.platform !== "slack") {
+    throw new TypeError("Slack resume requires a Slack Destination");
   }
   const requestDeadline = getTurnRequestDeadline();
   const threadId = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
-  const persistedLocationConfiguration = replyContext.environment?.locationConfiguration ?? (replyContext.environment?.configuration ? createReadOnlyConfigService(replyContext.environment.configuration) : void 0);
-  const priorOnEvent = replyContext.onEvent;
+  const persistedLocationConfiguration = savedRun.environment?.locationConfiguration ?? (savedRun.environment?.configuration ? createReadOnlyConfigService(savedRun.environment.configuration) : void 0);
+  const priorOnEvent = savedRun.onEvent;
   return {
-    ...replyContext,
+    ...savedRun,
     conversationId: args.conversationId,
     turnId: args.turnId,
     instruction: {
-      ...replyContext.instruction ?? { text: args.messageText },
+      ...savedRun.instruction ?? { text: args.messageText },
       text: args.messageText
     },
     source: source.platform === "slack" ? {
@@ -1273,9 +1274,9 @@ function createResumeReplyContext(args, statusSession, delivery) {
       channelId: args.channelId,
       ...args.threadTs ? { threadTs: args.threadTs } : void 0
     } : source,
-    deadlineAtMs: replyContext.deadlineAtMs ?? requestDeadline?.deadlineAtMs,
+    deadlineAtMs: savedRun.deadlineAtMs ?? requestDeadline?.deadlineAtMs,
     environment: {
-      ...replyContext.environment,
+      ...savedRun.environment,
       locationConfiguration: persistedLocationConfiguration
     },
     onEvent: async (event) => {
@@ -1286,12 +1287,12 @@ function createResumeReplyContext(args, statusSession, delivery) {
     },
     delivery,
     durability: {
-      ...replyContext.durability,
+      ...savedRun.durability,
       onSandboxRefChanged: async (sandboxRef) => {
         await persistThreadStateById(threadId, {
           sandboxRef
         });
-        await replyContext.durability?.onSandboxRefChanged?.(sandboxRef);
+        await savedRun.durability?.onSandboxRefChanged?.(sandboxRef);
       }
     }
   };
@@ -1321,8 +1322,9 @@ async function resumeSlackTurnInContext(args) {
   let deferredFailureHandler;
   let runResultHandled = false;
   let assistantMessageDelivered = false;
+  let shouldScheduleCompletedPluginTasks = false;
   let postDeliveryCommitError;
-  const turnLifecycle = args.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore());
+  const turnLifecycle = getTurnLifecycle();
   let failureCode = "agent_run_failed";
   let runArgs = args;
   try {
@@ -1334,36 +1336,33 @@ async function resumeSlackTurnInContext(args) {
       runArgs = { ...args, ...preparedArgs };
     }
     setTags(getResumeLogContext(runArgs, lockKey));
-    const activeReplyContext = runArgs.replyContext;
-    if (!activeReplyContext) {
-      throw new Error("Resumed turn requires replyContext");
+    const savedRun = runArgs.run;
+    if (!savedRun) {
+      throw new Error("Resumed Turn requires a saved Run");
     }
-    const credentialContext = activeReplyContext.credentialContext;
+    const credentialContext = savedRun.credentialContext;
     if (!credentialContext) {
-      throw new Error("Resumed turn requires replyContext.credentialContext");
+      throw new Error("Resumed Run requires a credential context");
     }
-    const routingActor = activeReplyContext.actor;
+    const routingActor = savedRun.actor;
     let resumeActor;
     if ("type" in credentialContext.actor) {
       if (!isUserActor(routingActor) || credentialContext.actor.userId !== routingActor.userId) {
-        throw new Error(
-          "Resumed turn credential actor must match replyContext.actor.userId"
-        );
+        throw new Error("Resumed Run credential actor must match its Actor");
       }
       resumeActor = routingActor;
     } else {
       if (routingActor && (routingActor.platform !== "system" || routingActor.name !== credentialContext.actor.name)) {
         throw new Error(
-          "Resumed turn system credential actor must match replyContext.actor"
+          "Resumed Run system credential actor must match its Actor"
         );
       }
       resumeActor = credentialContext.actor;
     }
     if (runArgs.messageTs) {
-      processingReaction = await startSlackProcessingReactionForMessage({
+      processingReaction = await startProcessingReactionForMessage({
         channelId: runArgs.channelId,
-        timestamp: runArgs.messageTs,
-        logException
+        timestamp: runArgs.messageTs
       });
     }
     if (runArgs.initialText) {
@@ -1417,11 +1416,11 @@ async function resumeSlackTurnInContext(args) {
       const deliveryState2 = await getDeliveryConversation();
       let slackMessageTs = [];
       try {
-        if (runArgs.replyContext?.publishExternally !== false) {
+        if (runArgs.run?.publishExternally !== false) {
           slackMessageTs = await sendSlackReply({
             channelId: runArgs.channelId,
             conversationId: runArgs.conversationId,
-            replyAttribution: runArgs.replyContext?.dispatch?.replyAttribution,
+            replyAttribution: runArgs.run?.dispatch?.replyAttribution,
             text,
             threadTs: runArgs.threadTs
           });
@@ -1448,7 +1447,7 @@ async function resumeSlackTurnInContext(args) {
         });
       }
       try {
-        const destination = runArgs.replyContext?.destination;
+        const destination = runArgs.run?.destination;
         const providerConversationIds = runArgs.threadTs ? [runArgs.threadTs] : slackMessageTs;
         await persistWithRetry(
           () => commitAcceptedReply({
@@ -1456,7 +1455,7 @@ async function resumeSlackTurnInContext(args) {
             conversation: deliveryState2.conversation,
             conversationMessageId: recordedMessageId,
             conversationId,
-            ...runArgs.replyContext?.dispatch && destination?.platform === "slack" && providerConversationIds.length > 0 ? {
+            ...runArgs.run?.dispatch && destination?.platform === "slack" && providerConversationIds.length > 0 ? {
               providerConversationBindings: providerConversationIds.map(
                 (providerConversationId) => ({
                   provider: "slack",
@@ -1475,22 +1474,21 @@ async function resumeSlackTurnInContext(args) {
           { "error.type": error instanceof Error ? error.name : typeof error }
         );
       }
-      const replyContext2 = runArgs.replyContext;
-      const dispatchId = replyContext2?.dispatch?.id;
-      if (messageTs && dispatchId && replyContext2) {
+      const dispatchId = savedRun.dispatch?.id;
+      if (messageTs && dispatchId) {
         try {
           await persistWithRetry(
             () => recordTurnSummary({
               conversationId: runArgs.conversationId,
-              destination: replyContext2.destination,
-              destinationVisibility: replyContext2.destinationVisibility,
+              destination: savedRun.destination,
+              destinationVisibility: savedRun.destinationVisibility,
               dispatchId,
               resultMessageId: messageTs,
               turnId: runArgs.turnId,
               sliceId: runArgs.sliceId ?? 1,
-              source: replyContext2.source,
+              source: savedRun.source,
               state: "running",
-              surface: replyContext2.surface ?? "slack"
+              surface: savedRun.surface ?? "slack"
             })
           );
         } catch (error) {
@@ -1504,11 +1502,7 @@ async function resumeSlackTurnInContext(args) {
       deliveryState.conversation,
       sessionId
     );
-    const replyContext = createResumeReplyContext(
-      runArgs,
-      status,
-      deliverAssistantMessage
-    );
+    const run = buildResumedRun(runArgs, status, deliverAssistantMessage);
     if (runArgs.inputMessageIds?.length) {
       await turnLifecycle.start({
         conversationId: runArgs.conversationId,
@@ -1518,10 +1512,70 @@ async function resumeSlackTurnInContext(args) {
         surface: "slack"
       });
     }
-    const replyTimeoutMs = resolveReplyTimeoutMs(runArgs.replyTimeoutMs);
-    const outcome = await runAgentWithTimeout(
-      runArgs.agentRunner,
-      replyContext,
+    const replyTimeoutMs = resolveReplyTimeoutMs();
+    const outcome = await runArgs.executeTurn(
+      run,
+      async (result) => {
+        const finalized = finalizeFailedTurnReplyWithEvent({
+          reply: result,
+          logException
+        });
+        const reply = finalized.reply;
+        const dispatchErrorMessage = run.dispatch && reply.diagnostics.outcome !== "success" ? reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.` : void 0;
+        if (reply.diagnostics.outcome !== "success") {
+          await deliverAssistantMessage(reply.text);
+        }
+        runResultHandled = true;
+        await status.clear();
+        failureCode = "persistence_failed";
+        if (reply.piMessages?.length) {
+          await saveTurnCheckpoint({
+            mode: "completed",
+            conversationId: runArgs.conversationId,
+            turnId: runArgs.turnId,
+            messages: reply.piMessages,
+            durationMs: reply.diagnostics.durationMs,
+            usage: reply.diagnostics.usage,
+            destination: run.destination,
+            destinationVisibility: run.destinationVisibility,
+            dispatchId: run.dispatch?.id,
+            dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+            ...dispatchErrorMessage ? { errorMessage: dispatchErrorMessage } : void 0,
+            ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+            source: run.source,
+            actor: resumeActor,
+            surface: run.surface ?? "slack",
+            sliceId: runArgs.sliceId
+          });
+        } else if (run.dispatch?.id) {
+          await recordTurnSummary({
+            conversationId: runArgs.conversationId,
+            destination: run.destination,
+            destinationVisibility: run.destinationVisibility,
+            dispatchId: run.dispatch?.id,
+            dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+            ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+            turnId: runArgs.turnId,
+            sliceId: runArgs.sliceId ?? 1,
+            source: run.source,
+            state: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+            surface: run.surface ?? "slack"
+          });
+        }
+        await runArgs.commitResult?.(reply);
+        if (reply.diagnostics.outcome === "success") {
+          shouldScheduleCompletedPluginTasks = true;
+          return {
+            outcome: assistantMessageDelivered ? "success" : "no_reply"
+          };
+        }
+        return {
+          outcome: "failed",
+          failureCode: "model_execution_failed",
+          ...finalized.eventId ? { eventId: finalized.eventId } : void 0,
+          ...finalized.failureReason ? { failureReason: finalized.failureReason } : void 0
+        };
+      },
       replyTimeoutMs
     );
     if (outcome.status !== "completed") {
@@ -1540,7 +1594,7 @@ async function resumeSlackTurnInContext(args) {
           });
         };
       } else if (outcome.status === "suspended") {
-        if (runArgs.ownsConversationLease && (outcome.reason === "timeout" || activeReplyContext.durability?.shouldYield?.())) {
+        if (runArgs.ownsConversationLease && (outcome.reason === "timeout" || savedRun.durability?.shouldYield?.())) {
           throw new CooperativeTurnYieldError();
         }
         if (onSuspend) {
@@ -1550,124 +1604,49 @@ async function resumeSlackTurnInContext(args) {
         } else {
           deferredFailureHandler = async () => {
             await handleResumeFailure({
-              body: "Failed to resume Slack turn",
-              error: new Error(
-                `Resumed run ended suspended without a pause handler`
-              ),
+              error: new Error("Resumed Run ended suspended without onSuspend"),
               eventName: "slack.resume.turn.failed",
               failureCode: "agent_run_failed",
-              turnLifecycle,
-              lockKey,
-              resumeArgs: runArgs
+              resume: runArgs
             });
           };
         }
       } else {
         deferredFailureHandler = async () => {
           await handleResumeFailure({
-            body: "Failed to resume Slack turn",
             error: new Error(
-              `Resumed run ended ${outcome.status} without a pause handler`
+              `Resumed Run ended ${outcome.status} without its required callback`
             ),
             eventName: "slack.resume.turn.failed",
             failureCode: "agent_run_failed",
-            turnLifecycle,
-            lockKey,
-            resumeArgs: runArgs
+            resume: runArgs
           });
         };
       }
-    } else {
-      const finalized = finalizeFailedTurnReplyWithEvent({
-        reply: outcome.result,
-        logException
-      });
-      const reply = finalized.reply;
-      const dispatchErrorMessage = replyContext.dispatch && reply.diagnostics.outcome !== "success" ? reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.` : void 0;
-      if (reply.diagnostics.outcome !== "success") {
-        await deliverAssistantMessage(reply.text);
-      }
-      runResultHandled = true;
-      await status.clear();
-      failureCode = "persistence_failed";
-      if (reply.piMessages?.length) {
-        await saveTurnCheckpoint({
-          mode: "completed",
-          conversationId: runArgs.conversationId,
-          turnId: runArgs.turnId,
-          messages: reply.piMessages,
-          durationMs: reply.diagnostics.durationMs,
-          usage: reply.diagnostics.usage,
-          destination: replyContext.destination,
-          destinationVisibility: replyContext.destinationVisibility,
-          dispatchId: replyContext.dispatch?.id,
-          dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
-          ...dispatchErrorMessage ? { errorMessage: dispatchErrorMessage } : void 0,
-          ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
-          source: replyContext.source,
-          actor: resumeActor,
-          surface: replyContext.surface ?? "slack",
-          sliceId: runArgs.sliceId
-        });
-      } else if (replyContext.dispatch?.id) {
-        await recordTurnSummary({
-          conversationId: runArgs.conversationId,
-          destination: replyContext.destination,
-          destinationVisibility: replyContext.destinationVisibility,
-          dispatchId: replyContext.dispatch?.id,
-          dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
-          ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
-          turnId: runArgs.turnId,
-          sliceId: runArgs.sliceId ?? 1,
-          source: replyContext.source,
-          state: reply.diagnostics.outcome === "success" ? "completed" : "failed",
-          surface: replyContext.surface ?? "slack"
-        });
-      }
-      await runArgs.commitResult?.(reply);
-      if (reply.diagnostics.outcome === "success") {
-        await turnLifecycle.complete({
-          conversationId: runArgs.conversationId,
-          turnId: runArgs.turnId,
-          createdAtMs: Date.now(),
-          outcome: assistantMessageDelivered ? "success" : "no_reply"
-        });
-      } else {
-        await turnLifecycle.fail({
+    }
+    if (shouldScheduleCompletedPluginTasks) {
+      try {
+        const params = {
           conversationId: runArgs.conversationId,
-          turnId: runArgs.turnId,
-          createdAtMs: Date.now(),
-          failureCode: "model_execution_failed",
-          ...finalized.eventId ? { eventId: finalized.eventId } : void 0
-        });
-      }
-      if (reply.diagnostics.outcome === "success") {
-        try {
-          const params = {
-            conversationId: runArgs.conversationId,
-            sessionId: runArgs.turnId
-          };
-          if (runArgs.scheduleSessionCompletedPluginTasks) {
-            await runArgs.scheduleSessionCompletedPluginTasks(params);
-          } else {
-            await scheduleSessionCompletedPluginTasks(params);
-          }
-        } catch (scheduleError) {
-          logException(
-            scheduleError,
-            "plugin.session.completed_task_schedule.failed"
-          );
-        }
+          sessionId: runArgs.turnId
+        };
+        await (runArgs.scheduleSessionCompletedPluginTasks ?? scheduleSessionCompletedPluginTasks)(params);
+      } catch (scheduleError) {
+        logException(
+          scheduleError,
+          "plugin.session.completed_task_schedule.failed"
+        );
       }
     }
   } catch (error) {
     await status.clear();
-    if (isCooperativeTurnYieldError(error)) {
+    const runError = error instanceof AgentRunError ? error.cause : error;
+    if (isCooperativeTurnYieldError(runError)) {
       if (lock) {
         await stateAdapter.releaseLock(lock);
       }
       await processingReaction?.stop();
-      throw error;
+      throw runError;
     }
     if (runResultHandled) {
       postDeliveryCommitError = error;
@@ -1682,13 +1661,10 @@ async function resumeSlackTurnInContext(args) {
     } else {
       deferredFailureHandler = async () => {
         await handleResumeFailure({
-          body: "Failed to resume Slack turn",
-          error,
+          error: runError,
           eventName: "slack.resume.turn.failed",
           failureCode,
-          turnLifecycle,
-          lockKey,
-          resumeArgs: runArgs
+          resume: runArgs
         });
       };
     }
@@ -1729,19 +1705,16 @@ async function resumeSlackTurnInContext(args) {
             deferredAuthInfo.requestText
           ),
           runArgs.conversationId,
-          runArgs.replyContext?.dispatch?.replyAttribution
+          runArgs.run?.dispatch?.replyAttribution
         );
       }
       return true;
     } catch (pauseError) {
       await handleResumeFailure({
-        body: "Failed to handle resumed turn pause",
         error: pauseError,
         eventName: "slack.resume.pause_handler.failed",
         failureCode: "persistence_failed",
-        turnLifecycle,
-        lockKey,
-        resumeArgs: runArgs
+        resume: runArgs
       });
       return true;
     }
@@ -1807,6 +1780,15 @@ async function wakePausedTurn(request, options = {}) {
     state: options.state
   });
 }
+function createPausedTurns(options = {}) {
+  return {
+    get: (args) => getPausedTurnRequest({
+      ...args,
+      conversationStore: options.conversationStore
+    }),
+    wake: (request) => wakePausedTurn(request, options)
+  };
+}
 
 // src/handlers/oauth-html.ts
 function htmlCallbackResponse(title, message, status, options = {}) {
@@ -1994,7 +1976,7 @@ async function resumeAuthorizedMcpTurn(args) {
     messageTs: getTurnUserSlackMessageTs(userMessage),
     lockKey: threadId,
     initialText: "",
-    agentRunner,
+    executeTurn: async (run, saveResult, timeoutMs) => await executeTurn(agentRunner, run, saveResult, timeoutMs),
     beforeStart: async () => {
       const lockedState = await getPersistedThreadState(threadId);
       const lockedConversation = coerceThreadConversationState(lockedState);
@@ -2093,7 +2075,7 @@ async function resumeAuthorizedMcpTurn(args) {
         sliceId: lockedSessionRecord.sliceId,
         messageTs: lockedMessageTs,
         inputMessageIds: [lockedUserMessage.id],
-        replyContext: {
+        run: {
           instruction: {
             text: lockedUserMessage.text,
             context: lockedConversationContext,
@@ -2650,7 +2632,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
     messageTs: getTurnUserSlackMessageTs(userMessage),
     lockKey: stored.resumeConversationId,
     initialText: "",
-    agentRunner: options.agentRunner,
+    executeTurn: async (run, saveResult, timeoutMs) => await executeTurn(options.agentRunner, run, saveResult, timeoutMs),
     beforeStart: async () => {
       const lockedState = await getPersistedThreadState(
         stored.resumeConversationId
@@ -2753,7 +2735,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         sliceId: lockedSessionRecord.sliceId,
         messageTs: lockedMessageTs,
         inputMessageIds: [lockedUserMessage.id],
-        replyContext: {
+        run: {
           instruction: {
             text: lockedUserMessage.text,
             context: lockedConversationContext,
@@ -3255,11 +3237,12 @@ export {
   getAssistantThreadContext,
   getMessageTs,
   shouldKeepProcessingReactionForToolInvocation,
-  startSlackProcessingReaction,
+  startProcessingReaction,
   buildAuthPauseResponse,
   resumeSlackTurn,
   getPausedTurnRequest,
   wakePausedTurn,
+  createPausedTurns,
   GET,
   publishAppHomeView,
   GET2,