@sentry/junior 0.89.0 → 0.91.0

package/dist/app.js

@@ -1,81 +1,23 @@
 import {
-  AuthorizationFlowDisabledError,
-  PluginCredentialFailureError,
-  SANDBOX_EGRESS_PROXY_PATH,
-  TurnInputCommitLostError,
-  TurnInputDeferredError,
-  addReactionToMessage,
-  appendSlackLegacyAttachmentText,
-  applyPendingAuthUpdate,
   buildConversationContext,
   buildDeliveredTurnStatePatch,
-  buildDeterministicTurnId,
-  buildSteeringPiMessage,
-  clearPendingAuth,
-  coerceThreadArtifactsState,
-  completeDeliveredTurn,
   createConversationMemoryService,
-  createUserTokenStore,
-  deleteMcpAuthSession,
-  deliverResourceEventSubscription,
   estimateTextTokens,
-  executeCredentialedEgressRequest,
   finalizeFailedTurnReply,
-  finalizeMcpAuthorization,
-  findMatchingResourceEventSubscriptions,
-  formatProviderLabel,
-  generateAssistantReply,
   generateConversationId,
   getAgentContextCompactionTriggerTokens,
   getAgentTurnDiagnosticsAttributes,
-  getChannelConfigurationService,
-  getChannelConfigurationServiceById,
-  getConfigDefaults,
   getConversationMessageSlackTs,
-  getConversationPendingAuth,
-  getMcpStoredOAuthCredentials,
-  getPersistedSandboxState,
-  getPersistedThreadState,
   getThreadTitleSourceMessage,
-  isAuthResumeRetryableTurnError,
-  isCooperativeTurnYieldError,
   isHumanConversationMessage,
-  isPendingAuthLatestRequest,
-  isRetryableTurnError,
-  isTurnInputCommitLostError,
-  isTurnInputDeferredError,
-  listThreadReplies,
   markConversationMessage,
-  markTurnClosed,
-  markTurnFailed,
-  mergeArtifactsState,
   normalizeConversationText,
-  normalizeSandboxEgressTracePropagationDomains,
-  parseOAuthStatePayload,
-  parseSandboxEgressCredentialToken,
-  persistCompletedSessionRecord,
-  persistThreadState,
-  persistThreadStateById,
-  persistYieldSessionRecord,
-  postSlackMessage,
   processPluginTask,
-  removeReactionFromMessage,
-  renderSlackLegacyAttachmentText,
   requireTurnFailureEventId,
-  resolveBaseUrl,
-  resolvePluginOAuthAccount,
-  resolveSandboxEgressProviderForHost,
   scheduleSessionCompletedPluginTasks,
-  setConfigDefaults,
-  shouldEmitDevAgentTrace,
-  shouldPropagateSandboxEgressTrace,
-  startActiveTurn,
-  startOAuthFlow,
-  unlinkProvider,
   updateConversationStats,
-  uploadFilesToThread,
   upsertConversationMessage
-} from "./chunk-NYJLQI42.js";
+} from "./chunk-AOISHLSF.js";
 import {
   CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
@@ -99,17 +41,12 @@ import {
   requestConversationContinuation,
   requestConversationWork,
   startConversationWork
-} from "./chunk-2DPZRS3B.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS,
-  coerceThreadConversationState
-} from "./chunk-66NX7MNW.js";
-import "./chunk-V6XDCS3X.js";
+} from "./chunk-IX76WFJV.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-F22AM3OW.js";
+} from "./chunk-NYWPISSO.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -123,25 +60,11 @@ import {
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   setConversationTitle
-} from "./chunk-6UPQ5GTJ.js";
-import {
-  abandonAgentTurnSessionRecord,
-  buildSlackOutputMessage,
-  commitMessages,
-  failAgentTurnSessionRecord,
-  getAgentTurnSessionRecord,
-  listAgentTurnSessionSummariesForConversation,
-  loadProjection,
-  normalizeSlackStatusText,
-  recordAgentTurnSessionSummary,
-  recordAuthorizationCompleted,
-  splitSlackReplyText,
-  truncateStatusText
-} from "./chunk-KBSLCOGE.js";
+} from "./chunk-QCKGI74V.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-C5NCV3OB.js";
+} from "./chunk-TYUXD3FN.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -149,51 +72,128 @@ import {
   pluginRuntimeRegistrationsFromPluginSet
 } from "./chunk-SG5WAA7H.js";
 import {
+  AuthorizationFlowDisabledError,
+  PluginCredentialFailureError,
+  SANDBOX_EGRESS_PROXY_PATH,
+  addReactionToMessage,
+  appendSlackLegacyAttachmentText,
+  buildSteeringPiMessage,
+  createAgentRunner,
+  createUserTokenStore,
+  deleteMcpAuthSession,
+  deliverResourceEventSubscription,
+  executeAgentRun,
+  executeCredentialedEgressRequest,
+  finalizeMcpAuthorization,
+  findMatchingResourceEventSubscriptions,
+  formatProviderLabel,
+  getConfigDefaults,
+  getMcpStoredOAuthCredentials,
+  listThreadReplies,
+  normalizeSandboxEgressTracePropagationDomains,
+  parseOAuthStatePayload,
+  parseSandboxEgressCredentialToken,
+  postSlackMessage,
+  removeReactionFromMessage,
+  renderSlackLegacyAttachmentText,
+  resolveBaseUrl,
+  resolvePluginOAuthAccount,
+  resolveSandboxEgressProviderForHost,
+  setConfigDefaults,
+  shouldEmitDevAgentTrace,
+  shouldPropagateSandboxEgressTrace,
+  startOAuthFlow,
+  unlinkProvider
+} from "./chunk-ZGDTBSQ7.js";
+import {
+  CooperativeTurnYieldError,
+  TurnInputCommitLostError,
+  TurnInputDeferredError,
+  applyPendingAuthUpdate,
+  buildDeterministicTurnId,
+  clearPendingAuth,
+  coerceThreadArtifactsState,
+  completeDeliveredTurn,
+  getChannelConfigurationService,
+  getChannelConfigurationServiceById,
+  getConversationPendingAuth,
+  getPersistedSandboxState,
+  getPersistedThreadState,
+  isCooperativeTurnYieldError,
+  isPendingAuthLatestRequest,
+  isTurnInputCommitLostError,
+  isTurnInputDeferredError,
+  markTurnClosed,
+  markTurnFailed,
+  mergeArtifactsState,
+  persistCompletedSessionRecord,
+  persistThreadState,
+  persistThreadStateById,
+  persistYieldSessionRecord,
+  startActiveTurn
+} from "./chunk-ONFOWI2D.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
+  coerceThreadConversationState
+} from "./chunk-KC42JAAQ.js";
+import "./chunk-5GBUZI6M.js";
+import {
+  buildSlackOutputMessage,
+  escapeSlackMrkdwnText,
+  formatSlackLink,
+  normalizeSlackStatusText,
+  splitSlackReplyText,
+  truncateStatusText,
+  unwrapCurrentInstruction
+} from "./chunk-PIB4EOW6.js";
+import {
+  abandonAgentTurnSessionRecord,
+  commitMessages,
+  escapeXml,
+  failAgentTurnSessionRecord,
+  getAgentTurnSessionRecord,
+  listAgentTurnSessionSummariesForConversation,
+  loadProjection,
+  recordAgentTurnSessionSummary,
+  recordAuthorizationCompleted
+} from "./chunk-GCWD2VHP.js";
+import {
+  SlackActionError,
   bindSlackDirectCredentialSubject,
+  downloadPrivateSlackFile,
+  getHeaderString,
   getPluginApiRoutes,
   getPluginRoutes,
   getPluginSlackConversationLink,
   getPlugins,
-  parseSlackMessageTs,
+  getSlackClient,
+  getWorkspaceTeamId,
+  isDmChannel,
+  normalizeSlackConversationId,
+  runWithSlackInstallationToken,
+  runWithWorkspaceTeamId,
   setPlugins,
   validatePlugins,
   verifySlackDirectCredentialSubject
-} from "./chunk-XS6NLQPA.js";
+} from "./chunk-DACFZ5CI.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-IATAYWFU.js";
+} from "./chunk-NW7AXDA5.js";
 import "./chunk-G3E7SCME.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-YPAE5RH3.js";
+} from "./chunk-RS6ANWVT.js";
 import {
   getConversationStore,
   getDb
-} from "./chunk-4IXHIV37.js";
-import {
-  SlackActionError,
-  createSlackDestination,
-  destinationKey,
-  downloadPrivateSlackFile,
-  getHeaderString,
-  getSlackClient,
-  getWorkspaceTeamId,
-  isDmChannel,
-  normalizeSlackConversationId,
-  parseDestination,
-  requireSlackDestination,
-  runWithSlackInstallationToken,
-  runWithWorkspaceTeamId,
-  sameDestination
-} from "./chunk-AHLSXMOU.js";
+} from "./chunk-2S7M37HY.js";
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   botConfig,
   completeObject,
   completeText,
-  escapeXml,
   getChatConfig,
   getRuntimeMetadata,
   getSlackBotToken,
@@ -205,57 +205,66 @@ import {
   normalizeSlackEmojiName,
   setSlackReactionConfig,
   stripRuntimeTurnContext,
-  trimTrailingAssistantMessages,
-  unwrapCurrentInstruction
-} from "./chunk-S35CPNPT.js";
+  trimTrailingAssistantMessages
+} from "./chunk-HXL2ZV74.js";
 import {
   parseSlackThreadId,
+  readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-L7OHKDOX.js";
+} from "./chunk-3MPOMK3K.js";
+import {
+  createSlackDestination,
+  destinationKey,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination
+} from "./chunk-GHGPTPBL.js";
 import {
   discoverSkills
-} from "./chunk-7ES37H6U.js";
+} from "./chunk-AN2437E3.js";
 import {
   buildOAuthTokenRequest,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse,
   pluginCatalogRuntime
-} from "./chunk-KBFQXJL4.js";
-import {
-  createRequester,
-  createSlackRequester,
-  createSlackResumeRequester,
-  isActorUserId,
-  parseActorUserId,
-  toStoredSlackRequester
-} from "./chunk-KQKIA4CU.js";
-import {
-  homeDir
-} from "./chunk-6APU57E6.js";
+} from "./chunk-XP7F4LYB.js";
 import {
   buildTurnFailureResponse,
   createChatSdkLogger,
   createRequestContext,
+  createRequester,
+  createSlackRequester,
+  createSlackResumeRequester,
   getActiveTraceId,
+  isActorUserId,
   logError,
   logException,
   logInfo,
   logWarn,
+  parseActorUserId,
   setSentryUser,
   setSpanAttributes,
   setSpanStatus,
   setTags,
+  toStoredSlackRequester,
   withContext,
   withSpan
-} from "./chunk-VMBZFPZM.js";
+} from "./chunk-ZUK7BL63.js";
 import {
-  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE,
   toOptionalString
-} from "./chunk-FTMXFBDC.js";
+} from "./chunk-OB42YVAE.js";
 import {
   continueTrace
 } from "./chunk-3DA7X2U3.js";
