@sentry/junior 0.183.0 → 0.185.0

package/dist/{chunk-T5MTGX2E.js → chunk-X2SS6BF7.js}

@@ -4,7 +4,11 @@ import {
 import {
   buildSentryConversationUrl,
   deleteWebAuthorization
-} from "./chunk-4WGFWHWP.js";
+} from "./chunk-UUULGCKK.js";
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-W7GCLNIV.js";
 import {
   buildDeliveredTurnStatePatch,
   finalizeFailedTurnReplyWithEvent,
@@ -15,14 +19,14 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-WOKJRLM2.js";
+} from "./chunk-DAPC2HTM.js";
 import {
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-W5JMPEBO.js";
+} from "./chunk-FFHXG2FX.js";
 import {
   ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+} from "./chunk-6Q7YZLCL.js";
 import {
   coerceThreadConversationState,
   configValueSchema,
@@ -30,7 +34,7 @@ import {
   getPersistedSandboxState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-PLZT45VC.js";
+} from "./chunk-Y5G23T2D.js";
 import {
   createUserTokenStore,
   deleteMcpAuthSession,
@@ -39,12 +43,8 @@ import {
   getMcpProviderErrorAttributes,
   getMcpStoredOAuthCredentials,
   lookupSlackUserProfile,
-  resolvePluginOAuthAccount,
-  runAgentWithTimeout
-} from "./chunk-2EPYYVJC.js";
-import {
-  RetryableDeliveryError
-} from "./chunk-RF6J3DIO.js";
+  resolvePluginOAuthAccount
+} from "./chunk-4HA36IWS.js";
 import {
   addReactionToMessage,
   escapeSlackMrkdwnText,
@@ -57,17 +57,20 @@ import {
   removeReactionFromMessage,
   resolveBaseUrl,
   truncateStatusText
-} from "./chunk-QI5JW5AG.js";
+} from "./chunk-ZKKGFUWM.js";
 import {
   parseSlackThreadId,
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-SQHFVIMZ.js";
+} from "./chunk-X7NCJQAA.js";
+import {
+  RetryableDeliveryError
+} from "./chunk-INQHUE72.js";
 import {
   ensureConversationWake,
   requestConversationWork
-} from "./chunk-HUK5XIZL.js";
+} from "./chunk-D63IUQQE.js";
 import {
   CooperativeTurnYieldError,
   clearPendingAuth,
@@ -76,7 +79,7 @@ import {
   isCooperativeTurnYieldError,
   isPendingAuthLatestRequest,
   markTurnFailed
-} from "./chunk-56XONJPF.js";
+} from "./chunk-U4CTAVWN.js";
 import {
   TurnSliceLimitExceededError,
   abandonTurnRecord,
@@ -96,13 +99,13 @@ import {
   recordTurnSummary,
   saveTurnCheckpoint,
   turnHasReply
-} from "./chunk-24OJZ5OU.js";
+} from "./chunk-WLKWN4CD.js";
 import {
   getVercelConversationWorkQueue
 } from "./chunk-DKIJ2RP5.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-FJMTMGBC.js";
+} from "./chunk-FTVMXDNN.js";
 import {
   SlackActionError,
   getDashboardConversationLink,
@@ -111,37 +114,39 @@ import {
   getSlackClient,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-AHMWPFIW.js";
+} from "./chunk-VH4IU3UC.js";
 import {
   getConversationEventStore,
   getSqlExecutor,
   requireSlackDestination,
   upsertIdentity,
   upsertLinkedIdentity
-} from "./chunk-AX3UDIMA.js";
+} from "./chunk-ABAX75GG.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-G2B2XZQW.js";
+} from "./chunk-PNYJOEVV.js";
 import {
   botConfig,
-  defaultModelId,
   escapeXml,
   getChatConfig,
   getRuntimeMetadata,
   normalizeSlackEmojiName
-} from "./chunk-LMNMMESF.js";
+} from "./chunk-LRI5IRGY.js";
+import {
+  defaultModelId
+} from "./chunk-D4YV5TDV.js";
 import {
   discoverSkills
-} from "./chunk-KTXOGLNE.js";
+} from "./chunk-ATUWN6Z3.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-E3OBGRHN.js";
+} from "./chunk-GJTIZQGJ.js";
 import {
   buildOAuthTokenRequest,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse
-} from "./chunk-EENQGEIP.js";
+} from "./chunk-7MHNIGHP.js";
 import {
   createSlackResumeActor,
   isUserActor,
@@ -160,7 +165,7 @@ import {
   setTags,
   toOptionalString,
   withLogContext
-} from "./chunk-LZBPGX5A.js";
+} from "./chunk-OMQ2J6F6.js";
 
 // src/chat/slack/assistant-thread/status-render.ts
 var DEFAULT_STATUS_CONTEXTS = {
@@ -789,6 +794,7 @@ async function sendSlackReply(args) {
     replyAttribution: args.replyAttribution
   });
   const messageTs = [];
