@sentry/junior 0.16.0 → 0.17.0

package/dist/app.js

@@ -7,7 +7,7 @@ import {
   logCapabilityCatalogLoadedOnce,
   parseSkillInvocation,
   stripFrontmatter
-} from "./chunk-ZU6X5ZGL.js";
+} from "./chunk-4XWTSMRF.js";
 import {
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
@@ -26,7 +26,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   toOptionalTrimmed
-} from "./chunk-3JKW7ISL.js";
+} from "./chunk-XYOKYK6U.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -55,7 +55,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-RUC2V7Q7.js";
+} from "./chunk-DTOS5CG4.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   aboutPathCandidates,
@@ -1937,9 +1937,7 @@ function createChannelConfigurationService(storage) {
   };
   const resolveValues = async (options = {}) => {
     const keys = Array.isArray(options.keys) ? options.keys.map((entry) => entry.trim()).filter((entry) => entry.length > 0) : void 0;
-    const entries = await list({
-      ...options.prefix ? { prefix: options.prefix } : {}
-    });
+    const entries = options.prefix ? await list({ prefix: options.prefix }) : await list({});
     const filtered = keys ? entries.filter((entry) => keys.includes(entry.key)) : entries;
     const resolved = {};
     for (const entry of filtered) {
@@ -2176,14 +2174,15 @@ function resolveGatewayModel(modelId) {
   return matched;
 }
 async function completeText(params) {
-  const startedAt = Date.now();
   const model = resolveGatewayModel(params.modelId);
   const apiKey = getPiGatewayApiKeyOverride();
   const requestMessagesAttribute = serializeGenAiAttribute(params.messages);
+  const systemInstructionsAttribute = params.system ? serializeGenAiAttribute([{ type: "text", content: params.system }]) : void 0;
   const startAttributes = {
     "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
     "gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
     "gen_ai.request.model": params.modelId,
+    ...systemInstructionsAttribute ? { "gen_ai.system_instructions": systemInstructionsAttribute } : {},
     ...requestMessagesAttribute ? { "gen_ai.input.messages": requestMessagesAttribute } : {},
     "app.ai.auth_mode": apiKey ? "oidc" : "api_key"
   };
@@ -2216,8 +2215,7 @@ async function completeText(params) {
     "gen_ai.request.model": params.modelId,
     ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
     ...usageAttributes,
-    "app.ai.duration_ms": Date.now() - startedAt,
-    "app.ai.stop_reason": message.stopReason ?? "unknown"
+    ...message.stopReason ? { "gen_ai.response.finish_reasons": [message.stopReason] } : {}
   };
   setSpanAttributes(endAttributes);
   if (message.stopReason === "error") {
@@ -2807,24 +2805,6 @@ function formatLoadedSkillsForPrompt(skills) {
   lines.push("</loaded_skills>");
   return lines.join("\n");
 }
-function formatLoadedToolsForPrompt(tools) {
-  if (tools.length === 0) {
-    return "<loaded_tools>\n</loaded_tools>";
-  }
-  const lines = ["<loaded_tools>"];
-  for (const tool2 of tools) {
-    lines.push(
-      `  <tool name="${escapeXml(tool2.tool_name)}" provider="${escapeXml(tool2.provider)}">`
-    );
-    lines.push(`    <description>${escapeXml(tool2.description)}</description>`);
-    lines.push(
-      `    <arguments_summary>${escapeXml(tool2.input_schema_summary)}</arguments_summary>`
-    );
-    lines.push("  </tool>");
-  }
-  lines.push("</loaded_tools>");
-  return lines.join("\n");
-}
 function formatProviderCatalogForPrompt() {
   const providers = listCapabilityProviders();
   if (providers.length === 0) {
@@ -2858,7 +2838,7 @@ function baseSystemPrompt() {
     "- Never claim you cannot access tools in this turn. If prior results are empty, run tools now.",
     "- If critical input is missing and cannot be discovered with tools, ask one direct clarifying question.",
     "- Always gather evidence from available sources (tools or skills) before answering factual questions.",
-    "- When a loaded skill exposes MCP capabilities, prefer the exact tool_name values disclosed by `loadSkill` or `<loaded_tools>`, then execute them with `useTool`.",
+    "- When a loaded skill exposes MCP capabilities, those tools are registered as callable tools. Call them directly by name.",
     "- Use `searchTools` only when you need to rediscover or filter active MCP tools.",
     "- Never guess. If you cannot verify with available sources, say it is unverified.",
     "- Never claim a lookup succeeded unless a tool result supports it.",
@@ -2899,10 +2879,8 @@ function buildSystemPrompt(params) {
     "Loaded skills for this turn:",
     formatLoadedSkillsForPrompt(activeSkills)
   ].join("\n");
-  const activeToolsSection = [
-    "Loaded host-managed tools for this turn. Use the exact tool_name values from here or from `loadSkill.available_tools`, and use `searchTools` only when you need to rediscover or filter them:",
-    formatLoadedToolsForPrompt(activeTools ?? [])
-  ].join("\n");
+  const activeToolNames = (activeTools ?? []).map((tool2) => tool2.tool_name);
+  const activeToolsSection = activeToolNames.length > 0 ? `Active MCP tools registered for this turn: ${activeToolNames.join(", ")}. Call them directly by name.` : "";
   const configurationKeys = Object.keys(configuration ?? {}).sort(
     (a, b) => a.localeCompare(b)
   );
@@ -3028,9 +3006,8 @@ function buildSystemPrompt(params) {
         "- Do not use reaction-based progress signals; Assistants API status already covers in-progress UX.",
         "- Prefer `webSearch` before `webFetch` when the user gave no URL.",
         "- Never call side-effecting tools when the user only asked for analysis or options.",
-        "- `loadSkill` returns `available_tools` when the loaded skill exposes MCP tools. Use those exact tool_name values instead of guessing.",
+        "- `loadSkill` activates MCP tools when the loaded skill exposes them. After loading, call them directly by name (for example `mcp__provider__tool_name`).",
         "- `searchTools` searches active MCP tools exposed by currently loaded skills when you need to rediscover or filter them.",
-        "- `useTool` executes a canonical MCP tool name from `loadSkill.available_tools`, `<loaded_tools>`, or `searchTools`.",
         "- When the user asks for their conversation ID, trace ID, or a reference for Sentry lookup, use the IDs from `<session-context>` and `<turn-context>` in the user turn."
       ].join("\n")
     ),
@@ -3046,7 +3023,7 @@ function buildSystemPrompt(params) {
         "- Never apply skill-specific behavior unless the skill is present in <loaded_skills> or `loadSkill` succeeded in this turn.",
         "- Load only the best matching skill first; do not load multiple skills upfront.",
         "- After `loadSkill`, use `skill_dir` as the root for any referenced files you read via `bash`.",
-        "- If a loaded skill exposes MCP tools, prefer the exact tool_name values returned by `loadSkill`, then use `useTool` to execute them.",
+        "- If a loaded skill exposes MCP tools, they are registered as callable tools after `loadSkill` returns. Call them directly by name.",
         "- Use `searchTools` only when you need to rediscover or filter the currently exposed MCP tools.",
         "- If no skill is a clear fit, continue with normal tool usage."
       ].join("\n")
@@ -3067,7 +3044,7 @@ function buildSystemPrompt(params) {
     ),
     availableSkillsSection,
     activeSkillsSection,
-    activeToolsSection,
+    ...activeToolsSection ? [activeToolsSection] : [],
     renderTag(
       "invocation-context",
       invocation ? `Explicit skill trigger detected: /${invocation.skillName}` : "No explicit skill trigger detected."
@@ -3760,9 +3737,7 @@ ${usage}
         exitCode: 2
       });
     }
-    const entries = await configuration.list({
-      ...prefixResult.prefix ? { prefix: prefixResult.prefix } : {}
-    });
+    const entries = prefixResult.prefix ? await configuration.list({ prefix: prefixResult.prefix }) : await configuration.list({});
     return commandResult({
       stdout: {
         ok: true,
@@ -3952,65 +3927,6 @@ async function maybeExecuteJrRpcCustomCommand(command, deps) {
   };
 }
 
-// src/chat/services/channel-intent.ts
-function isExplicitChannelPostIntent(text) {
-  if (!/\bchannel\b/i.test(text)) {
-    return false;
-  }
-  const directChannelVerb = /\b(show|post|send|share|say|announce|broadcast)\b[\s\S]{0,80}\b(?:the\s+)?channel\b/i;
-  if (directChannelVerb.test(text)) {
-    return true;
-  }
-  const scopedChannelVerb = /\b(post|send|share|say|announce|broadcast)\b[\s\S]{0,80}\b(?:in|to)\b[\s\S]{0,40}\b(?:the\s+)?channel\b/i;
-  return scopedChannelVerb.test(text);
-}
-
-// src/chat/services/reply-delivery-plan.ts
-var REACTION_ONLY_ACK_RE = /^(?::[a-z0-9_+-]+:|[\p{Extended_Pictographic}\uFE0F\u200D]+)$/u;
-var REDUNDANT_REACTION_ACK_TEXT = ["done", "got it", "ok", "okay"];
-var REACTION_ALIAS_PREFIX_RE = /^:[a-z0-9_+-]*$/i;
-function normalizeReactionAckText(text) {
-  return text.trim().toLowerCase().replace(/[!.]+$/g, "");
-}
-function isRedundantReactionAckText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return false;
-  }
-  if (REACTION_ONLY_ACK_RE.test(trimmed)) {
-    return true;
-  }
-  const normalized = normalizeReactionAckText(text);
-  return REDUNDANT_REACTION_ACK_TEXT.includes(
-    normalized
-  );
-}
-function isPotentialRedundantReactionAckText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return true;
-  }
-  if (REACTION_ONLY_ACK_RE.test(trimmed) || REACTION_ALIAS_PREFIX_RE.test(trimmed)) {
-    return true;
-  }
-  const normalized = normalizeReactionAckText(text);
-  return REDUNDANT_REACTION_ACK_TEXT.some(
-    (candidate) => candidate.startsWith(normalized)
-  );
-}
-function buildReplyDeliveryPlan(args) {
-  const mode = args.explicitChannelPostIntent && args.channelPostPerformed ? "channel_only" : "thread";
-  let attachFiles = "none";
-  if (args.hasFiles && mode === "thread") {
-    attachFiles = args.streamingThreadReply ? "followup" : "inline";
-  }
-  return {
-    mode,
-    postThreadText: mode === "thread",
-    attachFiles
-  };
-}
-
 // src/chat/sandbox/skill-sandbox.ts
 import fs2 from "fs/promises";
 import path2 from "path";
@@ -4210,9 +4126,6 @@ var SkillSandbox = class {
   }
 };
 
-// src/chat/mcp/tool-manager.ts
-import { validateToolArguments } from "@mariozechner/pi-ai";
-
 // src/chat/mcp/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client";
 import {
@@ -4392,6 +4305,12 @@ var PluginMcpClient = class {
 };
 
 // src/chat/mcp/tool-manager.ts
+var McpToolError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "McpToolError";
+  }
+};
 function normalizeMcpToolName(provider, toolName) {
   return `mcp__${provider}__${toolName}`;
 }