+import {
+  homeDir
+} from "./chunk-6APU57E6.js";
+import {
+  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE,
+  parseSlackChannelId,
+  parseSlackMessageTs
+} from "./chunk-LFLTJQVR.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -313,16 +322,7 @@ function getDashboardConversationLink(conversationId) {
   return `${baseURL}${path2}`;
 }
 
-// src/chat/slack/reply.ts
-import { Buffer as Buffer2 } from "buffer";
-
 // src/chat/slack/footer.ts
-function escapeSlackMrkdwn(text) {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-function escapeSlackLinkUrl(url) {
-  return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
-}
 function buildSlackReplyFooter(args) {
   const items = [];
   const conversationId = args.conversationId?.trim();
@@ -354,7 +354,7 @@ function buildSlackReplyBlocks(text, footer) {
       type: "context",
       elements: footer.items.map((item) => ({
         type: "mrkdwn",
-        text: item.url ? `*${escapeSlackMrkdwn(item.label)}:* <${escapeSlackLinkUrl(item.url)}|${escapeSlackMrkdwn(item.value)}>` : `*${escapeSlackMrkdwn(item.label)}:* ${escapeSlackMrkdwn(item.value)}`
+        text: item.url ? `*${escapeSlackMrkdwnText(item.label)}:* ${formatSlackLink(item.url, item.value)}` : `*${escapeSlackMrkdwnText(item.label)}:* ${escapeSlackMrkdwnText(item.value)}`
       }))
     });
   }
@@ -362,17 +362,12 @@ function buildSlackReplyBlocks(text, footer) {
 }
 
 // src/chat/slack/reply.ts