+  let threadTs = args.threadTs;
   for (const [index, text] of chunks.entries()) {
     const isFinalChunk = index === chunks.length - 1;
     const blocks = buildSlackReplyBlocks(
@@ -800,12 +806,13 @@ async function sendSlackReply(args) {
 ${escapeSlackMrkdwnText(formatReplyAttribution(args.replyAttribution))}` : text;
     const response = await postSlackMessage({
       channelId: args.channelId,
-      threadTs: args.threadTs,
+      threadTs,
       text: fallbackText,
       ...blocks ? { blocks } : void 0
     });
     if (response.ts) {
       messageTs.push(response.ts);
+      threadTs ??= response.ts;
     }
   }
   return messageTs;
@@ -968,7 +975,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,
@@ -980,7 +987,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;
   }
@@ -989,13 +996,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,
@@ -1003,7 +1009,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)
@@ -1023,7 +1029,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)
@@ -1045,7 +1051,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)
@@ -1084,11 +1090,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;
@@ -1128,7 +1131,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)),
@@ -1146,7 +1149,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";
   }
 };
@@ -1154,7 +1157,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,
@@ -1177,7 +1180,7 @@ async function handleResumeFailure(args) {
   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,
@@ -1186,8 +1189,8 @@ async function handleResumeFailure(args) {
     );
     try {
       await args.turnLifecycle.fail({
-        conversationId: args.resumeArgs.conversationId,
-        turnId: args.resumeArgs.turnId,
+        conversationId: args.resume.conversationId,
+        turnId: args.resume.turnId,
         createdAtMs: Date.now(),
         failureCode: "persistence_failed",
         ...persistEventId ? { eventId: persistEventId } : void 0
@@ -1203,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
     });
@@ -1216,8 +1219,8 @@ async function handleResumeFailure(args) {
     );
     try {
       await args.turnLifecycle.fail({
-        conversationId: args.resumeArgs.conversationId,
-        turnId: args.resumeArgs.turnId,
+        conversationId: args.resume.conversationId,
+        turnId: args.resume.turnId,
         createdAtMs: Date.now(),
         failureCode: "delivery_failed",
         ...deliveryEventId ? { eventId: deliveryEventId } : void 0
@@ -1235,35 +1238,35 @@ async function handleResumeFailure(args) {
     throw failureStatePersistError;
   }
   await args.turnLifecycle.fail({
-    conversationId: args.resumeArgs.conversationId,
-    turnId: args.resumeArgs.turnId,
+    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" ? {
@@ -1271,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) => {
@@ -1284,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);
       }
     }
   };
@@ -1319,8 +1322,11 @@ 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 = new ConversationTurnLifecycleService(
+    getConversationEventStore()
+  );
   let failureCode = "agent_run_failed";
   let runArgs = args;
   try {
@@ -1332,36 +1338,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) {
@@ -1415,11 +1418,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
           });
@@ -1446,7 +1449,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({
@@ -1454,7 +1457,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",
@@ -1473,22 +1476,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) {
@@ -1502,11 +1504,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,
@@ -1516,10 +1514,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") {
@@ -1538,7 +1596,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) {
@@ -1548,124 +1606,51 @@ 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;
@@ -1680,13 +1665,11 @@ 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
         });
       };
     }
@@ -1727,19 +1710,17 @@ 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;
     }
@@ -1805,6 +1786,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 = {}) {
@@ -1992,7 +1982,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);
@@ -2091,7 +2081,7 @@ async function resumeAuthorizedMcpTurn(args) {
         sliceId: lockedSessionRecord.sliceId,
         messageTs: lockedMessageTs,
         inputMessageIds: [lockedUserMessage.id],
-        replyContext: {
+        run: {
           instruction: {
             text: lockedUserMessage.text,
             context: lockedConversationContext,
@@ -2648,7 +2638,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
@@ -2751,7 +2741,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         sliceId: lockedSessionRecord.sliceId,
         messageTs: lockedMessageTs,
         inputMessageIds: [lockedUserMessage.id],
-        replyContext: {
+        run: {
           instruction: {
             text: lockedUserMessage.text,
             context: lockedConversationContext,
@@ -3253,11 +3243,12 @@ export {
   getAssistantThreadContext,
   getMessageTs,
   shouldKeepProcessingReactionForToolInvocation,
-  startSlackProcessingReaction,
+  startProcessingReaction,
   buildAuthPauseResponse,
   resumeSlackTurn,
   getPausedTurnRequest,
   wakePausedTurn,
+  createPausedTurns,
   GET,
   publishAppHomeView,
   GET2,