@@ -4575,13 +4494,6 @@ var McpToolManager = class {
       return left.tool.name.localeCompare(right.tool.name);
     }).slice(0, Math.max(1, options.limit ?? 8)).map((entry) => this.toToolDescriptor(entry.tool));
   }
-  async executeTool(skills, canonicalToolName, args) {
-    const tool2 = this.resolveActiveTool(skills, canonicalToolName);
-    if (!tool2) {
-      throw new Error(`Unknown active MCP tool: ${canonicalToolName}`);
-    }
-    return await tool2.execute(this.validateExecutionArgs(tool2, args));
-  }
   filterListedTools(plugin, tools) {
     const allowedTools = plugin.manifest.mcp?.allowedTools;
     if (!allowedTools || allowedTools.length === 0) {
@@ -4625,7 +4537,7 @@ var McpToolManager = class {
         try {
           const result = await client2.callTool(tool2.name, resolvedArgs);
           if ("isError" in result && result.isError) {
-            throw new Error(extractMcpErrorMessage(result));
+            throw new McpToolError(extractMcpErrorMessage(result));
           }
           return {
             content: toAgentToolContent(result),
@@ -4676,6 +4588,7 @@ var McpToolManager = class {
     this.activeProviders.delete(provider);
     return true;
   }
+  /** Return all active ManagedMcpTool objects for the given skill scope. */
   getResolvedActiveTools(skills, options = {}) {
     const resolved = [];
     for (const provider of this.getActiveProviders()) {
@@ -4699,11 +4612,6 @@ var McpToolManager = class {
     }
     return providerTools;
   }
-  resolveActiveTool(skills, canonicalToolName) {
-    return this.getResolvedActiveTools(skills).find(
-      (tool2) => tool2.name === canonicalToolName
-    );
-  }
   toToolDescriptor(tool2) {
     return {
       name: tool2.name,
@@ -4712,15 +4620,6 @@ var McpToolManager = class {
       provider: tool2.provider
     };
   }
-  validateExecutionArgs(tool2, args) {
-    return validateToolArguments(
-      tool2,
-      {
-        name: tool2.name,
-        arguments: args
-      }
-    );
-  }
   scoreToolMatch(tool2, normalizedQuery, queryTokens) {
     const exactCandidates = [tool2.name, tool2.rawName, tool2.title].filter((value) => Boolean(value)).map((value) => value.toLowerCase());
     if (exactCandidates.includes(normalizedQuery)) {
@@ -5186,7 +5085,7 @@ var DEFAULT_LIMIT = 5;
 var MAX_LIMIT = 20;
 function createSearchToolsTool(mcpToolManager, getActiveSkills) {
   return tool({
-    description: "Search active MCP tools exposed by the currently loaded skills. Use when you need to rediscover or filter tools beyond what `loadSkill` or `<loaded_tools>` already disclosed.",
+    description: "Search active MCP tools exposed by the currently loaded skills. Use when you need to rediscover or filter active tools.",
     inputSchema: Type6.Object(
       {
         query: Type6.String({
@@ -6262,45 +6161,8 @@ function createSystemTimeTool() {
   });
 }
 
-// src/chat/tools/skill/use-tool.ts
-import { Type as Type13 } from "@sinclair/typebox";
-function normalizeToolArguments(value) {
-  return value ?? {};
-}
-function createUseToolTool(mcpToolManager, getActiveSkills) {
-  return tool({
-    description: "Execute an active MCP tool by canonical tool_name. Use tool_name values disclosed by `loadSkill`, `<loaded_tools>`, or `searchTools`.",
-    inputSchema: Type13.Object(
-      {
-        tool_name: Type13.String({
-          minLength: 1,
-          description: "Canonical MCP tool name in the form mcp__<provider>__<tool>."
-        }),
-        arguments: Type13.Optional(
-          Type13.Object(
-            {},
-            {
-              additionalProperties: true,
-              description: "Arguments for the selected MCP tool."
-            }
-          )
-        )
-      },
-      { additionalProperties: false }
-    ),
-    execute: async ({ tool_name, arguments: rawArguments }) => {
-      const activeSkills = getActiveSkills();
-      return await mcpToolManager.executeTool(
-        activeSkills,
-        tool_name,
-        normalizeToolArguments(rawArguments)
-      );
-    }
-  });
-}
-
 // src/chat/tools/web/fetch-tool.ts
-import { Type as Type14 } from "@sinclair/typebox";
+import { Type as Type13 } from "@sinclair/typebox";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -6648,13 +6510,13 @@ function extractHttpStatusFromMessage(message) {
 function createWebFetchTool(hooks) {
   return tool({
     description: "Fetch and extract readable content from a specific URL. Use when you need details from a known page or document. Do not use for discovery when search is the first step.",
-    inputSchema: Type14.Object({
-      url: Type14.String({
+    inputSchema: Type13.Object({
+      url: Type13.String({
         minLength: 1,
         description: "HTTP(S) URL to fetch."
       }),
-      max_chars: Type14.Optional(
-        Type14.Integer({
+      max_chars: Type13.Optional(
+        Type13.Integer({
           minimum: 500,
           maximum: MAX_FETCH_CHARS,
           description: "Optional maximum number of extracted characters to return."
@@ -6714,7 +6576,7 @@ function createWebFetchTool(hooks) {
 // src/chat/tools/web/search.ts
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
-import { Type as Type15 } from "@sinclair/typebox";
+import { Type as Type14 } from "@sinclair/typebox";
 var SEARCH_TIMEOUT_MS = 1e4;
 var MAX_RESULTS = 5;
 var DEFAULT_SEARCH_MODEL = "xai/grok-4-fast-reasoning";
@@ -6765,14 +6627,14 @@ function isTimeoutSearchFailure(message) {
 function createWebSearchTool() {
   return tool({
     description: "Search public web sources and return top snippets/URLs. Use when you need discovery or source candidates. Do not use when the user already provided a specific URL to inspect.",
-    inputSchema: Type15.Object({
-      query: Type15.String({
+    inputSchema: Type14.Object({
+      query: Type14.String({
         minLength: 1,
         maxLength: 500,
         description: "Search query."
       }),
-      max_results: Type15.Optional(
-        Type15.Integer({
+      max_results: Type14.Optional(
+        Type14.Integer({
           minimum: 1,
           maximum: MAX_RESULTS,
           description: "Max results to return."
@@ -6833,17 +6695,17 @@ function createWebSearchTool() {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { Type as Type16 } from "@sinclair/typebox";
+import { Type as Type15 } from "@sinclair/typebox";
 function createWriteFileTool() {
   return tool({
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or replacement after validation. Do not use for exploratory analysis-only turns.",
-    inputSchema: Type16.Object(
+    inputSchema: Type15.Object(
       {
-        path: Type16.String({
+        path: Type15.String({
           minLength: 1,
           description: "Path to write in the sandbox workspace."
         }),
-        content: Type16.String({
+        content: Type15.String({
           description: "UTF-8 file content to write."
         })
       },
@@ -6963,20 +6825,16 @@ function createTools(availableSkills, hooks = {}, context) {
       createSearchToolsTool(context.mcpToolManager, context.getActiveSkills),
       hooks
     );
-    tools.useTool = wrapToolExecution(
-      "useTool",
-      createUseToolTool(context.mcpToolManager, context.getActiveSkills),
-      hooks
-    );
   }
-  if (isConversationScopedChannel(context.channelId)) {
+  const { channelCapabilities } = context;
+  if (channelCapabilities.canCreateCanvas) {
     tools.slackCanvasCreate = wrapToolExecution(
       "slackCanvasCreate",
       createSlackCanvasCreateTool(context, state),
       hooks
     );
   }
-  if (isConversationChannel(context.channelId)) {
+  if (channelCapabilities.canPostToChannel) {
     tools.slackChannelPostMessage = wrapToolExecution(
       "slackChannelPostMessage",
       createSlackChannelPostMessageTool(context, state),
@@ -6988,7 +6846,7 @@ function createTools(availableSkills, hooks = {}, context) {
       hooks
     );
   }
-  if (isConversationScopedChannel(context.channelId)) {
+  if (channelCapabilities.canAddReactions) {
     tools.slackMessageAddReaction = wrapToolExecution(
       "slackMessageAddReaction",
       createSlackMessageAddReactionTool(context, state),
@@ -6998,6 +6856,15 @@ function createTools(availableSkills, hooks = {}, context) {
   return tools;
 }
 
+// src/chat/tools/channel-capabilities.ts
+function resolveChannelCapabilities(channelId) {
+  return {
+    canCreateCanvas: isConversationScopedChannel(channelId),
+    canPostToChannel: isConversationChannel(channelId),
+    canAddReactions: isConversationScopedChannel(channelId)
+  };
+}
+
 // src/chat/sandbox/sandbox.ts
 import fs3 from "fs/promises";
 import path4 from "path";
@@ -7939,6 +7806,8 @@ function createSandboxExecutor(options) {
           pathPrefix: `${SANDBOX_RUNTIME_BIN_DIR}:$PATH`
         });
         let commandError;
+        let result;
+        let restoreError;
         try {
           const commandResult2 = await activeSandbox.runCommand({
             cmd: "bash",
@@ -7954,7 +7823,7 @@ function createSandboxExecutor(options) {
           const stderrRaw = await commandResult2.stderr();
           const stdout = truncateOutput(stdoutRaw, boundedOutputLength);
           const stderr = truncateOutput(stderrRaw, boundedOutputLength);
-          return {
+          result = {
             stdout: stdout.value,
             stderr: stderr.value,
             exitCode: commandResult2.exitCode,
@@ -7968,14 +7837,16 @@ function createSandboxExecutor(options) {
           if (headerTransforms && headerTransforms.length > 0) {
             try {
               await activeSandbox.updateNetworkPolicy(restoreNetworkPolicy);
-            } catch (restoreError) {
-              await invalidateSandboxInstance(activeSandbox, restoreError);
-              if (!commandError) {
-                throw restoreError;
-              }
+            } catch (error) {
+              restoreError = error;
+              await invalidateSandboxInstance(activeSandbox, error);
             }
           }
         }
+        if (restoreError && !commandError) {
+          throw restoreError;
+        }
+        return result;
       },
       readFile: async (input) => await executeReadFile(input, {
         toolCallId: "sandbox-read-file",
@@ -8198,95 +8069,6 @@ function shouldEmitDevAgentTrace() {
   return process.env.NODE_ENV === "development";
 }
 
-// src/chat/state/turn-session-store.ts
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function parseAgentTurnSessionCheckpoint(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(parsed)) {
-      return void 0;
-    }
-    const status = parsed.state;
-    if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed") {
-      return void 0;
-    }
-    const conversationId = parsed.conversationId;
-    const sessionId = parsed.sessionId;
-    const sliceId = parsed.sliceId;
-    const checkpointVersion = parsed.checkpointVersion;
-    const updatedAtMs = parsed.updatedAtMs;
-    if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
-      return void 0;
-    }
-    return {
-      checkpointVersion,
-      conversationId,
-      sessionId,
-      sliceId,
-      state: status,
-      updatedAtMs,
-      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
-      ...Array.isArray(parsed.loadedSkillNames) ? {
-        loadedSkillNames: parsed.loadedSkillNames.filter(
-          (value2) => typeof value2 === "string"
-        )
-      } : {},
-      ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
-      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  return parseAgentTurnSessionCheckpoint(value);
-}
-async function upsertAgentTurnSessionCheckpoint(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const existing = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.sessionId
-  );
-  const checkpoint = {
-    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: Date.now(),
-    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
-    ...Array.isArray(args.loadedSkillNames) ? {
-      loadedSkillNames: args.loadedSkillNames.filter(
-        (value) => typeof value === "string"
-      )
-    } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
-  };
-  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await stateAdapter.set(
-    agentTurnSessionKey(args.conversationId, args.sessionId),
-    JSON.stringify(checkpoint),
-    ttlMs
-  );
-  return checkpoint;
-}
-
 // src/chat/runtime/status-format.ts
 var SLACK_STATUS_MAX_LENGTH = 50;
 function truncateWithEllipsis(text, maxLength) {
@@ -8433,20 +8215,6 @@ function extractStatusUrlDomain(value) {
 }
 
 // src/chat/runtime/tool-status.ts
-function formatCanonicalToolStatusName(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  const mcpMatch = /^mcp__([^_]+)__(.+)$/.exec(trimmed);
-  if (mcpMatch) {
-    return compactStatusText(`${mcpMatch[1]}/${mcpMatch[2]}`, 40);
-  }
-  return compactStatusText(trimmed, 40);
-}
 function formatToolStatus(toolName) {
   const known = {
     loadSkill: "Loading skill instructions",
@@ -8465,12 +8233,15 @@ function formatToolStatus(toolName) {
     slackListAddItems: "Updating tracking list",
     slackListUpdateItem: "Updating tracking list",
     imageGenerate: "Generating image",
-    searchTools: "Searching active tools",
-    useTool: "Running active tool"
+    searchTools: "Searching active tools"
   };
   if (known[toolName]) {
     return known[toolName];
   }
+  const mcpMatch = /^mcp__([^_]+)__(.+)$/.exec(toolName);
+  if (mcpMatch) {
+    return `Running ${mcpMatch[1]}/${mcpMatch[2]}`;
+  }
   const readable = toolName.replaceAll("_", " ").trim();
   return readable.length > 0 ? `Running ${readable}` : "Running tool";
 }
@@ -8483,7 +8254,6 @@ function formatToolStatusWithInput(toolName, input) {
   const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
   const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
   const provider = obj ? compactStatusText(obj.provider, 20) : void 0;
-  const activeToolName = obj ? formatCanonicalToolStatusName(obj.tool_name ?? obj.toolName) : void 0;
   if (command && toolName === "bash") {
     return `Running ${command}`;
   }
@@ -8508,25 +8278,57 @@ function formatToolStatusWithInput(toolName, input) {
   if (query && toolName === "searchTools") {
     return `Searching tools for "${query}"`;
   }
-  if (activeToolName && toolName === "useTool") {
-    return `Running ${activeToolName}`;
-  }
   if (domain && toolName === "webFetch") {
     return `Fetching page from ${domain}`;
   }
   return formatToolStatus(toolName);
 }
 
-// src/chat/tools/agent-tools.ts
-import { Value } from "@sinclair/typebox/value";
-function toToolContentText(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
+// src/chat/tools/execution/build-sandbox-input.ts
+function buildSandboxInput(toolName, params) {
+  if (toolName === "bash") {
+    return { command: String(params.command ?? "") };
+  }
+  if (toolName === "readFile") {
+    return { path: String(params.path ?? "") };
+  }
+  if (toolName === "writeFile") {
+    return {
+      path: String(params.path ?? ""),
+      content: String(params.content ?? "")
+    };
+  }
+  return params;
+}
+
+// src/chat/tools/execution/inject-credentials.ts
+function resolveCredentialInjection(toolName, command, capabilityRuntime, sandbox) {
+  if (toolName !== "bash" || !capabilityRuntime) {
+    return {};
+  }
+  const headerTransforms = capabilityRuntime.getTurnHeaderTransforms();
+  const env = capabilityRuntime.getTurnEnv();
+  const isCustomCommand = /^jr-rpc(?:\s|$)/.test(command.trim());
+  const shouldLog = !isCustomCommand && Boolean(headerTransforms && headerTransforms.length > 0);
+  if (shouldLog) {
+    const headerDomains = (headerTransforms ?? []).map(
+      (transform) => transform.domain
+    );
+    logInfo(
+      "credential_inject_start",
+      {},
+      {
+        "app.skill.name": sandbox.getActiveSkill()?.name,
+        "app.credential.delivery": "header_transform",
+        "app.credential.header_domains": headerDomains
+      },
+      "Injecting scoped credential headers for sandbox command"
+    );
   }
+  return { headerTransforms, env };
 }
+
+// src/chat/tools/execution/normalize-result.ts
 function isStructuredToolExecutionResult(value) {
   const content = value?.content;
   return typeof value === "object" && value !== null && Array.isArray(content) && content.every((part) => {
@@ -8543,9 +8345,29 @@ function isStructuredToolExecutionResult(value) {
     return false;
   }) && "details" in value;
 }
-function getToolErrorAttributes(error) {
-  if (!(error instanceof SlackActionError)) {
-    return {};
+function toToolContentText(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function normalizeToolResult(result, isSandboxResult) {
+  const unwrapped = isSandboxResult && result && typeof result === "object" && "result" in result ? result.result : result;
+  if (isStructuredToolExecutionResult(unwrapped)) {
+    return unwrapped;
+  }
+  return {
+    content: [{ type: "text", text: toToolContentText(unwrapped) }],
+    details: unwrapped
+  };
+}
+
+// src/chat/tools/execution/tool-error-handler.ts
+function getToolErrorAttributes(error) {
+  if (!(error instanceof SlackActionError)) {
+    return {};
   }
   return {
     "app.slack.error_code": error.code,
@@ -8555,6 +8377,44 @@ function getToolErrorAttributes(error) {
     ...error.detailRule ? { "app.slack.detail_rule": error.detailRule } : {}
   };
 }
+function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext) {
+  setSpanAttributes({
+    "error.type": error instanceof Error ? error.name : "tool_execution_error"
+  });
+  if (shouldTrace) {
+    logWarn(
+      "agent_tool_call_failed",
+      traceContext,
+      {
+        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": toolName,
+        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+        "error.type": error instanceof Error ? error.name : "tool_execution_error",
+        "error.message": error instanceof Error ? error.message : String(error)
+      },
+      "Agent tool call failed"
+    );
+  }
+  if (!(error instanceof McpToolError)) {
+    logException(
+      error,
+      "agent_tool_call_failed",
+      {},
+      {
+        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": toolName,
+        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+        ...getToolErrorAttributes(error)
+      },
+      "Agent tool call failed"
+    );
+  }
+  throw error;
+}
+
+// src/chat/tools/agent-tools.ts
 function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, capabilityRuntime, hooks) {
   const shouldTrace = shouldEmitDevAgentTrace();
   return Object.entries(tools).map(([toolName, toolDef]) => ({
@@ -8566,7 +8426,6 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
       const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
       const toolArgumentsAttribute = serializeGenAiAttribute(params);
       hooks?.onToolCall?.(toolName);
-      const toolStartedAt = Date.now();
       const traceToolContext = {
         ...spanContext,
         conversationId: spanContext.conversationId,
@@ -8579,163 +8438,65 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
         "gen_ai.execute_tool",
         spanContext,
         async () => {
-          if (!Value.Check(toolDef.inputSchema, params)) {
-            const details = [...Value.Errors(toolDef.inputSchema, params)].slice(0, 3).map((entry) => `${entry.path || "/"}: ${entry.message}`).join("; ");
-            const validationMessage = details.length > 0 ? details : "Invalid tool input";
-            const durationMs = Date.now() - toolStartedAt;
-            setSpanAttributes({
-              "app.ai.tool_duration_ms": durationMs,
-              "error.type": "tool_input_validation_error"
-            });
-            setSpanStatus("error");
-            logWarn(
-              "agent_tool_call_invalid_input",
-              {},
-              {
-                "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-                "gen_ai.operation.name": "execute_tool",
-                "gen_ai.tool.name": toolName,
-                ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
-                "app.ai.tool_duration_ms": durationMs
-              },
-              "Agent tool call input validation failed"
-            );
-            logException(
-              new Error(validationMessage),
-              "agent_tool_call_invalid_input_exception",
-              {},
-              {
-                "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-                "gen_ai.operation.name": "execute_tool",
-                "gen_ai.tool.name": toolName,
-                ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
-                "app.ai.tool_duration_ms": durationMs
-              },
-              "Agent tool call input validation failed with exception"
-            );
-            throw new Error(validationMessage);
-          }
           const parsed = params;
           try {
             if (typeof toolDef.execute !== "function") {
-              const resultDetails2 = { ok: true };
-              const durationMs2 = Date.now() - toolStartedAt;
-              const toolResultAttribute2 = serializeGenAiAttribute(resultDetails2);
-              setSpanAttributes({
-                "app.ai.tool_duration_ms": durationMs2,
-                "app.ai.tool_outcome": "success",
-                ...toolResultAttribute2 ? { "gen_ai.tool.call.result": toolResultAttribute2 } : {}
-              });
-              setSpanStatus("ok");
+              const resultDetails = { ok: true };
+              const toolResultAttribute2 = serializeGenAiAttribute(resultDetails);
+              if (toolResultAttribute2) {
+                setSpanAttributes({
+                  "gen_ai.tool.call.result": toolResultAttribute2
+                });
+              }
               return {
                 content: [{ type: "text", text: "ok" }],
-                details: resultDetails2
+                details: resultDetails
               };
             }
-            const injectedHeaders = toolName === "bash" ? capabilityRuntime?.getTurnHeaderTransforms() : void 0;
-            const injectedEnv = toolName === "bash" ? capabilityRuntime?.getTurnEnv() : void 0;
             const bashCommand = toolName === "bash" && typeof parsed.command === "string" ? parsed.command.trim() : "";
-            const isCustomBashCommand = toolName === "bash" && /^jr-rpc(?:\s|$)/.test(bashCommand);
-            const shouldLogCredentialInjection = toolName === "bash" && !isCustomBashCommand && Boolean(injectedHeaders && injectedHeaders.length > 0);
-            if (shouldLogCredentialInjection) {
-              const headerDomains = (injectedHeaders ?? []).map(
-                (transform) => transform.domain
-              );
-              logInfo(
-                "credential_inject_start",
-                {},
-                {
-                  "app.skill.name": sandbox.getActiveSkill()?.name,
-                  "app.credential.delivery": "header_transform",
-                  "app.credential.header_domains": headerDomains
-                },
-                "Injecting scoped credential headers for sandbox command"
-              );
-            }
-            const hasBashCredentials = injectedHeaders || injectedEnv;
-            const sandboxInput = toolName === "bash" ? { command: String(parsed.command ?? "") } : toolName === "readFile" ? { path: String(parsed.path ?? "") } : toolName === "writeFile" ? {
-              path: String(parsed.path ?? ""),
-              content: String(parsed.content ?? "")
-            } : parsed;
-            const result = sandboxExecutor?.canExecute(toolName) ? await sandboxExecutor.execute({
+            const injection = resolveCredentialInjection(
               toolName,
-              input: toolName === "bash" && hasBashCredentials ? {
+              bashCommand,
+              capabilityRuntime,
+              sandbox
+            );
+            const sandboxInput = buildSandboxInput(toolName, parsed);
+            const isSandbox = Boolean(sandboxExecutor?.canExecute(toolName));
+            const result = isSandbox ? await sandboxExecutor.execute({
+              toolName,
+              input: toolName === "bash" && (injection.headerTransforms || injection.env) ? {
                 ...sandboxInput,
-                ...injectedHeaders ? { headerTransforms: injectedHeaders } : {},
-                ...injectedEnv ? { env: injectedEnv } : {}
+                ...injection.headerTransforms ? { headerTransforms: injection.headerTransforms } : {},
+                ...injection.env ? { env: injection.env } : {}
               } : sandboxInput
             }) : await toolDef.execute(parsed, {
               experimental_context: sandbox
             });
-            const resultDetails = sandboxExecutor?.canExecute(toolName) && result && typeof result === "object" && "result" in result ? result.result : result;
-            const durationMs = Date.now() - toolStartedAt;
-            const structuredToolResult = isStructuredToolExecutionResult(
-              resultDetails
-            ) ? resultDetails : void 0;
+            const normalized = normalizeToolResult(result, isSandbox);
             const toolResultAttribute = serializeGenAiAttribute(
-              structuredToolResult?.details ?? resultDetails
+              normalized.details
             );
-            setSpanAttributes({
-              "app.ai.tool_duration_ms": durationMs,
-              "app.ai.tool_outcome": "success",
-              ...toolResultAttribute ? { "gen_ai.tool.call.result": toolResultAttribute } : {}
-            });
-            setSpanStatus("ok");
-            if (structuredToolResult) {
-              return structuredToolResult;
+            if (toolResultAttribute) {
+              setSpanAttributes({
+                "gen_ai.tool.call.result": toolResultAttribute
+              });
             }
-            return {
-              content: [
-                { type: "text", text: toToolContentText(resultDetails) }
-              ],
-              details: resultDetails
-            };
+            return normalized;
           } catch (error) {
-            const durationMs = Date.now() - toolStartedAt;
-            setSpanAttributes({
-              "app.ai.tool_duration_ms": durationMs,
-              "app.ai.tool_outcome": "error",
-              "error.type": error instanceof Error ? error.name : "tool_execution_error"
-            });
-            setSpanStatus("error");
-            if (shouldTrace) {
-              logWarn(
-                "agent_tool_call_failed",
-                traceToolContext,
-                {
-                  "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-                  "gen_ai.operation.name": "execute_tool",
-                  "gen_ai.tool.name": toolName,
-                  ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
-                  "app.ai.tool_duration_ms": durationMs,
-                  "app.ai.tool_outcome": "error",
-                  "error.type": error instanceof Error ? error.name : "tool_execution_error",
-                  "error.message": error instanceof Error ? error.message : String(error)
-                },
-                "Agent tool call failed"
-              );
-            }
-            logException(
+            handleToolExecutionError(
               error,
-              "agent_tool_call_failed",
-              {},
-              {
-                "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-                "gen_ai.operation.name": "execute_tool",
-                "gen_ai.tool.name": toolName,
-                ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
-                "app.ai.tool_duration_ms": durationMs,
-                ...getToolErrorAttributes(error)
-              },
-              "Agent tool call failed"
+              toolName,
+              normalizedToolCallId,
+              shouldTrace,
+              traceToolContext
             );
-            throw error;
           }
         },
         {
           "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
           "gen_ai.operation.name": "execute_tool",
           "gen_ai.tool.name": toolName,
+          "gen_ai.tool.description": toolDef.description,
           ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
           ...toolArgumentsAttribute ? { "gen_ai.tool.call.arguments": toolArgumentsAttribute } : {}
         }
@@ -8804,6 +8565,65 @@ function resolveReplyDelivery(args) {
   };
 }
 
+// src/chat/services/reply-delivery-plan.ts
+var REACTION_ONLY_ACK_RE = /^(?::[a-z0-9_+-]+:|[\p{Extended_Pictographic}\uFE0F\u200D]+)$/u;
+var REDUNDANT_REACTION_ACK_TEXT = ["done", "got it", "ok", "okay"];
+var REACTION_ALIAS_PREFIX_RE = /^:[a-z0-9_+-]*$/i;
+function normalizeReactionAckText(text) {
+  return text.trim().toLowerCase().replace(/[!.]+$/g, "");
+}
+function isRedundantReactionAckText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (REACTION_ONLY_ACK_RE.test(trimmed)) {
+    return true;
+  }
+  const normalized = normalizeReactionAckText(text);
+  return REDUNDANT_REACTION_ACK_TEXT.includes(
+    normalized
+  );
+}
+function isPotentialRedundantReactionAckText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return true;
+  }
+  if (REACTION_ONLY_ACK_RE.test(trimmed) || REACTION_ALIAS_PREFIX_RE.test(trimmed)) {
+    return true;
+  }
+  const normalized = normalizeReactionAckText(text);
+  return REDUNDANT_REACTION_ACK_TEXT.some(
+    (candidate) => candidate.startsWith(normalized)
+  );
+}
+function buildReplyDeliveryPlan(args) {
+  const mode = args.explicitChannelPostIntent && args.channelPostPerformed ? "channel_only" : "thread";
+  let attachFiles = "none";
+  if (args.hasFiles && mode === "thread") {
+    attachFiles = args.streamingThreadReply ? "followup" : "inline";
+  }
+  return {
+    mode,
+    postThreadText: mode === "thread",
+    attachFiles
+  };
+}
+
+// src/chat/services/channel-intent.ts
+function isExplicitChannelPostIntent(text) {
+  if (!/\bchannel\b/i.test(text)) {
+    return false;
+  }
+  const directChannelVerb = /\b(show|post|send|share|say|announce|broadcast)\b[\s\S]{0,80}\b(?:the\s+)?channel\b/i;
+  if (directChannelVerb.test(text)) {
+    return true;
+  }
+  const scopedChannelVerb = /\b(post|send|share|say|announce|broadcast)\b[\s\S]{0,80}\b(?:in|to)\b[\s\S]{0,40}\b(?:the\s+)?channel\b/i;
+  return scopedChannelVerb.test(text);
+}
+
 // src/chat/services/attachment-claims.ts
 function splitSentences(text) {
   return text.split(/\n+/).flatMap((line) => line.split(/(?<=[.!?])\s+/)).map((part) => part.trim()).filter((part) => part.length > 0);
@@ -8833,8 +8653,268 @@ function enforceAttachmentClaimTruth(text, hasAttachedFiles) {
 Note: No file was attached in this turn. I need to attach the file before claiming it is shared.`;
 }
 
-// src/chat/respond.ts
-var startupDiscoveryLogged = false;
+// src/chat/services/turn-result.ts
+function buildTurnResult(input) {
+  const {
+    newMessages,
+    userInput,
+    replyFiles,
+    artifactStatePatch,
+    toolCalls,
+    sandboxId,
+    sandboxDependencyProfileHash,
+    hasTextDeltaCallback,
+    shouldTrace,
+    spanContext,
+    correlation,
+    assistantUserName
+  } = input;
+  const toolResults = newMessages.filter(isToolResultMessage);
+  const assistantMessages = newMessages.filter(isAssistantMessage);
+  const primaryText = assistantMessages.map((message) => extractAssistantText(message)).join("\n\n").trim();
+  const oauthStartedMessage = extractOAuthStartedMessageFromToolResults(toolResults);
+  const toolErrorCount = toolResults.filter((result) => result.isError).length;
+  const explicitChannelPostIntent = isExplicitChannelPostIntent(userInput);
+  const successfulToolNames = new Set(
+    toolResults.filter((result) => !isToolResultError(result)).map((result) => normalizeToolNameFromResult(result)).filter((value) => Boolean(value))
+  );
+  const channelPostPerformed = successfulToolNames.has(
+    "slackChannelPostMessage"
+  );
+  const deliveryPlan = buildReplyDeliveryPlan({
+    explicitChannelPostIntent,
+    channelPostPerformed,
+    hasFiles: replyFiles.length > 0,
+    streamingThreadReply: hasTextDeltaCallback
+  });
+  const deliveryMode = deliveryPlan.mode;
+  if (!primaryText && !oauthStartedMessage) {
+    logWarn(
+      "ai_model_response_empty",
+      {
+        slackThreadId: correlation?.threadId,
+        slackUserId: correlation?.requesterId,
+        slackChannelId: correlation?.channelId,
+        runId: correlation?.runId,
+        assistantUserName,
+        modelId: botConfig.modelId
+      },
+      {
+        "app.ai.tool_results": toolResults.length,
+        "app.ai.tool_error_results": toolErrorCount,
+        "app.ai.generated_files": input.generatedFileCount
+      },
+      "Model returned empty text response"
+    );
+  }
+  const lastAssistant = assistantMessages.at(-1);
+  const stopReason = typeof lastAssistant?.stopReason === "string" ? lastAssistant.stopReason : void 0;
+  const errorMessage = typeof lastAssistant?.errorMessage === "string" ? lastAssistant.errorMessage : void 0;
+  const usedPrimaryText = Boolean(primaryText);
+  const outcome = primaryText || oauthStartedMessage ? stopReason === "error" ? "provider_error" : "success" : "execution_failure";
+  const fallbackText = oauthStartedMessage ?? buildExecutionFailureMessage(toolErrorCount);
+  const responseText = primaryText || fallbackText;
+  const escapedOrRawPayload = Boolean(primaryText) && (isExecutionEscapeResponse(primaryText) || isRawToolPayloadResponse(primaryText));
+  const resolvedText = escapedOrRawPayload ? fallbackText : enforceAttachmentClaimTruth(responseText, replyFiles.length > 0);
+  const resolvedOutcome = escapedOrRawPayload ? oauthStartedMessage ? outcome : "execution_failure" : outcome;
+  if (shouldTrace) {
+    logInfo(
+      "agent_message_out",
+      spanContext,
+      {
+        "app.message.kind": "assistant_outbound",
+        "app.message.length": resolvedText.length,
+        "app.message.output": summarizeMessageText(resolvedText),
+        "app.ai.outcome": resolvedOutcome,
+        "app.ai.assistant_messages": assistantMessages.length,
+        ...stopReason ? { "gen_ai.response.finish_reasons": [stopReason] } : {}
+      },
+      "Agent message sent"
+    );
+  }
+  const resolvedDiagnostics = {
+    outcome: resolvedOutcome,
+    modelId: botConfig.modelId,
+    assistantMessageCount: assistantMessages.length,
+    toolCalls,
+    toolResultCount: toolResults.length,
+    toolErrorCount,
+    usedPrimaryText,
+    stopReason,
+    errorMessage,
+    providerError: void 0
+  };
+  return {
+    text: resolvedText,
+    files: replyFiles.length > 0 ? replyFiles : void 0,
+    artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
+    deliveryPlan,
+    deliveryMode,
+    sandboxId,
+    sandboxDependencyProfileHash,
+    diagnostics: resolvedDiagnostics
+  };
+}
+
+// src/chat/state/turn-session-store.ts
+var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+function agentTurnSessionKey(conversationId, sessionId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
+}
+function parseAgentTurnSessionCheckpoint(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord(parsed)) {
+      return void 0;
+    }
+    const status = parsed.state;
+    if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed") {
+      return void 0;
+    }
+    const conversationId = parsed.conversationId;
+    const sessionId = parsed.sessionId;
+    const sliceId = parsed.sliceId;
+    const checkpointVersion = parsed.checkpointVersion;
+    const updatedAtMs = parsed.updatedAtMs;
+    if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
+      return void 0;
+    }
+    return {
+      checkpointVersion,
+      conversationId,
+      sessionId,
+      sliceId,
+      state: status,
+      updatedAtMs,
+      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
+      ...Array.isArray(parsed.loadedSkillNames) ? {
+        loadedSkillNames: parsed.loadedSkillNames.filter(
+          (value2) => typeof value2 === "string"
+        )
+      } : {},
+      ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
+      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
+      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const value = await stateAdapter.get(
+    agentTurnSessionKey(conversationId, sessionId)
+  );
+  return parseAgentTurnSessionCheckpoint(value);
+}
+async function upsertAgentTurnSessionCheckpoint(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const existing = await getAgentTurnSessionCheckpoint(
+    args.conversationId,
+    args.sessionId
+  );
+  const checkpoint = {
+    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    state: args.state,
+    updatedAtMs: Date.now(),
+    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
+    ...Array.isArray(args.loadedSkillNames) ? {
+      loadedSkillNames: args.loadedSkillNames.filter(
+        (value) => typeof value === "string"
+      )
+    } : {},
+    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
+  };
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  await stateAdapter.set(
+    agentTurnSessionKey(args.conversationId, args.sessionId),
+    JSON.stringify(checkpoint),
+    ttlMs
+  );
+  return checkpoint;
+}
+
+// src/chat/services/turn-checkpoint.ts
+async function loadTurnCheckpoint(ctx) {
+  const canUseTurnSession = Boolean(ctx.conversationId && ctx.sessionId);
+  const existingCheckpoint = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionCheckpoint(ctx.conversationId, ctx.sessionId) : void 0;
+  const hasAwaitingResumeCheckpoint = Boolean(
+    existingCheckpoint && existingCheckpoint.state === "awaiting_resume" && existingCheckpoint.piMessages.length > 0
+  );
+  return {
+    canUseTurnSession,
+    resumedFromCheckpoint: hasAwaitingResumeCheckpoint,
+    currentSliceId: hasAwaitingResumeCheckpoint ? existingCheckpoint.sliceId : 1,
+    existingCheckpoint
+  };
+}
+async function persistCompletedCheckpoint(args) {
+  await upsertAgentTurnSessionCheckpoint({
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    state: "completed",
+    piMessages: args.allMessages,
+    loadedSkillNames: args.loadedSkillNames
+  });
+}
+async function persistAuthPauseCheckpoint(args) {
+  const nextSliceId = args.currentSliceId + 1;
+  try {
+    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+      args.conversationId,
+      args.sessionId
+    );
+    const piMessages = trimTrailingAssistantMessages(
+      args.messages.length > 0 ? args.messages : latestCheckpoint?.piMessages ?? []
+    );
+    await upsertAgentTurnSessionCheckpoint({
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      sliceId: nextSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      loadedSkillNames: args.loadedSkillNames,
+      resumeReason: "auth",
+      resumedFromSliceId: args.currentSliceId,
+      errorMessage: args.errorMessage
+    });
+  } catch (checkpointError) {
+    logException(
+      checkpointError,
+      "agent_turn_auth_resume_checkpoint_failed",
+      {
+        slackThreadId: args.logContext.threadId,
+        slackUserId: args.logContext.requesterId,
+        slackChannelId: args.logContext.channelId,
+        runId: args.logContext.runId,
+        assistantUserName: args.logContext.assistantUserName,
+        modelId: args.logContext.modelId
+      },
+      {
+        "app.ai.resume_conversation_id": args.conversationId,
+        "app.ai.resume_session_id": args.sessionId,
+        "app.ai.resume_from_slice_id": args.currentSliceId,
+        "app.ai.resume_next_slice_id": nextSliceId
+      },
+      "Failed to persist auth checkpoint before retry"
+    );
+  }
+  return nextSliceId;
+}
+
+// src/chat/services/mcp-auth-orchestration.ts
 var McpAuthorizationPauseError = class extends Error {
   provider;
   constructor(provider) {
@@ -8843,6 +8923,86 @@ var McpAuthorizationPauseError = class extends Error {
     this.provider = provider;
   }
 };
+function createMcpAuthOrchestration(deps, abortAgent) {
+  let pendingPause;
+  const authSessionIdsByProvider = /* @__PURE__ */ new Map();
+  const authProviderFactory = async (plugin) => {
+    if (!deps.conversationId || !deps.sessionId || !deps.requesterId) {
+      return void 0;
+    }
+    const provider = await createMcpOAuthClientProvider({
+      provider: plugin.manifest.name,
+      conversationId: deps.conversationId,
+      sessionId: deps.sessionId,
+      userId: deps.requesterId,
+      userMessage: deps.userMessage,
+      ...deps.channelId ? { channelId: deps.channelId } : {},
+      ...deps.threadTs ? { threadTs: deps.threadTs } : {},
+      ...deps.toolChannelId ? { toolChannelId: deps.toolChannelId } : {},
+      configuration: deps.getConfiguration(),
+      artifactState: deps.getArtifactState()
+    });
+    authSessionIdsByProvider.set(plugin.manifest.name, provider.authSessionId);
+    return provider;
+  };
+  const onAuthorizationRequired = async (provider) => {
+    if (pendingPause) {
+      return true;
+    }
+    const authSessionId = authSessionIdsByProvider.get(provider);
+    if (!authSessionId || !deps.requesterId) {
+      throw new Error(
+        `Missing MCP auth session context for plugin "${provider}"`
+      );
+    }
+    const latestArtifactState = deps.getMergedArtifactState();
+    await patchMcpAuthSession(authSessionId, {
+      configuration: { ...deps.getConfiguration() },
+      artifactState: latestArtifactState,
+      toolChannelId: deps.toolChannelId ?? latestArtifactState.assistantContextChannelId ?? deps.channelId
+    });
+    const authSession = await getMcpAuthSession(authSessionId);
+    if (!authSession?.authorizationUrl) {
+      throw new Error(`Missing MCP authorization URL for plugin "${provider}"`);
+    }
+    const delivery = await deliverPrivateMessage({
+      channelId: authSession.channelId,
+      threadTs: authSession.threadTs,
+      userId: authSession.userId,
+      text: `<${authSession.authorizationUrl}|Click here to link your ${formatProviderLabel(provider)} MCP access>. Once you've authorized, this thread will continue automatically.`
+    });
+    if (!delivery) {
+      throw new Error(
+        `Unable to deliver MCP authorization link for plugin "${provider}"`
+      );
+    }
+    pendingPause = new McpAuthorizationPauseError(provider);
+    abortAgent();
+    return true;
+  };
+  return {
+    authProviderFactory,
+    onAuthorizationRequired,
+    getPendingPause: () => pendingPause
+  };
+}
+
+// src/chat/respond.ts
+var startupDiscoveryLogged = false;
+function mcpToolsToDefinitions(mcpTools) {
+  const defs = {};
+  for (const tool2 of mcpTools) {
+    defs[tool2.name] = {
+      description: tool2.description,
+      // Raw JSON Schema from MCP servers — not a TypeBox TSchema, but
+      // pi-agent-core validates with AJV and the Anthropic provider reads
+      // .properties/.required, so raw JSON Schema works at runtime.
+      inputSchema: tool2.parameters,
+      execute: async (args) => tool2.execute(args)
+    };
+  }
+  return defs;
+}
 async function maybeReplaceAgentMessages(agent, messages) {
   const resumable = agent;
   if (typeof resumable.replaceMessages !== "function") {
@@ -8867,7 +9027,6 @@ async function generateAssistantReply(messageText, context = {}) {
   let lastKnownSandboxDependencyProfileHash = context.sandbox?.sandboxDependencyProfileHash;
   let loadedSkillNamesForResume = [];
   let mcpToolManager;
-  let pendingMcpAuthorizationPause;
   try {
     const shouldTrace = shouldEmitDevAgentTrace();
     const spanContext = {
@@ -8926,15 +9085,13 @@ async function generateAssistantReply(messageText, context = {}) {
     const activeSkills = [];
     const skillSandbox = new SkillSandbox(availableSkills, activeSkills);
     const { conversationId: sessionConversationId, sessionId } = getSessionIdentifiers(context);
-    const canUseTurnSession = Boolean(sessionConversationId && sessionId);
+    const checkpointState = await loadTurnCheckpoint({
+      conversationId: sessionConversationId,
+      sessionId
+    });
+    const { resumedFromCheckpoint, currentSliceId, existingCheckpoint } = checkpointState;
     timeoutResumeConversationId = sessionConversationId;
     timeoutResumeSessionId = sessionId;
-    const existingTurnCheckpoint = canUseTurnSession && sessionConversationId && sessionId ? await getAgentTurnSessionCheckpoint(sessionConversationId, sessionId) : void 0;
-    const hasAwaitingResumeCheckpoint = Boolean(
-      existingTurnCheckpoint && existingTurnCheckpoint.state === "awaiting_resume" && existingTurnCheckpoint.piMessages.length > 0
-    );
-    const resumedFromCheckpoint = hasAwaitingResumeCheckpoint;
-    const currentSliceId = hasAwaitingResumeCheckpoint ? existingTurnCheckpoint.sliceId : 1;
     timeoutResumeSliceId = currentSliceId;
     const capabilityRuntime = createSkillCapabilityRuntime({
       invocationArgs: skillInvocation?.args,
@@ -8971,7 +9128,7 @@ async function generateAssistantReply(messageText, context = {}) {
     lastKnownSandboxDependencyProfileHash = sandboxExecutor.getDependencyProfileHash();
     sandboxExecutor.configureSkills(availableSkills);
     const sandbox = await sandboxExecutor.createSandbox();
-    for (const skillName of existingTurnCheckpoint?.loadedSkillNames ?? []) {
+    for (const skillName of existingCheckpoint?.loadedSkillNames ?? []) {
       const preloaded = await skillSandbox.loadSkill(skillName);
       if (preloaded) {
         upsertActiveSkill(activeSkills, preloaded);
@@ -8992,76 +9149,29 @@ async function generateAssistantReply(messageText, context = {}) {
       }
     );
     timeoutResumeMessages = [];
-    pendingMcpAuthorizationPause = void 0;
     const generatedFiles = [];
     const replyFiles = [];
     const artifactStatePatch = {};
     const toolCalls = [];
-    const mcpAuthSessionIdsByProvider = /* @__PURE__ */ new Map();
     let agent;
-    mcpToolManager = new McpToolManager(getPluginMcpProviders(), {
-      authProviderFactory: async (plugin) => {
-        if (!sessionConversationId || !sessionId || !context.requester?.userId) {
-          return void 0;
-        }
-        const provider = await createMcpOAuthClientProvider({
-          provider: plugin.manifest.name,
-          conversationId: sessionConversationId,
-          sessionId,
-          userId: context.requester.userId,
-          userMessage: userInput,
-          ...context.correlation?.channelId ? { channelId: context.correlation.channelId } : {},
-          ...context.correlation?.threadTs ? { threadTs: context.correlation.threadTs } : {},
-          ...context.toolChannelId ? { toolChannelId: context.toolChannelId } : {},
-          configuration: configurationValues,
-          artifactState: context.artifactState
-        });
-        mcpAuthSessionIdsByProvider.set(
-          plugin.manifest.name,
-          provider.authSessionId
-        );
-        return provider;
+    const mcpAuth = createMcpAuthOrchestration(
+      {
+        conversationId: sessionConversationId,
+        sessionId,
+        requesterId: context.requester?.userId,
+        channelId: context.correlation?.channelId,
+        threadTs: context.correlation?.threadTs,
+        toolChannelId: context.toolChannelId,
+        userMessage: userInput,
+        getConfiguration: () => configurationValues,
+        getArtifactState: () => context.artifactState,
+        getMergedArtifactState: () => mergeArtifactsState(context.artifactState ?? {}, artifactStatePatch)
       },
-      onAuthorizationRequired: async (provider) => {
-        if (pendingMcpAuthorizationPause) {
-          return true;
-        }
-        const authSessionId = mcpAuthSessionIdsByProvider.get(provider);
-        if (!authSessionId || !context.requester?.userId) {
-          throw new Error(
-            `Missing MCP auth session context for plugin "${provider}"`
-          );
-        }
-        const latestArtifactState = mergeArtifactsState(
-          context.artifactState ?? {},
-          artifactStatePatch
-        );
-        await patchMcpAuthSession(authSessionId, {
-          configuration: { ...configurationValues },
-          artifactState: latestArtifactState,
-          toolChannelId: context.toolChannelId ?? latestArtifactState.assistantContextChannelId ?? context.correlation?.channelId
-        });
-        const authSession = await getMcpAuthSession(authSessionId);
-        if (!authSession?.authorizationUrl) {
-          throw new Error(
-            `Missing MCP authorization URL for plugin "${provider}"`
-          );
-        }
-        const delivery = await deliverPrivateMessage({
-          channelId: authSession.channelId,
-          threadTs: authSession.threadTs,
-          userId: authSession.userId,
-          text: `<${authSession.authorizationUrl}|Click here to link your ${formatProviderLabel(provider)} MCP access>. Once you've authorized, this thread will continue automatically.`
-        });
-        if (!delivery) {
-          throw new Error(
-            `Unable to deliver MCP authorization link for plugin "${provider}"`
-          );
-        }
-        pendingMcpAuthorizationPause = new McpAuthorizationPauseError(provider);
-        agent?.abort();
-        return true;
-      }
+      () => agent?.abort()
+    );
+    mcpToolManager = new McpToolManager(getPluginMcpProviders(), {
+      authProviderFactory: mcpAuth.authProviderFactory,
+      onAuthorizationRequired: mcpAuth.onAuthorizationRequired
     });
     const turnMcpToolManager = mcpToolManager;
     const syncResumeState = () => {
@@ -9104,22 +9214,25 @@ async function generateAssistantReply(messageText, context = {}) {
           syncResumeState();
           await turnMcpToolManager.activateForSkill(effective);
           syncResumeState();
-          if (pendingMcpAuthorizationPause) {
+          if (mcpAuth.getPendingPause()) {
             return void 0;
           }
           if (!effective.pluginProvider) {
             return void 0;
           }
+          syncMcpAgentTools();
           return {
             available_tools: turnMcpToolManager.getActiveToolCatalog(activeSkills, {
               provider: effective.pluginProvider
-            }).map(toExposedToolSummary),
-            tool_search_available: true
+            }).map(toExposedToolSummary)
           };
         }
       },
       {
         channelId: context.toolChannelId ?? context.correlation?.channelId,
+        channelCapabilities: resolveChannelCapabilities(
+          context.toolChannelId ?? context.correlation?.channelId
+        ),
         messageTs: context.correlation?.messageTs,
         threadTs: context.correlation?.threadTs,
         userText: userInput,
@@ -9134,9 +9247,9 @@ async function generateAssistantReply(messageText, context = {}) {
     for (const skill of activeSkills) {
       await turnMcpToolManager.activateForSkill(skill);
       syncResumeState();
-      if (pendingMcpAuthorizationPause) {
-        timeoutResumeMessages = existingTurnCheckpoint?.piMessages ?? [];
-        throw pendingMcpAuthorizationPause;
+      if (mcpAuth.getPendingPause()) {
+        timeoutResumeMessages = existingCheckpoint?.piMessages ?? [];
+        throw mcpAuth.getPendingPause();
       }
     }
     syncResumeState();
@@ -9181,6 +9294,11 @@ async function generateAssistantReply(messageText, context = {}) {
         content: userContentParts.map((part) => toObservablePromptPart(part))
       }
     ]);
+    const agentToolHooks = {
+      onToolCall: (toolName) => {
+        toolCalls.push(toolName);
+      }
+    };
     const baseAgentTools = createAgentTools(
       tools,
       skillSandbox,
@@ -9188,18 +9306,31 @@ async function generateAssistantReply(messageText, context = {}) {
       context.onStatus,
       sandboxExecutor,
       capabilityRuntime,
-      {
-        onToolCall: (toolName) => {
-          toolCalls.push(toolName);
-        }
-      }
+      agentToolHooks
     );
+    const agentTools = [...baseAgentTools];
+    const syncMcpAgentTools = () => {
+      const mcpTools = turnMcpToolManager.getResolvedActiveTools(activeSkills);
+      const mcpDefs = mcpToolsToDefinitions(mcpTools);
+      const mcpAgentTools = createAgentTools(
+        mcpDefs,
+        skillSandbox,
+        spanContext,
+        context.onStatus,
+        sandboxExecutor,
+        capabilityRuntime,
+        agentToolHooks
+      );
+      agentTools.length = 0;
+      agentTools.push(...baseAgentTools, ...mcpAgentTools);
+    };
+    syncMcpAgentTools();
     agent = new Agent({
       getApiKey: () => getPiGatewayApiKeyOverride(),
       initialState: {
         systemPrompt: baseInstructions,
         model: resolveGatewayModel(botConfig.modelId),
-        tools: baseAgentTools
+        tools: agentTools
       }
     });
     let hasEmittedText = false;
@@ -9211,16 +9342,10 @@ async function generateAssistantReply(messageText, context = {}) {
         }
         return;
       }
-      if (event.type !== "message_update") {
-        return;
-      }
-      if (event.assistantMessageEvent.type !== "text_delta") {
-        return;
-      }
+      if (event.type !== "message_update") return;
+      if (event.assistantMessageEvent.type !== "text_delta") return;
       const deltaText = event.assistantMessageEvent.delta;
-      if (!deltaText) {
-        return;
-      }
+      if (!deltaText) return;
       const text = needsSeparator ? "\n\n" + deltaText : deltaText;
       needsSeparator = false;
       hasEmittedText = true;
@@ -9242,7 +9367,7 @@ async function generateAssistantReply(messageText, context = {}) {
       if (resumedFromCheckpoint) {
         const didReplace = await maybeReplaceAgentMessages(
           agent,
-          existingTurnCheckpoint.piMessages
+          existingCheckpoint.piMessages
         );
         if (!didReplace) {
           throw new Error(
@@ -9294,9 +9419,9 @@ async function generateAssistantReply(messageText, context = {}) {
               });
               timeoutResumeMessages = [...agent.state.messages];
             }
-            if (pendingMcpAuthorizationPause) {
+            if (mcpAuth.getPendingPause()) {
               timeoutResumeMessages = [...agent.state.messages];
-              throw pendingMcpAuthorizationPause;
+              throw mcpAuth.getPendingPause();
             }
             throw error;
           } finally {
@@ -9308,12 +9433,9 @@ async function generateAssistantReply(messageText, context = {}) {
             beforeMessageCount
           );
           completedAssistantTurn = hasCompletedAssistantTurn(newMessages);
-          if (pendingMcpAuthorizationPause && !completedAssistantTurn) {
+          if (mcpAuth.getPendingPause() && !completedAssistantTurn) {
             timeoutResumeMessages = [...agent.state.messages];
-            throw pendingMcpAuthorizationPause;
-          }
-          if (pendingMcpAuthorizationPause && completedAssistantTurn) {
-            pendingMcpAuthorizationPause = void 0;
+            throw mcpAuth.getPendingPause();
           }
           const outputMessages = newMessages.filter(isAssistantMessage);
           const outputMessagesAttribute = serializeGenAiAttribute(outputMessages);
@@ -9337,171 +9459,51 @@ async function generateAssistantReply(messageText, context = {}) {
     } finally {
       unsubscribe();
     }
-    if (pendingMcpAuthorizationPause && !completedAssistantTurn) {
-      throw pendingMcpAuthorizationPause;
+    if (mcpAuth.getPendingPause() && !completedAssistantTurn) {
+      throw mcpAuth.getPendingPause();
     }
-    if (canUseTurnSession && sessionConversationId && sessionId) {
-      await upsertAgentTurnSessionCheckpoint({
+    if (checkpointState.canUseTurnSession && sessionConversationId && sessionId) {
+      await persistCompletedCheckpoint({
         conversationId: sessionConversationId,
         sessionId,
         sliceId: currentSliceId,
-        state: "completed",
-        piMessages: agent.state.messages,
+        allMessages: agent.state.messages,
         loadedSkillNames: activeSkills.map((skill) => skill.name)
       });
     }
-    const toolResults = newMessages.filter(isToolResultMessage);
-    const assistantMessages = newMessages.filter(isAssistantMessage);
-    const primaryText = assistantMessages.map((message) => extractAssistantText(message)).join("\n\n").trim();
-    const oauthStartedMessage = extractOAuthStartedMessageFromToolResults(toolResults);
-    const toolErrorCount = toolResults.filter(
-      (result) => result.isError
-    ).length;
-    const explicitChannelPostIntent = isExplicitChannelPostIntent(userInput);
-    const successfulToolNames = new Set(
-      toolResults.filter((result) => !isToolResultError(result)).map((result) => normalizeToolNameFromResult(result)).filter((value) => Boolean(value))
-    );
-    const channelPostPerformed = successfulToolNames.has(
-      "slackChannelPostMessage"
-    );
-    const deliveryPlan = buildReplyDeliveryPlan({
-      explicitChannelPostIntent,
-      channelPostPerformed,
-      hasFiles: replyFiles.length > 0,
-      streamingThreadReply: Boolean(context.onTextDelta)
+    return buildTurnResult({
+      newMessages,
+      userInput,
+      replyFiles,
+      artifactStatePatch,
+      toolCalls,
+      sandboxId: sandboxExecutor.getSandboxId(),
+      sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash(),
+      generatedFileCount: generatedFiles.length,
+      hasTextDeltaCallback: Boolean(context.onTextDelta),
+      shouldTrace,
+      spanContext,
+      correlation: context.correlation,
+      assistantUserName: context.assistant?.userName
     });
-    const deliveryMode = deliveryPlan.mode;
-    if (!primaryText && !oauthStartedMessage) {
-      logWarn(
-        "ai_model_response_empty",
-        {
-          slackThreadId: context.correlation?.threadId,
-          slackUserId: context.correlation?.requesterId,
-          slackChannelId: context.correlation?.channelId,
+  } catch (error) {
+    if (error instanceof McpAuthorizationPauseError && timeoutResumeConversationId && timeoutResumeSessionId) {
+      const nextSliceId = await persistAuthPauseCheckpoint({
+        conversationId: timeoutResumeConversationId,
+        sessionId: timeoutResumeSessionId,
+        currentSliceId: timeoutResumeSliceId,
+        messages: timeoutResumeMessages,
+        loadedSkillNames: loadedSkillNamesForResume,
+        errorMessage: error.message,
+        logContext: {
+          threadId: context.correlation?.threadId,
+          requesterId: context.correlation?.requesterId,
+          channelId: context.correlation?.channelId,
           runId: context.correlation?.runId,
           assistantUserName: context.assistant?.userName,
           modelId: botConfig.modelId
-        },
-        {
-          "app.ai.tool_results": toolResults.length,
-          "app.ai.tool_error_results": toolErrorCount,
-          "app.ai.generated_files": generatedFiles.length
-        },
-        "Model returned empty text response"
-      );
-    }
-    const lastAssistant = assistantMessages.at(-1);
-    const stopReason = typeof lastAssistant?.stopReason === "string" ? lastAssistant.stopReason : void 0;
-    const errorMessage = typeof lastAssistant?.errorMessage === "string" ? lastAssistant.errorMessage : void 0;
-    const usedPrimaryText = Boolean(primaryText);
-    const outcome = primaryText || oauthStartedMessage ? stopReason === "error" ? "provider_error" : "success" : "execution_failure";
-    const fallbackText = oauthStartedMessage ?? buildExecutionFailureMessage(toolErrorCount);
-    const responseText = primaryText || fallbackText;
-    const escapedOrRawPayload = Boolean(primaryText) && (isExecutionEscapeResponse(primaryText) || isRawToolPayloadResponse(primaryText));
-    const resolvedText = escapedOrRawPayload ? fallbackText : enforceAttachmentClaimTruth(responseText, replyFiles.length > 0);
-    const resolvedOutcome = escapedOrRawPayload ? oauthStartedMessage ? outcome : "execution_failure" : outcome;
-    if (shouldTrace) {
-      logInfo(
-        "agent_message_out",
-        spanContext,
-        {
-          "app.message.kind": "assistant_outbound",
-          "app.message.length": resolvedText.length,
-          "app.message.output": summarizeMessageText(resolvedText),
-          "app.ai.outcome": resolvedOutcome,
-          "app.ai.assistant_messages": assistantMessages.length,
-          ...stopReason ? { "app.ai.stop_reason": stopReason } : {}
-        },
-        "Agent message sent"
-      );
-    }
-    if (escapedOrRawPayload) {
-      return {
-        text: resolvedText,
-        files: replyFiles.length > 0 ? replyFiles : void 0,
-        artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
-        deliveryPlan,
-        deliveryMode,
-        sandboxId: sandboxExecutor.getSandboxId(),
-        sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash(),
-        diagnostics: {
-          outcome: "execution_failure",
-          modelId: botConfig.modelId,
-          assistantMessageCount: assistantMessages.length,
-          toolCalls,
-          toolResultCount: toolResults.length,
-          toolErrorCount,
-          usedPrimaryText,
-          stopReason,
-          errorMessage,
-          providerError: void 0
         }
-      };
-    }
-    return {
-      text: resolvedText,
-      files: replyFiles.length > 0 ? replyFiles : void 0,
-      artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
-      deliveryPlan,
-      deliveryMode,
-      sandboxId: sandboxExecutor.getSandboxId(),
-      sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash(),
-      diagnostics: {
-        outcome,
-        modelId: botConfig.modelId,
-        assistantMessageCount: assistantMessages.length,
-        toolCalls,
-        toolResultCount: toolResults.length,
-        toolErrorCount,
-        usedPrimaryText,
-        stopReason,
-        errorMessage,
-        providerError: void 0
-      }
-    };
-  } catch (error) {
-    if (error instanceof McpAuthorizationPauseError && timeoutResumeConversationId && timeoutResumeSessionId) {
-      const nextSliceId = timeoutResumeSliceId + 1;
-      try {
-        const latestCheckpoint = await getAgentTurnSessionCheckpoint(
-          timeoutResumeConversationId,
-          timeoutResumeSessionId
-        );
-        const piMessages = trimTrailingAssistantMessages(
-          timeoutResumeMessages.length > 0 ? timeoutResumeMessages : latestCheckpoint?.piMessages ?? []
-        );
-        await upsertAgentTurnSessionCheckpoint({
-          conversationId: timeoutResumeConversationId,
-          sessionId: timeoutResumeSessionId,
-          sliceId: nextSliceId,
-          state: "awaiting_resume",
-          piMessages,
-          loadedSkillNames: loadedSkillNamesForResume,
-          resumeReason: "auth",
-          resumedFromSliceId: timeoutResumeSliceId,
-          errorMessage: error.message
-        });
-      } catch (checkpointError) {
-        logException(
-          checkpointError,
-          "agent_turn_auth_resume_checkpoint_failed",
-          {
-            slackThreadId: context.correlation?.threadId,
-            slackUserId: context.correlation?.requesterId,
-            slackChannelId: context.correlation?.channelId,
-            runId: context.correlation?.runId,
-            assistantUserName: context.assistant?.userName,
-            modelId: botConfig.modelId
-          },
-          {
-            "app.ai.resume_conversation_id": timeoutResumeConversationId,
-            "app.ai.resume_session_id": timeoutResumeSessionId,
-            "app.ai.resume_from_slice_id": timeoutResumeSliceId,
-            "app.ai.resume_next_slice_id": nextSliceId
-          },
-          "Failed to persist auth checkpoint before retry"
-        );
-      }
+      });
       throw new RetryableTurnError(
         "mcp_auth_resume",
         `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`
@@ -12004,7 +12006,11 @@ function createReplyToThread(deps) {
             "app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
             "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
             "app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
-            ...reply.diagnostics.stopReason ? { "app.ai.stop_reason": reply.diagnostics.stopReason } : {},
+            ...reply.diagnostics.stopReason ? {
+              "gen_ai.response.finish_reasons": [
+                reply.diagnostics.stopReason
+              ]
+            } : {},
             ...reply.diagnostics.errorMessage ? { "error.message": reply.diagnostics.errorMessage } : {}
           };
           setSpanAttributes(diagnosticsAttributes);