-function resolveReplyDelivery(reply) {
-  const replyHasFiles = Boolean(reply.files && reply.files.length > 0);
+function shouldPostThreadReply(reply) {
   const deliveryPlan = reply.deliveryPlan ?? {
     mode: reply.deliveryMode ?? "thread",
-    postThreadText: (reply.deliveryMode ?? "thread") !== "channel_only",
-    attachFiles: replyHasFiles ? "inline" : "none"
-  };
-  return {
-    shouldPostThreadReply: deliveryPlan.postThreadText,
-    attachFiles: replyHasFiles && deliveryPlan.attachFiles !== "none" ? "inline" : "none"
+    postThreadText: (reply.deliveryMode ?? "thread") !== "channel_only"
   };
+  return deliveryPlan.postThreadText;
 }
 function buildReplyText(text) {
   const message = buildSlackOutputMessage(text);
@@ -388,28 +383,9 @@ function buildTextPosts(args) {
   const chunks = splitSlackReplyText(args.text);
   return chunks.map((chunk, index) => ({
     text: chunk,
-    ...index === 0 && args.firstFiles ? { files: args.firstFiles } : {},
     stage: index === 0 ? args.firstStage ?? "thread_reply" : "thread_reply_continuation"
   }));
 }
-async function normalizeFileUploads(files) {
-  return await Promise.all(
-    files.map(async (file) => {
-      let data;
-      if (Buffer2.isBuffer(file.data)) {
-        data = file.data;
-      } else if (file.data instanceof ArrayBuffer) {
-        data = Buffer2.from(file.data);
-      } else {
-        data = Buffer2.from(await file.data.arrayBuffer());
-      }
-      return {
-        data,
-        filename: file.filename
-      };
-    })
-  );
-}
 function findLastTextPostIndex(posts) {
   for (let index = posts.length - 1; index >= 0; index -= 1) {
     if (posts[index]?.text.trim().length) {
@@ -418,56 +394,25 @@ function findLastTextPostIndex(posts) {
   }
   return -1;
 }
-async function uploadReplyFiles(args) {
-  try {
-    await uploadFilesToThread({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      files: await normalizeFileUploads(args.files)
-    });
-  } catch (error) {
-    if (args.failureMode === "strict") {
-      throw error;
-    }
-  }
-}
 function planSlackReplyPosts(args) {
-  const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
-  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery(
-    args.reply
-  );
   const posts = [];
-  const textPosts = shouldPostThreadReply ? buildTextPosts({
-    text: args.reply.text,
-    firstFiles: attachFiles === "inline" ? replyFiles : void 0
+  const textPosts = shouldPostThreadReply(args.reply) ? buildTextPosts({
+    text: args.reply.text
   }) : [];
   posts.push(...textPosts);
-  if (attachFiles === "inline" && replyFiles && textPosts.length === 0) {
-    posts.push({
-      files: replyFiles,
-      stage: "thread_reply",
-      text: ""
-    });
-  } else if (shouldPostThreadReply && textPosts.length === 0) {
+  if (shouldPostThreadReply(args.reply) && textPosts.length === 0) {
     posts.push({
       text: buildReplyText(args.reply.text),
       stage: "thread_reply"
     });
   }
-  if (attachFiles === "followup" && replyFiles) {
-    posts.push({
-      files: replyFiles,
-      stage: "thread_reply_files_followup",
-      text: ""
-    });
-  }
   return posts;
 }
 async function postSlackApiReplyPosts(args) {
   const lastTextPostIndex = findLastTextPostIndex(args.posts);
   let lastPostedMessageTs;
   for (const [index, post] of args.posts.entries()) {
-    const hasVisibleDelivery = post.text.trim().length > 0 || post.files?.length;
+    const hasVisibleDelivery = post.text.trim().length > 0;
     if (hasVisibleDelivery) {
       await args.beforePost?.();
     }
@@ -485,18 +430,7 @@ async function postSlackApiReplyPosts(args) {
         messageTs = response.ts;
         lastPostedMessageTs = response.ts;
       }
-      if (!post.files?.length) {
-        continue;
-      }
-      if (!args.threadTs && !lastPostedMessageTs) {
-        throw new Error("Slack file delivery requires a posted message thread");
-      }
-      await uploadReplyFiles({
-        channelId: args.channelId,
-        failureMode: args.fileUploadFailureMode ?? "best_effort",
-        threadTs: args.threadTs ?? lastPostedMessageTs,
-        files: post.files
-      });
+      continue;
     } catch (error) {
       await args.onPostError?.({
         error,
@@ -892,13 +826,19 @@ function getAssistantMessageId(dispatch) {
 function buildDispatchConversationText(dispatch) {
   return `[dispatched task] ${dispatch.input}`;
 }
+function shouldPostDispatchReplyText(reply) {
+  return reply.deliveryPlan?.postThreadText ?? (reply.deliveryMode ?? "thread") !== "channel_only";
+}
 function ensureVisibleDeliveryText(reply) {
-  if (reply.text.trim().length > 0 || !reply.files?.length) {
+  if (!shouldPostDispatchReplyText(reply)) {
+    return reply;
+  }
+  if (reply.text.trim().length > 0) {
     return reply;
   }
   return {
     ...reply,
-    text: "Generated files are attached."
+    text: "The task completed without a visible response."
   };
 }
 function upsertDispatchUserMessage(args) {
@@ -954,8 +894,7 @@ function canClaimDispatch(record, nowMs) {
   }
   return true;
 }
-async function runAgentDispatchSlice(callback, deps = {}) {
-  const generateAssistantReply2 = deps.generateAssistantReply ?? generateAssistantReply;
+async function runAgentDispatchSlice(callback, deps) {
   const scheduleCallback = deps.scheduleCallback ?? scheduleDispatchCallback;
   const scheduleCompletedTasks = deps.scheduleSessionCompletedPluginTasks ?? scheduleSessionCompletedPluginTasks;
   const nowMs = Date.now();
@@ -1051,61 +990,91 @@ async function runAgentDispatchSlice(callback, deps = {}) {
     const conversationContext = buildConversationContext(conversation, {
       excludeMessageId: userMessageId
     });
-    let reply = await generateAssistantReply2(dispatch.input, {
-      authorizationFlowMode: "disabled",
-      credentialContext: {
-        actor: dispatch.actor,
-        ...dispatch.credentialSubject ? { subject: dispatch.credentialSubject } : {}
+    const outcome = await deps.agentRunner.run({
+      input: {
+        messageText: dispatch.input,
+        conversationContext,
+        piMessages: conversation.piMessages
       },
-      configuration,
-      channelConfiguration,
-      conversationContext,
-      artifactState: artifacts,
-      piMessages: conversation.piMessages,
-      destination: dispatch.destination,
-      source: dispatch.source,
-      dispatch: {
-        actor: dispatch.actor,
-        metadata: dispatch.metadata,
-        plugin: dispatch.plugin
-      },
-      correlation: {
-        conversationId,
-        threadId: conversationId,
-        turnId,
-        runId: dispatch.id,
-        channelId: dispatch.destination.channelId,
-        teamId: dispatch.destination.teamId
+      routing: {
+        credentialContext: {
+          actor: dispatch.actor,
+          ...dispatch.credentialSubject ? { subject: dispatch.credentialSubject } : {}
+        },
+        destination: dispatch.destination,
+        source: dispatch.source,
+        dispatch: {
+          actor: dispatch.actor,
+          metadata: dispatch.metadata,
+          plugin: dispatch.plugin
+        },
+        correlation: {
+          conversationId,
+          threadId: conversationId,
+          turnId,
+          runId: dispatch.id,
+          channelId: dispatch.destination.channelId,
+          teamId: dispatch.destination.teamId
+        },
+        surface: "api",
+        toolChannelId: dispatch.destination.channelId
       },
-      surface: "api",
-      toolChannelId: dispatch.destination.channelId,
-      sandbox: {
-        sandboxId,
-        sandboxDependencyProfileHash,
-        tracePropagation: deps.tracePropagation
+      policy: {
+        authorizationFlowMode: "disabled",
+        configuration,
+        channelConfiguration
       },
-      onSandboxAcquired: async (sandbox) => {
-        sandboxId = sandbox.sandboxId;
-        sandboxDependencyProfileHash = sandbox.sandboxDependencyProfileHash;
-        await persistRuntimePatch({
-          threadId: conversationId,
-          conversation,
-          artifacts,
+      state: {
+        artifactState: artifacts,
+        sandbox: {
           sandboxId,
           sandboxDependencyProfileHash
-        });
+        }
       },
-      onArtifactStateUpdated: async (nextArtifacts2) => {
-        artifacts = nextArtifacts2;
-        await persistRuntimePatch({
-          threadId: conversationId,
-          conversation,
-          artifacts,
-          sandboxId,
-          sandboxDependencyProfileHash
-        });
+      durability: {
+        onSandboxAcquired: async (sandbox) => {
+          sandboxId = sandbox.sandboxId;
+          sandboxDependencyProfileHash = sandbox.sandboxDependencyProfileHash;
+          await persistRuntimePatch({
+            threadId: conversationId,
+            conversation,
+            artifacts,
+            sandboxId,
+            sandboxDependencyProfileHash
+          });
+        },
+        onArtifactStateUpdated: async (nextArtifacts2) => {
+          artifacts = nextArtifacts2;
+          await persistRuntimePatch({
+            threadId: conversationId,
+            conversation,
+            artifacts,
+            sandboxId,
+            sandboxDependencyProfileHash
+          });
+        }
       }
     });
+    if (outcome.status === "awaiting_auth") {
+      await markDispatch({
+        dispatch,
+        status: "blocked",
+        errorMessage: "Dispatch requires authorization from an interactive user turn."
+      });
+      return;
+    }
+    if (outcome.status === "suspended") {
+      const awaiting = await markDispatch({
+        dispatch,
+        status: "awaiting_resume"
+      });
+      await scheduleCallback({
+        id: awaiting.id,
+        expectedVersion: awaiting.version
+      });
+      return;
+    }
+    let reply = outcome.result;
     const failure = reply.diagnostics.outcome === "success" ? void 0 : reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.`;
     if (failure) {
       reply = finalizeFailedTurnReply({
@@ -1123,8 +1092,7 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       posts: planSlackReplyPosts({ reply: deliveryReply }),
       footer: buildSlackReplyFooter({
         conversationId
-      }),
-      fileUploadFailureMode: "strict"
+      })
     });
     markConversationMessage(conversation, userMessageId, {
       replied: true,
@@ -1224,28 +1192,6 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       });
       return;
     }
-    if (isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) {
-      await markDispatch({
-        dispatch,
-        status: "blocked",
-        errorMessage: "Dispatch requires authorization from an interactive user turn."
-      });
-      return;
-    }
-    if (isRetryableTurnError(error, "agent_continue")) {
-      const version = error.metadata?.version;
-      if (typeof version === "number") {
-        const awaiting = await markDispatch({
-          dispatch,
-          status: "awaiting_resume"
-        });
-        await scheduleCallback({
-          id: awaiting.id,
-          expectedVersion: awaiting.version
-        });
-        return;
-      }
-    }
     logException(
       error,
       "agent_dispatch_run_failed",
@@ -1267,14 +1213,14 @@ async function runAgentDispatchSlice(callback, deps = {}) {
 }
 
 // src/handlers/agent-dispatch.ts
-async function POST(request, waitUntil, options = {}) {
+async function POST(request, waitUntil, options) {
   const payload = await verifyDispatchCallbackRequest(request);
   if (!payload) {
     return new Response("Unauthorized", { status: 401 });
   }
   waitUntil(
     () => runAgentDispatchSlice(payload, {
-      tracePropagation: options.tracePropagation
+      agentRunner: options.agentRunner
     }).catch((error) => {
       logException(
         error,
@@ -3529,6 +3475,12 @@ function isSlackTitlePermissionError(error) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function readObjectField(value, key) {
+  return value[key];
+}
+function readOptionalStringField(value, key) {
+  return toOptionalString(readObjectField(value, key));
+}
 function stripLeadingBotMention(text, options = {}) {
   if (!text.trim()) return text;
   let next = text;
@@ -3560,7 +3512,7 @@ function getThreadId(thread, _message) {
   return toOptionalString(thread.id);
 }
 function getRunId(thread, message) {
-  return toOptionalString(thread.runId) ?? toOptionalString(message.runId);
+  return readOptionalStringField(thread, "runId") ?? readOptionalStringField(message, "runId");
 }
 function getChannelId(thread, message) {
   return resolveSlackChannelIdFromThreadId(toOptionalString(thread.id)) ?? normalizeSlackConversationId(toOptionalString(thread.channelId)) ?? resolveSlackChannelIdFromMessage(message);
@@ -3569,18 +3521,16 @@ function getThreadTs(threadId) {
   return parseSlackThreadId(threadId)?.threadTs;
 }
 function getAssistantThreadContext(message) {
-  const raw = message.raw;
-  const rawRecord = raw && typeof raw === "object" ? raw : void 0;
-  const channelId = toOptionalString(rawRecord?.channel);
+  const rawContext = readSlackRawMessageContext(message);
+  const channelId = rawContext?.channelId;
   if (channelId) {
-    const rawThreadTs = toOptionalString(rawRecord?.thread_ts);
-    const threadTs = isDmChannel(channelId) ? rawThreadTs : rawThreadTs ?? toOptionalString(rawRecord?.ts);
+    const threadTs = isDmChannel(channelId) ? rawContext.threadTs : rawContext.threadTs ?? rawContext.messageTs;
     if (threadTs) {
       return { channelId, threadTs };
     }
   }
   const parsedThreadId = parseSlackThreadId(
-    toOptionalString(message.threadId)
+    readOptionalStringField(message, "threadId")
   );
   if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
     return void 0;
@@ -3588,22 +3538,16 @@ function getAssistantThreadContext(message) {
   return parsedThreadId;
 }
 function getMessageTs(message) {
-  const directTs = toOptionalString(
-    message.ts
-  );
+  const directTs = readOptionalStringField(message, "ts");
   const parsedDirectTs = parseSlackMessageTs(directTs);
   if (parsedDirectTs) {
     return parsedDirectTs;
   }
-  const raw = message.raw;
-  if (!raw || typeof raw !== "object") {
+  const rawContext = readSlackRawMessageContext(message);
+  if (!rawContext) {
     return void 0;
   }
-  const rawRecord = raw;
-  const candidates = [
-    rawRecord.ts,
-    rawRecord.message?.ts
-  ];
+  const candidates = [rawContext.messageTs, rawContext.nestedMessageTs];
   for (const candidate of candidates) {
     const ts = parseSlackMessageTs(candidate);
     if (ts) {
@@ -3623,7 +3567,7 @@ function isProcessingReactionEmoji(value) {
   return typeof value === "string" && normalizeSlackEmojiName(value) === getChatConfig().slack.processingReactionEmoji;
 }
 function shouldKeepProcessingReactionForToolInvocation(input) {
-  return input.toolName === "slackMessageAddReaction" && isProcessingReactionEmoji(input.params.emoji);
+  return input.toolName === "addReaction" && isProcessingReactionEmoji(input.params.emoji);
 }
 async function startSlackProcessingReaction(args) {
   if (args.message.author.isMe) {
@@ -3824,19 +3768,20 @@ function getDefaultLockKey(channelId, threadTs) {
   return `slack:${channelId}:${threadTs}`;
 }
 function getResumeLogContext(args, lockKey) {
+  const routing = args.replyContext?.routing;
   return {
-    conversationId: args.replyContext?.correlation?.conversationId ?? lockKey,
-    slackThreadId: args.replyContext?.correlation?.threadId ?? lockKey,
-    slackUserId: args.replyContext?.requester?.userId ?? args.replyContext?.correlation?.requesterId,
-    slackUserName: args.replyContext?.requester?.userName,
+    conversationId: routing?.correlation?.conversationId ?? lockKey,
+    slackThreadId: routing?.correlation?.threadId ?? lockKey,
+    slackUserId: routing?.requester?.userId ?? routing?.correlation?.requesterId,
+    slackUserName: routing?.requester?.userName,
     slackChannelId: args.channelId,
-    runId: args.replyContext?.correlation?.runId,
+    runId: routing?.correlation?.runId,
     assistantUserName: botConfig.userName,
     modelId: botConfig.modelId
   };
 }
 function getResumeConversationId(args, lockKey) {
-  return args.replyContext?.correlation?.conversationId ?? lockKey;
+  return args.replyContext?.routing.correlation?.conversationId ?? lockKey;
 }
 async function postResumeFailureReply(args) {
   try {
@@ -3881,42 +3826,58 @@ function createResumeReplyContext(args, statusSession) {
   if (!replyContext) {
     throw new TypeError("Slack resume requires a reply context");
   }
-  if (!replyContext.source) {
+  if (!replyContext.routing.source) {
     throw new TypeError("Slack resume requires a reply context source");
   }
-  const source = replyContext.source;
-  if (replyContext.destination.platform !== "slack") {
+  const source = replyContext.routing.source;
+  if (replyContext.routing.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 persistedChannelConfiguration = replyContext.channelConfiguration ?? (replyContext.configuration ? createReadOnlyConfigService(replyContext.configuration) : void 0);
+  const persistedChannelConfiguration = replyContext.policy?.channelConfiguration ?? (replyContext.policy?.configuration ? createReadOnlyConfigService(replyContext.policy.configuration) : void 0);
   return {
-    ...replyContext,
-    source,
-    turnDeadlineAtMs: replyContext.turnDeadlineAtMs ?? requestDeadline?.deadlineAtMs,
-    correlation: {
-      ...replyContext.correlation,
-      threadId: replyContext.correlation?.threadId ?? threadId,
-      channelId: replyContext.correlation?.channelId ?? args.channelId,
-      threadTs: replyContext.correlation?.threadTs ?? args.threadTs,
-      requesterId: replyContext.correlation?.requesterId ?? replyContext.requester?.userId
+    input: {
+      ...replyContext.input ?? {},
+      messageText: args.messageText
     },
-    channelConfiguration: persistedChannelConfiguration,
-    onSandboxAcquired: async (sandbox) => {
-      await persistThreadStateById(threadId, {
-        sandboxId: sandbox.sandboxId,
-        sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
-      });
-      await replyContext.onSandboxAcquired?.(sandbox);
+    routing: {
+      ...replyContext.routing,
+      source,
+      correlation: {
+        ...replyContext.routing.correlation,
+        threadId: replyContext.routing.correlation?.threadId ?? threadId,
+        channelId: replyContext.routing.correlation?.channelId ?? args.channelId,
+        threadTs: replyContext.routing.correlation?.threadTs ?? args.threadTs,
+        requesterId: replyContext.routing.correlation?.requesterId ?? replyContext.routing.requester?.userId
+      }
+    },
+    policy: {
+      ...replyContext.policy,
+      turnDeadlineAtMs: replyContext.policy?.turnDeadlineAtMs ?? requestDeadline?.deadlineAtMs,
+      channelConfiguration: persistedChannelConfiguration
     },
-    onArtifactStateUpdated: async (artifacts) => {
-      await persistThreadStateById(threadId, { artifacts });
-      await replyContext.onArtifactStateUpdated?.(artifacts);
+    state: replyContext.state,
+    observers: {
+      ...replyContext.observers,
+      onStatus: async (nextStatus) => {
+        statusSession.update(nextStatus);
+        await replyContext.observers?.onStatus?.(nextStatus);
+      }
     },
-    onStatus: async (nextStatus) => {
-      statusSession.update(nextStatus);
-      await replyContext.onStatus?.(nextStatus);
+    durability: {
+      ...replyContext.durability,
+      onSandboxAcquired: async (sandbox) => {
+        await persistThreadStateById(threadId, {
+          sandboxId: sandbox.sandboxId,
+          sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
+        });
+        await replyContext.durability?.onSandboxAcquired?.(sandbox);
+      },
+      onArtifactStateUpdated: async (artifacts) => {
+        await persistThreadStateById(threadId, { artifacts });
+        await replyContext.durability?.onArtifactStateUpdated?.(artifacts);
+      }
     }
   };
 }
@@ -3948,16 +3909,18 @@ async function resumeSlackTurn(args) {
     if (preparedArgs) {
       runArgs = { ...args, ...preparedArgs };
     }
-    if (!runArgs.replyContext?.requester?.userId) {
-      throw new Error("Resumed turn requires replyContext.requester.userId");
+    if (!runArgs.replyContext?.routing.requester?.userId) {
+      throw new Error(
+        "Resumed turn requires replyContext.routing.requester.userId"
+      );
     }
-    const credentialContext = runArgs.replyContext.credentialContext;
+    const credentialContext = runArgs.replyContext.routing.credentialContext;
     if (!credentialContext) {
       throw new Error("Resumed turn requires replyContext.credentialContext");
     }
-    if (credentialContext.actor.type !== "user" || credentialContext.actor.userId !== runArgs.replyContext.requester.userId) {
+    if (credentialContext.actor.type !== "user" || credentialContext.actor.userId !== runArgs.replyContext.routing.requester.userId) {
       throw new Error(
-        "Resumed turn credential actor must match replyContext.requester.userId"
+        "Resumed turn credential actor must match replyContext.routing.requester.userId"
       );
     }
     if (runArgs.messageTs) {
@@ -3976,87 +3939,119 @@ async function resumeSlackTurn(args) {
       );
     }
     status.start();
-    const generateReply = runArgs.generateReply ?? generateAssistantReply;
     const replyContext = createResumeReplyContext(runArgs, status);
-    const replyPromise = generateReply(runArgs.messageText, replyContext);
+    const replyPromise = runArgs.agentRunner.run(replyContext);
     const replyTimeoutMs = resolveReplyTimeoutMs(runArgs.replyTimeoutMs);
-    let reply = typeof replyTimeoutMs === "number" ? await Promise.race([
+    const outcome = typeof replyTimeoutMs === "number" ? await Promise.race([
       replyPromise,
       new Promise(
         (_, reject) => setTimeout(
           () => reject(
             new Error(
-              `generateAssistantReply timed out after ${replyTimeoutMs}ms`
+              `executeAgentRun timed out after ${replyTimeoutMs}ms`
             )
           ),
           replyTimeoutMs
         )
       )
     ]) : await replyPromise;
-    reply = finalizeFailedTurnReply({
-      reply,
-      logException,
-      context: getResumeLogContext(runArgs, lockKey)
-    });
-    await status.stop();
-    const footer = buildSlackReplyFooter({
-      conversationId: getResumeConversationId(runArgs, lockKey)
-    });
-    await postSlackApiReplyPosts({
-      channelId: runArgs.channelId,
-      threadTs: runArgs.threadTs,
-      posts: planSlackReplyPosts({ reply }),
-      fileUploadFailureMode: "best_effort",
-      footer
-    });
-    finalReplyDelivered = true;
-    if (replyContext.correlation?.conversationId && replyContext.correlation.turnId && reply.piMessages?.length) {
-      await persistCompletedSessionRecord({
-        conversationId: replyContext.correlation.conversationId,
-        sessionId: replyContext.correlation.turnId,
-        allMessages: reply.piMessages,
-        currentDurationMs: reply.diagnostics.durationMs,
-        currentUsage: reply.diagnostics.usage,
-        destination: replyContext.destination,
-        source: replyContext.source,
-        requester: replyContext.requester,
-        surface: "slack",
-        logContext: {
-          threadId: replyContext.correlation.threadId,
-          requesterId: replyContext.requester?.userId,
-          channelId: runArgs.channelId,
-          runId: replyContext.correlation.runId,
-          assistantUserName: botConfig.userName,
-          modelId: reply.diagnostics.modelId
-        }
-      });
-    }
-    await runArgs.onSuccess?.(reply);
-    if (reply.diagnostics.outcome === "success" && replyContext.correlation?.conversationId && replyContext.correlation.turnId) {
-      try {
-        const params = {
-          conversationId: replyContext.correlation.conversationId,
-          sessionId: replyContext.correlation.turnId
+    if (outcome.status !== "completed") {
+      await status.stop();
+      const onAuthPause = runArgs.onAuthPause;
+      const onTimeoutPause = runArgs.onTimeoutPause;
+      if (outcome.status === "awaiting_auth" && onAuthPause) {
+        deferredPauseKind = "auth";
+        deferredAuthInfo = {
+          providerDisplayName: outcome.providerDisplayName,
+          requesterId: runArgs.replyContext?.routing.requester?.userId
         };
-        if (runArgs.scheduleSessionCompletedPluginTasks) {
-          await runArgs.scheduleSessionCompletedPluginTasks(params);
-        } else {
-          await scheduleSessionCompletedPluginTasks(params);
+        deferredPauseHandler = async () => {
+          await onAuthPause({
+            providerDisplayName: outcome.providerDisplayName
+          });
+        };
+      } else if (outcome.status === "suspended" && onTimeoutPause) {
+        deferredPauseKind = "timeout";
+        deferredPauseHandler = async () => {
+          await onTimeoutPause({ resumeVersion: outcome.resumeVersion });
+        };
+      } else {
+        deferredFailureHandler = async () => {
+          await handleResumeFailure({
+            body: "Failed to resume Slack turn",
+            error: new Error(
+              `Resumed run ended ${outcome.status} without a pause handler`
+            ),
+            eventName: "slack_resume_turn_failed",
+            lockKey,
+            resumeArgs: runArgs
+          });
+        };
+      }
+    } else {
+      let reply = outcome.result;
+      reply = finalizeFailedTurnReply({
+        reply,
+        logException,
+        context: getResumeLogContext(runArgs, lockKey)
+      });
+      await status.stop();
+      const footer = buildSlackReplyFooter({
+        conversationId: getResumeConversationId(runArgs, lockKey)
+      });
+      await postSlackApiReplyPosts({
+        channelId: runArgs.channelId,
+        threadTs: runArgs.threadTs,
+        posts: planSlackReplyPosts({ reply }),
+        footer
+      });
+      finalReplyDelivered = true;
+      if (replyContext.routing.correlation?.conversationId && replyContext.routing.correlation.turnId && reply.piMessages?.length) {
+        await persistCompletedSessionRecord({
+          conversationId: replyContext.routing.correlation.conversationId,
+          sessionId: replyContext.routing.correlation.turnId,
+          allMessages: reply.piMessages,
+          currentDurationMs: reply.diagnostics.durationMs,
+          currentUsage: reply.diagnostics.usage,
+          destination: replyContext.routing.destination,
+          source: replyContext.routing.source,
+          requester: replyContext.routing.requester,
+          surface: "slack",
+          logContext: {
+            threadId: replyContext.routing.correlation.threadId,
+            requesterId: replyContext.routing.requester?.userId,
+            channelId: runArgs.channelId,
+            runId: replyContext.routing.correlation.runId,
+            assistantUserName: botConfig.userName,
+            modelId: reply.diagnostics.modelId
+          }
+        });
+      }
+      await runArgs.onSuccess?.(reply);
+      if (reply.diagnostics.outcome === "success" && replyContext.routing.correlation?.conversationId && replyContext.routing.correlation.turnId) {
+        try {
+          const params = {
+            conversationId: replyContext.routing.correlation.conversationId,
+            sessionId: replyContext.routing.correlation.turnId
+          };
+          if (runArgs.scheduleSessionCompletedPluginTasks) {
+            await runArgs.scheduleSessionCompletedPluginTasks(params);
+          } else {
+            await scheduleSessionCompletedPluginTasks(params);
+          }
+        } catch (scheduleError) {
+          logException(
+            scheduleError,
+            "plugin_session_completed_task_schedule_failed",
+            getResumeLogContext(runArgs, lockKey),
+            {},
+            "Plugin session.completed task scheduling failed"
+          );
         }
-      } catch (scheduleError) {
-        logException(
-          scheduleError,
-          "plugin_session_completed_task_schedule_failed",
-          getResumeLogContext(runArgs, lockKey),
-          {},
-          "Plugin session.completed task scheduling failed"
-        );
       }
     }
   } catch (error) {
     await status.stop();
-    const onAuthPause = runArgs.onAuthPause;
-    const onTimeoutPause = runArgs.onTimeoutPause;
     if (finalReplyDelivered) {
       postDeliveryCommitError = error;
       try {
@@ -4070,21 +4065,6 @@ async function resumeSlackTurn(args) {
           "Failed to terminalize resumed turn after post-delivery commit failure"
         );
       }
-    } else if (isAuthResumeRetryableTurnError(error) && onAuthPause) {
-      deferredPauseKind = "auth";
-      deferredAuthInfo = {
-        providerDisplayName: error.metadata.authProviderDisplayName,
-        // The try body validates requester.userId; catch scope does not retain that narrowing.
-        requesterId: runArgs.replyContext?.requester?.userId
-      };
-      deferredPauseHandler = async () => {
-        await onAuthPause(error);
-      };
-    } else if (isRetryableTurnError(error, "agent_continue") && onTimeoutPause) {
-      deferredPauseKind = "timeout";
-      deferredPauseHandler = async () => {
-        await onTimeoutPause(error);
-      };
     } else {
       deferredFailureHandler = async () => {
         await handleResumeFailure({
@@ -4157,7 +4137,7 @@ async function resumeAuthorizedRequest(args) {
     replyContext: args.replyContext,
     lockKey: args.lockKey,
     initialText: args.connectedText,
-    generateReply: args.generateReply,
+    agentRunner: args.agentRunner,
     onSuccess: args.onSuccess,
     onFailure: args.onFailure,
     onAuthPause: args.onAuthPause,
@@ -4354,7 +4334,7 @@ async function persistFailedReplyState(channelId, threadTs, sessionId, expectedV
   });
 }
 async function resumeAuthorizedMcpTurn(args) {
-  const { authSession, generateReply, provider } = args;
+  const { authSession, agentRunner, provider } = args;
   if (!authSession.channelId || !authSession.destination || !authSession.threadTs) {
     return;
   }
@@ -4397,7 +4377,7 @@ async function resumeAuthorizedMcpTurn(args) {
     messageTs: getTurnUserSlackMessageTs(userMessage2),
     lockKey: threadId,
     connectedText: "",
-    generateReply,
+    agentRunner,
     beforeStart: async () => {
       const lockedState = await getPersistedThreadState(threadId);
       const lockedConversation = coerceThreadConversationState(lockedState);
@@ -4492,38 +4472,48 @@ async function resumeAuthorizedMcpTurn(args) {
         messageText: lockedUserMessage.text,
         messageTs: lockedMessageTs,
         replyContext: {
-          credentialContext: {
-            actor: { type: "user", userId: requester.userId }
-          },
-          requester,
-          destination,
-          source: lockedSessionRecord.source,
-          correlation: {
-            conversationId: authSession.conversationId,
-            turnId: lockedSessionId,
-            channelId: authSession.channelId,
-            threadTs: authSession.threadTs,
-            requesterId: requester.userId
+          input: {
+            conversationContext: lockedConversationContext,
+            piMessages: lockedConversation.piMessages,
+            ...getTurnUserReplyAttachmentContext(lockedUserMessage)
           },
-          toolChannelId: authSession.toolChannelId ?? lockedArtifacts.assistantContextChannelId ?? authSession.channelId,
-          conversationContext: lockedConversationContext,
-          artifactState: lockedArtifacts,
-          piMessages: lockedConversation.piMessages,
-          configuration: authSession.configuration,
-          pendingAuth: lockedPendingAuth,
-          channelConfiguration: lockedChannelConfiguration,
-          sandbox: getPersistedSandboxState(lockedState),
-          recordPendingAuth: async (nextPendingAuth) => {
-            await applyPendingAuthUpdate({
-              conversation: lockedConversation,
+          routing: {
+            credentialContext: {
+              actor: { type: "user", userId: requester.userId }
+            },
+            requester,
+            destination,
+            source: lockedSessionRecord.source,
+            correlation: {
               conversationId: authSession.conversationId,
-              nextPendingAuth
-            });
-            await persistThreadStateById(threadId, {
-              conversation: lockedConversation
-            });
+              turnId: lockedSessionId,
+              channelId: authSession.channelId,
+              threadTs: authSession.threadTs,
+              requesterId: requester.userId
+            },
+            toolChannelId: authSession.toolChannelId ?? lockedArtifacts.assistantContextChannelId ?? authSession.channelId
+          },
+          policy: {
+            configuration: authSession.configuration,
+            channelConfiguration: lockedChannelConfiguration
+          },
+          state: {
+            artifactState: lockedArtifacts,
+            pendingAuth: lockedPendingAuth,
+            sandbox: getPersistedSandboxState(lockedState)
           },
-          ...getTurnUserReplyAttachmentContext(lockedUserMessage)
+          durability: {
+            recordPendingAuth: async (nextPendingAuth) => {
+              await applyPendingAuthUpdate({
+                conversation: lockedConversation,
+                conversationId: authSession.conversationId,
+                nextPendingAuth
+              });
+              await persistThreadStateById(threadId, {
+                conversation: lockedConversation
+              });
+            }
+          }
         },
         onSuccess: async (reply) => {
           await persistCompletedReplyState(
@@ -4559,7 +4549,7 @@ async function resumeAuthorizedMcpTurn(args) {
             );
           }
         },
-        onAuthPause: async (error) => {
+        onAuthPause: async () => {
           await persistAuthPauseTurnState({
             sessionId: lockedSessionId,
             threadStateId: threadId
@@ -4567,35 +4557,23 @@ async function resumeAuthorizedMcpTurn(args) {
           logWarn(
             "mcp_oauth_callback_resume_reparked_for_auth",
             {},
-            {
-              "app.credential.provider": provider,
-              ...isRetryableTurnError(error) ? { "app.ai.retryable_reason": error.reason } : {}
-            },
+            { "app.credential.provider": provider },
             "Resumed MCP turn requested another authorization flow"
           );
         },
-        onTimeoutPause: async (error) => {
-          if (!isRetryableTurnError(error, "agent_continue")) {
-            throw error;
-          }
-          const version = error.metadata?.version;
-          if (typeof version !== "number") {
-            throw new Error(
-              "MCP OAuth agent continuation did not include a session record version"
-            );
-          }
+        onTimeoutPause: async ({ resumeVersion }) => {
           await scheduleAgentContinue({
             conversationId: authSession.conversationId,
             destination,
             sessionId: lockedSessionId,
-            expectedVersion: version
+            expectedVersion: resumeVersion
           });
         }
       };
     }
   });
 }
-async function GET3(request, provider, waitUntil, options = {}) {
+async function GET3(request, provider, waitUntil, options) {
   const url = new URL(request.url);
   const state = url.searchParams.get("state")?.trim();
   const code = url.searchParams.get("code")?.trim();
@@ -4625,7 +4603,7 @@ async function GET3(request, provider, waitUntil, options = {}) {
     waitUntil(
       () => resumeAuthorizedMcpTurn({
         authSession,
-        generateReply: options.generateReply,
+        agentRunner: options.agentRunner,
         provider
       })
     );
@@ -4927,7 +4905,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
     messageTs: getTurnUserSlackMessageTs(userMessage2),
     lockKey: stored.resumeConversationId,
     initialText: "",
-    generateReply: options.generateReply,
+    agentRunner: options.agentRunner,
     beforeStart: async () => {
       const lockedState = await getPersistedThreadState(
         stored.resumeConversationId
@@ -5025,40 +5003,50 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         messageText: lockedPendingAuth ? lockedUserMessage.text : stored.pendingMessage ?? lockedUserMessage.text,
         messageTs: lockedMessageTs,
         replyContext: {
-          credentialContext: {
-            actor: {
-              type: "user",
-              userId: requester.userId
-            }
+          input: {
+            conversationContext: lockedConversationContext,
+            piMessages: lockedConversation.piMessages,
+            ...getTurnUserReplyAttachmentContext(lockedUserMessage)
           },
-          requester,
-          destination,
-          source: lockedSessionRecord.source,
-          correlation: {
-            conversationId: stored.resumeConversationId,
-            turnId: lockedSessionId,
-            channelId: stored.channelId,
-            threadTs: stored.threadTs,
-            requesterId: requester.userId
-          },
-          toolChannelId: lockedArtifacts.assistantContextChannelId ?? stored.channelId,
-          artifactState: lockedArtifacts,
-          pendingAuth: lockedPendingAuth,
-          conversationContext: lockedConversationContext,
-          channelConfiguration: lockedChannelConfiguration,
-          piMessages: lockedConversation.piMessages,
-          sandbox: getPersistedSandboxState(lockedState),
-          recordPendingAuth: async (nextPendingAuth) => {
-            await applyPendingAuthUpdate({
-              conversation: lockedConversation,
+          routing: {
+            credentialContext: {
+              actor: {
+                type: "user",
+                userId: requester.userId
+              }
+            },
+            requester,
+            destination,
+            source: lockedSessionRecord.source,
+            correlation: {
               conversationId: stored.resumeConversationId,
-              nextPendingAuth
-            });
-            await persistThreadStateById(stored.resumeConversationId, {
-              conversation: lockedConversation
-            });
+              turnId: lockedSessionId,
+              channelId: stored.channelId,
+              threadTs: stored.threadTs,
+              requesterId: requester.userId
+            },
+            toolChannelId: lockedArtifacts.assistantContextChannelId ?? stored.channelId
           },
-          ...getTurnUserReplyAttachmentContext(lockedUserMessage)
+          policy: {
+            channelConfiguration: lockedChannelConfiguration
+          },
+          state: {
+            artifactState: lockedArtifacts,
+            pendingAuth: lockedPendingAuth,
+            sandbox: getPersistedSandboxState(lockedState)
+          },
+          durability: {
+            recordPendingAuth: async (nextPendingAuth) => {
+              await applyPendingAuthUpdate({
+                conversation: lockedConversation,
+                conversationId: stored.resumeConversationId,
+                nextPendingAuth
+              });
+              await persistThreadStateById(stored.resumeConversationId, {
+                conversation: lockedConversation
+              });
+            }
+          }
         },
         onSuccess: async (reply) => {
           logInfo(
@@ -5098,21 +5086,12 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
             threadStateId: stored.resumeConversationId
           });
         },
-        onTimeoutPause: async (error) => {
-          if (!isRetryableTurnError(error, "agent_continue")) {
-            throw error;
-          }
-          const version = error.metadata?.version;
-          if (typeof version !== "number") {
-            throw new Error(
-              "OAuth agent continuation did not include a session record version"
-            );
-          }
+        onTimeoutPause: async ({ resumeVersion }) => {
           await scheduleAgentContinue({
             conversationId: stored.resumeConversationId,
             destination,
             sessionId: lockedSessionId,
-            expectedVersion: version
+            expectedVersion: resumeVersion
           });
         }
       };
@@ -5148,23 +5127,29 @@ async function resumePendingOAuthMessage(stored, options) {
     threadTs: stored.threadTs,
     messageTs,
     connectedText: "",
-    generateReply: options.generateReply,
+    agentRunner: options.agentRunner,
     replyContext: {
-      credentialContext: {
-        actor: { type: "user", userId: stored.userId }
+      input: {
+        conversationContext,
+        piMessages: conversation.piMessages
       },
-      requester,
-      destination: stored.destination,
-      source,
-      correlation: {
-        conversationId: threadId,
-        channelId: stored.channelId,
-        threadTs: stored.threadTs,
-        requesterId: stored.userId
+      routing: {
+        credentialContext: {
+          actor: { type: "user", userId: stored.userId }
+        },
+        requester,
+        destination: stored.destination,
+        source,
+        correlation: {
+          conversationId: threadId,
+          channelId: stored.channelId,
+          threadTs: stored.threadTs,
+          requesterId: stored.userId
+        }
       },
-      conversationContext,
-      piMessages: conversation.piMessages,
-      configuration: stored.configuration
+      policy: {
+        configuration: stored.configuration
+      }
     },
     onSuccess: async (reply) => {
       logInfo(
@@ -5180,7 +5165,7 @@ async function resumePendingOAuthMessage(stored, options) {
     }
   });
 }
-async function GET4(request, provider, waitUntil, options = {}) {
+async function GET4(request, provider, waitUntil, options) {
   const providerConfig = pluginCatalogRuntime.getOAuthConfig(provider);
   if (!providerConfig) {
     return htmlErrorResponse(
@@ -7532,7 +7517,7 @@ function getQueuedMessages(context, options) {
       stripLeadingSlackMentionToken: options.explicitMention || Boolean(message.isMention)
     });
     return {
-      explicitMention: options.explicitMention || Boolean(message.isMention),
+      explicitMention: Boolean(message.isMention),
       message,
       rawText: appendSlackLegacyAttachmentText(message.text, message.raw),
       userText: appendSlackLegacyAttachmentText(stripped, message.raw)
@@ -7908,16 +7893,6 @@ function createSlackTurnRuntime(deps) {
           channelId: deps.getChannelId(thread, message),
           runId: deps.getRunId(thread, message)
         });
-        if (isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) {
-          deps.logException(
-            error,
-            "mention_handler_auth_pause",
-            errorContext,
-            { "app.ai.retryable_reason": error.reason },
-            "onNewMention parked turn for auth resume"
-          );
-          return;
-        }
         if (error instanceof AuthorizationFlowDisabledError) {
           return;
         }
@@ -8178,16 +8153,6 @@ function createSlackTurnRuntime(deps) {
           channelId: deps.getChannelId(thread, message),
           runId: deps.getRunId(thread, message)
         });
-        if (isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) {
-          deps.logException(
-            error,
-            "subscribed_message_handler_auth_pause",
-            errorContext,
-            { "app.ai.retryable_reason": error.reason },
-            "onSubscribedMessage parked turn for auth resume"
-          );
-          return;
-        }
         if (error instanceof AuthorizationFlowDisabledError) {
           return;
         }
@@ -8601,7 +8566,7 @@ function createSubscribedReplyPolicy(deps) {
   };
 }
 
-// src/chat/services/vision-context.ts
+// src/chat/slack/vision-context.ts
 var MAX_USER_ATTACHMENTS = 3;
 var MAX_USER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 var MAX_MESSAGE_IMAGE_ATTACHMENTS = 3;
@@ -8907,6 +8872,14 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
   if (!context.channelId || !context.threadTs) {
     return;
   }
+  const channelId = parseSlackChannelId(context.channelId);
+  if (!channelId) {
+    return;
+  }
+  const threadTs = parseSlackMessageTs(context.threadTs);
+  if (!threadTs) {
+    return;
+  }
   const messagesByTs = /* @__PURE__ */ new Map();
   for (const message of conversation.messages) {
     if (!isHumanConversationMessage(message)) continue;
@@ -8921,8 +8894,8 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
   let replies;
   try {
     replies = await deps.listThreadReplies({
-      channelId: context.channelId,
-      threadTs: context.threadTs,
+      channelId,
+      threadTs,
       limit: 1e3,
       maxPages: 10,
       targetMessageTs: [...messagesByTs.keys()]
@@ -9120,15 +9093,6 @@ function createVisionContextService(deps) {
 }
 
 // src/chat/app/services.ts
-function withSandboxTracePropagation(generateReply, tracePropagation) {
-  return async (messageText2, context) => await generateReply(messageText2, {
-    ...context,
-    sandbox: {
-      ...context?.sandbox,
-      tracePropagation: context?.sandbox?.tracePropagation ?? tracePropagation
-    }
-  });
-}
 function createJuniorRuntimeServices(overrides = {}) {
   const conversationMemory = createConversationMemoryService({
     completeText: overrides.conversationMemory?.completeText ?? completeText
@@ -9147,10 +9111,9 @@ function createJuniorRuntimeServices(overrides = {}) {
     contextCompactor,
     replyExecutor: {
       contextCompactor: overrides.replyExecutor?.contextCompactor ?? contextCompactor,
-      generateAssistantReply: overrides.replyExecutor?.generateAssistantReply ?? withSandboxTracePropagation(
-        generateAssistantReply,
-        overrides.sandbox?.tracePropagation
-      ),
+      agentRunner: overrides.replyExecutor?.agentRunner ?? createAgentRunner(executeAgentRun, {
+        tracePropagation: overrides.sandbox?.tracePropagation
+      }),
       getAwaitingAgentContinueRequest: overrides.replyExecutor?.getAwaitingAgentContinueRequest ?? getAwaitingAgentContinueRequest,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
       scheduleAgentContinue: overrides.replyExecutor?.scheduleAgentContinue ?? scheduleAgentContinue,
@@ -9317,6 +9280,56 @@ function parkedInputKey(message) {
   const text = first && typeof first === "object" && "text" in first ? String(first.text ?? "") : "";
   return `${message.timestamp}:${text}`;
 }
+function renderRecentThreadMessages(conversationContext, messages) {
+  const passiveMessages = messages.filter((queued) => {
+    if (queued.explicitMention) {
+      return false;
+    }
+    const slackTs = queuedInstructionActor(queued)?.slackTs;
+    return !slackTs || !conversationContext?.includes(`slack_ts="${slackTs}"`);
+  });
+  if (passiveMessages.length === 0) {
+    return void 0;
+  }
+  const lines = ["<recent-thread-messages>"];
+  for (const queued of passiveMessages) {
+    const actor = queuedInstructionActor(queued);
+    const attrs = [
+      actor?.authorId ? `author_id="${escapeXml(actor.authorId)}"` : void 0,
+      actor?.authorName ? `author_name="${escapeXml(actor.authorName)}"` : void 0,
+      actor?.slackTs ? `slack_ts="${escapeXml(actor.slackTs)}"` : void 0
+    ].filter((attr) => Boolean(attr)).join(" ");
+    lines.push(
+      attrs ? `  <message ${attrs}>` : "  <message>",
+      escapeXml(queued.userText),
+      "  </message>"
+    );
+  }
+  lines.push("</recent-thread-messages>");
+  return lines.join("\n");
+}
+function appendRecentThreadMessagesToContext(conversationContext, messages, options) {
+  const recentThreadMessages = renderRecentThreadMessages(
+    conversationContext,
+    messages
+  );
+  const contextParts = [
+    options?.includeConversationContext === false ? void 0 : conversationContext?.trim(),
+    recentThreadMessages
+  ].filter((part) => Boolean(part));
+  return contextParts.length > 0 ? contextParts.join("\n\n") : void 0;
+}
+function queuedInstructionActor(queued) {
+  const actor = getMessageActorIdentity(queued.message);
+  const authorId = actor?.userId ?? parseActorUserId(queued.message.author.userId);
+  const authorName = actor?.fullName ?? actor?.userName;
+  const slackTs = getSlackMessageTs(queued.message);
+  return {
+    ...authorId ? { authorId } : {},
+    ...authorName ? { authorName } : {},
+    ...slackTs ? { slackTs } : {}
+  };
+}
 function isResourceEventMessage(message) {
   const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
   return raw?.event_type === "resource_event";
@@ -9440,10 +9453,6 @@ function createReplyToThread(deps) {
             message.raw
           )
         };
-        const effectiveUserText = combineTurnText(
-          options.queuedMessages ?? [],
-          currentText
-        ).userText;
         await Promise.all(
           (options.queuedMessages ?? []).filter((queued) => !isResourceEventMessage(queued.message)).map(
             (queued) => ensureSlackMessageActorIdentity(
@@ -9453,6 +9462,7 @@ function createReplyToThread(deps) {
             )
           )
         );
+        const effectiveUserText = currentText.userText;
         const credentialContext = resourceEventCredentialContext(message) ?? {
           actor: { type: "user", userId: message.author.userId }
         };
@@ -9544,6 +9554,7 @@ function createReplyToThread(deps) {
             queuedMessages.map(async (queued) => {
               const attachments = queued.message.attachments;
               return {
+                actor: queuedInstructionActor(queued),
                 text: queued.userText,
                 timestampMs: queued.message.metadata.dateSent.getTime(),
                 omittedImageAttachmentCount: !isVisionEnabled() && hasPotentialImageAttachment(attachments) ? countPotentialImageAttachments(attachments) : 0,
@@ -9864,7 +9875,8 @@ function createReplyToThread(deps) {
         let finalReplyDelivered = false;
         let latestArtifacts = preparedState.artifacts;
         let assistantTitleArtifacts = {};
-        const hasVisibleSlackDelivery = (post) => post.text.trim().length > 0 || Boolean(post.files?.length);
+        let agentContinueScheduleError;
+        const hasVisibleSlackDelivery = (post) => post.text.trim().length > 0;
         try {
           const loadedPiMessages = await loadPiMessagesForTurn({
             conversationId,
@@ -9893,6 +9905,18 @@ function createReplyToThread(deps) {
               });
             }
           }
+          const hasDurablePromptHistory = Boolean(piMessages?.length);
+          const queuedInstructionPiMessages = (await resolveSteeringMessages(
+            (options.queuedMessages ?? []).filter(
+              (queued) => queued.explicitMention
+            )
+          )).map(buildSteeringPiMessage);
+          if (queuedInstructionPiMessages.length > 0) {
+            piMessages = [
+              ...piMessages ?? [],
+              ...queuedInstructionPiMessages
+            ];
+          }
           status.start();
           const assistantTitleTask = maybeUpdateAssistantTitle({
             assistantThreadContext,
@@ -9956,6 +9980,12 @@ function createReplyToThread(deps) {
             );
           });
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
+          const activeInstructionAuthorId = requester?.userId ?? parseActorUserId(message.author.userId);
+          const activeInstructionAuthorName = requester?.fullName ?? requester?.userName;
+          const promptConversationContext = appendRecentThreadMessagesToContext(
+            preparedState.conversationContext,
+            options.queuedMessages ?? []
+          );
           const drainSteeringMessages = options.drainSteeringMessages ? async (accept) => {
             let acceptedMessages;
             const drained = await options.drainSteeringMessages(
@@ -9967,26 +9997,28 @@ function createReplyToThread(deps) {
             );
             return acceptedMessages ?? await resolveSteeringMessages(drained);
           } : void 0;
-          let reply = await deps.services.generateAssistantReply(
-            effectiveUserText,
-            {
-              credentialContext,
-              requester,
-              conversationContext: preparedState.conversationContext,
-              artifactState: preparedState.artifacts,
+          const outcome = await deps.services.agentRunner.run({
+            input: {
+              actor: {
+                ...activeInstructionAuthorId ? { authorId: activeInstructionAuthorId } : {},
+                ...activeInstructionAuthorName ? { authorName: activeInstructionAuthorName } : {},
+                ...slackMessageTs ? { slackTs: slackMessageTs } : {}
+              },
+              includeConversationContextWithPiMessages: hasDurablePromptHistory,
+              messageText: effectiveUserText,
+              conversationContext: promptConversationContext,
               piMessages,
-              pendingAuth: preparedState.conversation.processing.pendingAuth,
-              configuration: preparedState.configuration,
-              channelConfiguration: preparedState.channelConfiguration,
               inboundAttachmentCount: turnAttachments.length,
               omittedImageAttachmentCount,
-              userAttachments,
+              userAttachments
+            },
+            routing: {
+              credentialContext,
+              requester,
               slackConversation,
               source,
               destination,
               surface: "slack",
-              authorizationFlowMode: message.author.isBot === true ? "disabled" : void 0,
-              turnDeadlineAtMs: getTurnRequestDeadline()?.deadlineAtMs,
               correlation: {
                 conversationId,
                 threadId,
@@ -9999,11 +10031,30 @@ function createReplyToThread(deps) {
                 channelName,
                 requesterId: slackRequesterId
               },
-              toolChannelId,
+              toolChannelId
+            },
+            policy: {
+              configuration: preparedState.configuration,
+              channelConfiguration: preparedState.channelConfiguration,
+              authorizationFlowMode: message.author.isBot === true ? "disabled" : void 0,
+              turnDeadlineAtMs: getTurnRequestDeadline()?.deadlineAtMs
+            },
+            state: {
+              artifactState: preparedState.artifacts,
+              pendingAuth: preparedState.conversation.processing.pendingAuth,
               sandbox: {
                 sandboxId: preparedState.sandboxId,
                 sandboxDependencyProfileHash: preparedState.sandboxDependencyProfileHash
-              },
+              }
+            },
+            observers: {
+              onStatus: (nextStatus) => status.update(nextStatus),
+              onToolInvocation: options.onToolInvocation
+            },
+            durability: {
+              onInputCommitted: options.ack,
+              drainSteeringMessages,
+              shouldYield: options.shouldYield,
               onSandboxAcquired: async (sandbox) => {
                 await persistThreadState(thread, {
                   sandboxId: sandbox.sandboxId,
@@ -10028,14 +10079,98 @@ function createReplyToThread(deps) {
                 await persistThreadState(thread, {
                   conversation: preparedState.conversation
                 });
-              },
-              onStatus: (nextStatus) => status.update(nextStatus),
-              onToolInvocation: options.onToolInvocation,
-              onInputCommitted: options.ack,
-              drainSteeringMessages,
-              shouldYield: options.shouldYield
+              }
             }
-          );
+          });
+          if (outcome.status === "awaiting_auth") {
+            if (!requester) {
+              const text = `I could not act on this subscribed event because ${outcome.providerDisplayName} needs user authorization. Ask me in this thread to connect ${outcome.providerDisplayName} before retrying.`;
+              await postThreadReply(
+                buildSlackOutputMessage(text),
+                "thread_reply"
+              );
+              markConversationMessage(
+                preparedState.conversation,
+                preparedState.userMessageId,
+                {
+                  replied: true,
+                  skippedReason: void 0
+                }
+              );
+              upsertConversationMessage(preparedState.conversation, {
+                id: generateConversationId("assistant"),
+                role: "assistant",
+                text: normalizeConversationText(text),
+                createdAtMs: Date.now(),
+                author: {
+                  userName: botConfig.userName,
+                  isBot: true
+                },
+                meta: {
+                  replied: true
+                }
+              });
+              markTurnClosed({
+                conversation: preparedState.conversation,
+                nowMs: Date.now(),
+                sessionId: turnId,
+                updateConversationStats
+              });
+              await persistThreadState(thread, {
+                conversation: preparedState.conversation
+              });
+              persistedAtLeastOnce = true;
+              shouldPersistFailureState = false;
+              return;
+            }
+            await postAuthPauseNotice(outcome.providerDisplayName);
+            completeAuthPauseTurn({
+              conversation: preparedState.conversation,
+              sessionId: turnId
+            });
+            await persistThreadState(thread, {
+              conversation: preparedState.conversation
+            });
+            persistedAtLeastOnce = true;
+            shouldPersistFailureState = false;
+            return;
+          }
+          if (outcome.status === "suspended") {
+            if (options.shouldYield?.()) {
+              shouldPersistFailureState = false;
+              throw new CooperativeTurnYieldError();
+            }
+            if (!destination || !conversationId) {
+              throw new Error(
+                "Agent continuation requires a destination and conversation id"
+              );
+            }
+            try {
+              await deps.services.scheduleAgentContinue({
+                conversationId,
+                destination,
+                sessionId: turnId,
+                expectedVersion: outcome.resumeVersion
+              });
+              shouldPersistFailureState = false;
+            } catch (scheduleError) {
+              logException(
+                scheduleError,
+                "agent_continue_schedule_failed",
+                turnTraceContext,
+                {
+                  ...messageTs ? { "messaging.message.id": messageTs } : {},
+                  "app.ai.resume_session_version": outcome.resumeVersion
+                },
+                "Failed to schedule agent continuation"
+              );
+              shouldPersistFailureState = true;
+              agentContinueScheduleError = scheduleError;
+              throw scheduleError;
+            }
+            return;
+          }
+          let reply = outcome.result;
           const diagnosticsContext = {
             slackThreadId: threadId,
             slackUserId: message.author.userId,
@@ -10081,7 +10216,6 @@ function createReplyToThread(deps) {
                 channelId: slackChannelId,
                 threadTs: slackThreadTs,
                 posts: plannedPosts,
-                fileUploadFailureMode: "strict",
                 footer: replyFooter,
                 onPostError: ({ error, messageTs: messageTs2, stage }) => {
                   logException(
@@ -10103,7 +10237,7 @@ function createReplyToThread(deps) {
                   continue;
                 }
                 await postThreadReply(
-                  buildSlackOutputMessage(post.text, post.files),
+                  buildSlackOutputMessage(post.text),
                   post.stage
                 );
               }
@@ -10229,99 +10363,13 @@ function createReplyToThread(deps) {
             );
             return;
           }
-          if (isCooperativeTurnYieldError(error)) {
+          if (error instanceof CooperativeTurnYieldError) {
             shouldPersistFailureState = false;
             throw error;
           }
-          if (isAuthResumeRetryableTurnError(error)) {
-            if (!requester) {
-              const text = `I could not act on this subscribed event because ${error.metadata.authProviderDisplayName} needs user authorization. Ask me in this thread to connect ${error.metadata.authProviderDisplayName} before retrying.`;
-              await postThreadReply(
-                buildSlackOutputMessage(text),
-                "thread_reply"
-              );
-              markConversationMessage(
-                preparedState.conversation,
-                preparedState.userMessageId,
-                {
-                  replied: true,
-                  skippedReason: void 0
-                }
-              );
-              upsertConversationMessage(preparedState.conversation, {
-                id: generateConversationId("assistant"),
-                role: "assistant",
-                text: normalizeConversationText(text),
-                createdAtMs: Date.now(),
-                author: {
-                  userName: botConfig.userName,
-                  isBot: true
-                },
-                meta: {
-                  replied: true
-                }
-              });
-              markTurnClosed({
-                conversation: preparedState.conversation,
-                nowMs: Date.now(),
-                sessionId: turnId,
-                updateConversationStats
-              });
-              await persistThreadState(thread, {
-                conversation: preparedState.conversation
-              });
-              persistedAtLeastOnce = true;
-              shouldPersistFailureState = false;
-              return;
-            }
-            await postAuthPauseNotice(error.metadata.authProviderDisplayName);
-            completeAuthPauseTurn({
-              conversation: preparedState.conversation,
-              sessionId: error.metadata?.sessionId ?? turnId
-            });
-            await persistThreadState(thread, {
-              conversation: preparedState.conversation
-            });
-            persistedAtLeastOnce = true;
-            shouldPersistFailureState = false;
-            return;
-          }
-          if (isRetryableTurnError(error, "agent_continue")) {
-            const conversationIdForResume = error.metadata?.conversationId;
-            const sessionIdForResume = error.metadata?.sessionId;
-            const version = error.metadata?.version;
-            if (conversationIdForResume && sessionIdForResume && typeof version === "number" && destination) {
-              try {
-                await deps.services.scheduleAgentContinue({
-                  conversationId: conversationIdForResume,
-                  destination,
-                  sessionId: sessionIdForResume,
-                  expectedVersion: version
-                });
-                shouldPersistFailureState = false;
-              } catch (scheduleError) {
-                logException(
-                  scheduleError,
-                  "agent_continue_schedule_failed",
-                  turnTraceContext,
-                  {
-                    ...messageTs ? { "messaging.message.id": messageTs } : {},
-                    "app.ai.resume_session_version": version
-                  },
-                  "Failed to schedule agent continuation"
-                );
-                shouldPersistFailureState = true;
-                throw scheduleError;
-              }
-              return;
-            } else {
-              logWarn(
-                "agent_continue_metadata_missing",
-                turnTraceContext,
-                messageTs ? { "messaging.message.id": messageTs } : {},
-                "Agent continuation could not be scheduled because retry metadata was incomplete"
-              );
-            }
+          if (error === agentContinueScheduleError) {
+            shouldPersistFailureState = true;
+            throw error;
           }
           shouldPersistFailureState = true;
           const createdCanvasUrl = getCurrentTurnCanvasUrl({
@@ -10962,7 +11010,7 @@ async function failUnresumableContinuation(args) {
     errorMessage: args.errorMessage
   });
 }
-async function continueSlackAgentRun(payload, options = {}) {
+async function continueSlackAgentRun(payload, options) {
   const thread = parseSlackThreadId(payload.conversationId);
   if (!thread) {
     throw new Error(
@@ -10976,7 +11024,7 @@ async function continueSlackAgentRun(payload, options = {}) {
     channelId: thread.channelId,
     threadTs: thread.threadTs,
     lockKey: payload.conversationId,
-    generateReply: options.generateReply,
+    agentRunner: options.agentRunner,
     scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
     beforeStart: async () => {
       let sessionRecord;
@@ -11041,40 +11089,50 @@ async function continueSlackAgentRun(payload, options = {}) {
           messageText: userMessage2.text,
           messageTs: getTurnUserSlackMessageTs(userMessage2),
           replyContext: {
-            credentialContext: {
-              actor: {
-                type: "user",
-                userId: requester.userId
-              }
-            },
-            requester,
-            destination: payload.destination,
-            source: activeSessionRecord.source,
-            correlation: {
-              conversationId: payload.conversationId,
-              turnId: payload.sessionId,
-              channelId: thread.channelId,
-              threadTs: thread.threadTs,
-              requesterId: requester.userId
+            input: {
+              conversationContext,
+              piMessages: conversation.piMessages,
+              ...getTurnUserReplyAttachmentContext(userMessage2)
             },
-            toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId,
-            artifactState: artifacts,
-            pendingAuth: conversation.processing.pendingAuth,
-            conversationContext,
-            channelConfiguration,
-            piMessages: conversation.piMessages,
-            sandbox,
-            recordPendingAuth: async (nextPendingAuth) => {
-              await applyPendingAuthUpdate({
-                conversation,
+            routing: {
+              credentialContext: {
+                actor: {
+                  type: "user",
+                  userId: requester.userId
+                }
+              },
+              requester,
+              destination: payload.destination,
+              source: activeSessionRecord.source,
+              correlation: {
                 conversationId: payload.conversationId,
-                nextPendingAuth
-              });
-              await persistThreadStateById(payload.conversationId, {
-                conversation
-              });
+                turnId: payload.sessionId,
+                channelId: thread.channelId,
+                threadTs: thread.threadTs,
+                requesterId: requester.userId
+              },
+              toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId
+            },
+            policy: {
+              channelConfiguration
             },
-            ...getTurnUserReplyAttachmentContext(userMessage2)
+            state: {
+              artifactState: artifacts,
+              pendingAuth: conversation.processing.pendingAuth,
+              sandbox
+            },
+            durability: {
+              recordPendingAuth: async (nextPendingAuth) => {
+                await applyPendingAuthUpdate({
+                  conversation,
+                  conversationId: payload.conversationId,
+                  nextPendingAuth
+                });
+                await persistThreadStateById(payload.conversationId, {
+                  conversation
+                });
+              }
+            }
           },
           onSuccess: async (reply) => {
             await persistCompletedReplyState2({
@@ -11108,21 +11166,12 @@ async function continueSlackAgentRun(payload, options = {}) {
               "Continued agent run parked for auth"
             );
           },
-          onTimeoutPause: async (error) => {
-            if (!isRetryableTurnError(error, "agent_continue")) {
-              throw error;
-            }
-            const version = error.metadata?.version;
-            if (typeof version !== "number") {
-              throw new Error(
-                "Agent continuation did not include a session record version"
-              );
-            }
+          onTimeoutPause: async ({ resumeVersion }) => {
             await scheduleAgentContinue2({
               conversationId: payload.conversationId,
               destination: payload.destination,
               sessionId: payload.sessionId,
-              expectedVersion: version
+              expectedVersion: resumeVersion
             });
           }
         };
@@ -11240,7 +11289,7 @@ async function recoverStrandedRunningSession(args) {
   });
   return false;
 }
-async function resumeAwaitingSlackContinuation(conversationId, options = {}) {
+async function resumeAwaitingSlackContinuation(conversationId, options) {
   const summaries = await listAgentTurnSessionSummariesForConversation(conversationId);
   const newest = summaries[0];
   if (newest?.state === "running") {
@@ -11278,7 +11327,7 @@ async function resumeAwaitingSlackContinuation(conversationId, options = {}) {
   }
   return false;
 }
-async function continueSlackAgentRunWithLockRetry(payload, options = {}) {
+async function continueSlackAgentRunWithLockRetry(payload, options) {
   const scheduleAgentContinue2 = options.scheduleAgentContinue ?? scheduleAgentContinue;
   for (const [attempt, delayMs] of [
     ...AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS,
@@ -11362,9 +11411,17 @@ function createProductionSlackWebhookServices(options) {
 }
 function createProductionConversationWorkOptions(options) {
   const conversationStore = getProductionConversationStore();
+  const { agentRunner } = options;
+  const services = {
+    ...options.services,
+    replyExecutor: {
+      ...options.services?.replyExecutor,
+      agentRunner
+    }
+  };
   const runtime = createSlackRuntime({
     getSlackAdapter: getProductionSlackAdapter,
-    services: options?.services
+    services
   });
   return {
     conversationStore,
@@ -11373,11 +11430,8 @@ function createProductionConversationWorkOptions(options) {
       getSlackAdapter: getProductionSlackAdapter,
       conversationStore,
       resumeAwaitingContinuation: async (conversationId) => await resumeAwaitingSlackContinuation(conversationId, {
-        generateReply: withSandboxTracePropagation(
-          generateAssistantReply,
-          options?.services?.sandbox?.tracePropagation
-        ),
-        scheduleSessionCompletedPluginTasks: options?.services?.replyExecutor?.scheduleSessionCompletedPluginTasks
+        agentRunner,
+        scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks
       }),
       runtime
     })
@@ -11699,18 +11753,17 @@ async function createApp(options) {
     throw error;
   }
   const waitUntil = options?.waitUntil ?? await defaultWaitUntil();
+  const tracePropagation = { domains: sandboxEgressTracePropagationDomains };
+  const agentRunner = createAgentRunner(executeAgentRun, {
+    tracePropagation
+  });
   const runtimeServiceOverrides = {
-    sandbox: {
-      tracePropagation: { domains: sandboxEgressTracePropagationDomains }
-    }
+    replyExecutor: { agentRunner },
+    sandbox: { tracePropagation }
   };
   const slackWebhookServices = createProductionSlackWebhookServices({
     services: runtimeServiceOverrides
   });
-  const generateReplyWithTracePropagation = withSandboxTracePropagation(
-    generateAssistantReply,
-    runtimeServiceOverrides.sandbox.tracePropagation
-  );
   const app = new Hono();
   app.onError((err, c) => {
     logException(err, "unhandled_route_error");
@@ -11736,24 +11789,23 @@ async function createApp(options) {
   app.get("/health", () => GET());
   app.get("/api/oauth/callback/mcp/:provider", (c) => {
     return GET3(c.req.raw, c.req.param("provider"), waitUntil, {
-      generateReply: generateReplyWithTracePropagation
+      agentRunner
     });
   });
   app.get("/api/oauth/callback/:provider", (c) => {
     return GET4(c.req.raw, c.req.param("provider"), waitUntil, {
-      generateReply: generateReplyWithTracePropagation
+      agentRunner
     });
   });
   app.post("/api/internal/agent-dispatch", (c) => {
-    return POST(c.req.raw, waitUntil, {
-      tracePropagation: { domains: sandboxEgressTracePropagationDomains }
-    });
+    return POST(c.req.raw, waitUntil, { agentRunner });
   });
   let agentContinuePOST;
   let pluginTaskPOST;
   let conversationWorkOptions;
   const getConversationWorkOptions = () => {
     conversationWorkOptions ??= options?.conversationWork ?? createProductionConversationWorkOptions({
+      agentRunner,
       services: runtimeServiceOverrides
     });
     return conversationWorkOptions;