@sentry/junior 0.22.0 → 0.23.0

package/dist/app.js

@@ -311,9 +311,6 @@ async function GET3() {
   });
 }
 
-// src/handlers/mcp-oauth-callback.ts
-import { Buffer as Buffer2 } from "buffer";
-
 // src/chat/state/conversation.ts
 function coerceRole(value) {
   return value === "assistant" || value === "system" || value === "user" ? value : "user";
@@ -729,81 +726,6 @@ async function deleteMcpServerSessionId(userId, provider) {
   await stateAdapter.delete(serverSessionKey(userId, provider));
 }
 
-// src/chat/slack/output.ts
-var MAX_INLINE_CHARS = 2200;
-var MAX_INLINE_LINES = 45;
-function ensureBlockSpacing(text) {
-  const codeBlockPattern = /^```/;
-  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-  const lines = text.split("\n");
-  const result = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isCodeFence = codeBlockPattern.test(line.trimStart());
-    if (isCodeFence) {
-      if (!inCodeBlock) {
-        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev2 !== void 0 && prev2.trim() !== "") {
-          result.push("");
-        }
-      }
-      inCodeBlock = !inCodeBlock;
-      result.push(line);
-      continue;
-    }
-    if (inCodeBlock) {
-      result.push(line);
-      continue;
-    }
-    const prev = result.length > 0 ? result[result.length - 1] : void 0;
-    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
-      result.push("");
-    }
-    result.push(line);
-  }
-  return result.join("\n");
-}
-function normalizeForSlack(text) {
-  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
-  normalized = ensureBlockSpacing(normalized);
-  return normalized.replace(/\n{3,}/g, "\n\n").trim();
-}
-function buildSlackOutputMessage(text, files) {
-  const normalized = normalizeForSlack(text);
-  const fileCount = files?.length ?? 0;
-  if (!normalized) {
-    if (fileCount > 0) {
-      return {
-        raw: "",
-        files
-      };
-    }
-    logWarn(
-      "slack_output_normalized_empty",
-      {},
-      {
-        "app.output.original_length": text.length,
-        "app.output.parsed_length": normalized.length,
-        "app.output.file_count": fileCount
-      },
-      "Slack output normalized to empty content"
-    );
-    return {
-      markdown: "I couldn't produce a response.",
-      files
-    };
-  }
-  return {
-    markdown: normalized,
-    files
-  };
-}
-var slackOutputPolicy = {
-  maxInlineChars: MAX_INLINE_CHARS,
-  maxInlineLines: MAX_INLINE_LINES
-};
-
 // src/chat/mcp/oauth.ts
 import { randomUUID } from "crypto";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -2176,24 +2098,6 @@ function markTurnFailed(args) {
   });
   args.updateConversationStats(args.conversation);
 }
-function resolveReplyDelivery(args) {
-  const replyHasFiles = Boolean(
-    args.reply.files && args.reply.files.length > 0
-  );
-  const deliveryPlan = args.reply.deliveryPlan ?? {
-    mode: args.reply.deliveryMode ?? "thread",
-    postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
-    attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
-  };
-  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
-  if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
-    attachFiles = "inline";
-  }
-  return {
-    shouldPostThreadReply: deliveryPlan.postThreadText,
-    attachFiles
-  };
-}
 
 // src/chat/runtime/turn-user-message.ts
 function getTurnUserMessage(conversation, sessionId) {
@@ -2799,6 +2703,276 @@ import { Agent } from "@mariozechner/pi-agent-core";
 // src/chat/prompt.ts
 import fs from "fs";
 import path2 from "path";
+
+// src/chat/slack/output.ts
+var MAX_INLINE_CHARS = 2200;
+var MAX_INLINE_LINES = 45;
+var CONTINUED_MARKER = "\n\n[Continued below]";
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+var STREAMING_FENCE_CLOSE_GUARD = "\n```";
+function ensureBlockSpacing(text) {
+  const codeBlockPattern = /^```/;
+  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isCodeFence = codeBlockPattern.test(line.trimStart());
+    if (isCodeFence) {
+      if (!inCodeBlock) {
+        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
+        if (prev2 !== void 0 && prev2.trim() !== "") {
+          result.push("");
+        }
+      }
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+    const prev = result.length > 0 ? result[result.length - 1] : void 0;
+    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
+      result.push("");
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
+function normalizeForSlack(text) {
+  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
+  normalized = ensureBlockSpacing(normalized);
+  return normalized.replace(/\n{3,}/g, "\n\n").trim();
+}
+function countSlackLines(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split("\n").length;
+}
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return text.length <= maxChars && countSlackLines(text) <= maxLines;
+}
+function findSplitIndex(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text.length;
+  }
+  const bounded = text.slice(0, maxChars);
+  const newlineIndex = bounded.lastIndexOf("\n");
+  if (newlineIndex > 0) {
+    return newlineIndex;
+  }
+  const spaceIndex = bounded.lastIndexOf(" ");
+  if (spaceIndex > 0) {
+    return spaceIndex;
+  }
+  return maxChars;
+}
+function splitByLineBudget(text, maxLines) {
+  if (maxLines <= 0) {
+    return "";
+  }
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) {
+    return text;
+  }
+  return lines.slice(0, maxLines).join("\n");
+}
+function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return {
+    maxChars: Math.max(1, maxChars - suffix.length),
+    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+  };
+}
+function forceSplitBudget(text, budget) {
+  const lineCount = countSlackLines(text);
+  return {
+    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
+    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+  };
+}
+function getFenceContinuation(text) {
+  let open;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trimStart();
+    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+    if (!openerMatch) {
+      continue;
+    }
+    if (!open) {
+      open = {
+        fence: openerMatch[1],
+        openerLine: trimmed
+      };
+      continue;
+    }
+    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
+      open = void 0;
+    }
+  }
+  if (!open) {
+    return null;
+  }
+  return {
+    closeSuffix: text.endsWith("\n") ? open.fence : `
+${open.fence}`,
+    reopenPrefix: `${open.openerLine}
+`
+  };
+}
+function appendSlackSuffix(text, marker) {
+  const carryover = getFenceContinuation(text);
+  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
+}
+function takeSlackContinuationChunk(text, budget) {
+  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, budget)
+    ));
+  }
+  let carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  const carryoverBudget = reserveInlineBudgetForSuffix(
+    `${carryover.closeSuffix}${CONTINUED_MARKER}`
+  );
+  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, carryoverBudget)
+    ));
+  }
+  carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  return {
+    prefix,
+    rest: `${carryover.reopenPrefix}${rest}`
+  };
+}
+function takeSlackContinuationPrefix(text, options) {
+  const budget = {
+    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
+    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+  };
+  const { prefix, rest } = (() => {
+    if (options?.forceSplit) {
+      return takeSlackContinuationChunk(text, budget);
+    }
+    const initial = takeSlackInlinePrefix(text, budget);
+    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
+  })();
+  return {
+    prefix,
+    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
+    rest
+  };
+}
+function takeSlackInlinePrefix(text, options) {
+  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
+  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
+  const normalized = text.replace(/\r\n?/g, "\n");
+  if (!normalized) {
+    return { prefix: "", rest: "" };
+  }
+  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
+    return { prefix: normalized, rest: "" };
+  }
+  const lineBounded = splitByLineBudget(normalized, maxLines);
+  const cutIndex = findSplitIndex(lineBounded, maxChars);
+  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
+  if (prefix) {
+    return {
+      prefix,
+      rest: normalized.slice(prefix.length).trimStart()
+    };
+  }
+  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
+  return {
+    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
+    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
+  };
+}
+function splitSlackReplyText(text, options) {
+  const normalized = normalizeForSlack(text);
+  if (!normalized) {
+    return [];
+  }
+  const chunks = [];
+  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+  let remaining = normalized;
+  while (remaining) {
+    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, INTERRUPTED_MARKER)) : fitsInlineBudget(remaining);
+    if (fitsFinalChunk) {
+      chunks.push(
+        options?.interrupted ? appendSlackSuffix(remaining, INTERRUPTED_MARKER) : remaining
+      );
+      break;
+    }
+    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
+      ...continuationBudget,
+      forceSplit: true
+    });
+    chunks.push(renderedPrefix);
+    remaining = rest;
+  }
+  return chunks;
+}
+function getSlackInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+function getSlackContinuationBudget() {
+  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+function getSlackStreamingContinuationBudget() {
+  return reserveInlineBudgetForSuffix(
+    `${STREAMING_FENCE_CLOSE_GUARD}${CONTINUED_MARKER}`
+  );
+}
+function buildSlackOutputMessage(text, files) {
+  const normalized = normalizeForSlack(text);
+  const fileCount = files?.length ?? 0;
+  if (!normalized) {
+    if (fileCount > 0) {
+      return {
+        raw: "",
+        files
+      };
+    }
+    logWarn(
+      "slack_output_normalized_empty",
+      {},
+      {
+        "app.output.original_length": text.length,
+        "app.output.parsed_length": normalized.length,
+        "app.output.file_count": fileCount
+      },
+      "Slack output normalized to empty content"
+    );
+    return {
+      markdown: "I couldn't produce a response.",
+      files
+    };
+  }
+  return {
+    markdown: normalized,
+    files
+  };
+}
+var slackOutputPolicy = {
+  maxInlineChars: MAX_INLINE_CHARS,
+  maxInlineLines: MAX_INLINE_LINES
+};
+
+// src/chat/prompt.ts
 var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
 function getLoggedMarkdownFiles() {
   const globalState = globalThis;
@@ -3169,6 +3343,9 @@ function buildSystemPrompt(params) {
         "- Keep routine setup and research steps silent in user-facing replies. Do not narrate duplicate checks, credential issuance, file writes, or similar internal progress unless the result is user-relevant.",
         "- If a routine prerequisite check finds nothing notable, omit it entirely from the final reply and report only the user-relevant outcome.",
         "- Prefer a single result-focused reply after tool work completes. Only send an interim reply when you need user input or have a concrete blocking problem to report.",
+        "- For external/factual research requests that require tools, do not send any preliminary conclusion, 'let me check', or progress narration before the evidence-gathering work is done. Use assistant status for in-progress work and make the first visible reply the researched answer.",
+        "- For evidence-gathering tasks, never state a factual conclusion before you have actually gathered and checked the sources.",
+        "- Do not include internal process chatter such as 'let me find', 'fetching now', 'good, I have sources', 'trying smaller limits', or 'I now have sufficient context' in the final user-facing reply.",
         "- Use `attachFile` for files that actually exist in the sandbox (for example screenshots, PDFs, logs), or for `attachment_path` values returned by `imageGenerate`.",
         "- If the user asks to see/share/show a screenshot or file, attach the file with `attachFile` instead of only reporting its path.",
         "- Never claim a screenshot/file is attached unless `attachFile` succeeded in this turn.",
@@ -3227,7 +3404,8 @@ function buildSystemPrompt(params) {
         "- Use plain Slack-safe markdown (headings, bullets, short code blocks).",
         "- Keep normal responses brief and scannable.",
         "- If depth is needed, start with a concise summary and then provide fuller detail.",
-        "- A brief initial acknowledgment before significant tool work is fine; avoid extended process chatter or repeated status updates.",
+        "- For tool-heavy research, discovery, or source-checking requests, do not send an initial acknowledgment. Start the visible reply only once you can present the actual answer.",
+        "- Do not narrate tool execution or repeated status updates in the visible reply.",
         "- Avoid tables unless explicitly requested.",
         "- End every turn with a final user-facing markdown response.",
         "</output>"
@@ -8847,13 +9025,13 @@ function buildToolStatus(toolName, input) {
     return makeAssistantStatus("loading", skillName);
   }
   if (query && toolName === "webSearch") {
-    return makeAssistantStatus("searching", `"${query}"`);
-  }
-  if (query && provider && toolName === "searchTools") {
-    return makeAssistantStatus("searching", `${provider} "${query}"`);
+    return makeAssistantStatus("searching", "sources");
   }
   if (query && toolName === "searchTools") {
-    return makeAssistantStatus("searching", `"${query}"`);
+    return makeAssistantStatus(
+      "searching",
+      provider ? `${provider} tools` : "tools"
+    );
   }
   if (domain && toolName === "webFetch") {
     return makeAssistantStatus("fetching", domain);
@@ -9157,13 +9335,34 @@ function buildReplyDeliveryPlan(args) {
     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;
+function resolveReplyDelivery(args) {
+  const replyHasFiles = Boolean(
+    args.reply.files && args.reply.files.length > 0
+  );
+  const deliveryPlan = args.reply.deliveryPlan ?? {
+    mode: args.reply.deliveryMode ?? "thread",
+    postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
+    attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
+  };
+  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
+  if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
+    attachFiles = "inline";
+  }
+  if (attachFiles === "inline" && args.hasStreamedThreadReply) {
+    attachFiles = "followup";
+  }
+  return {
+    shouldPostThreadReply: deliveryPlan.postThreadText,
+    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;
   }
@@ -9954,6 +10153,17 @@ async function generateAssistantReply(messageText, context = {}) {
     const agentToolHooks = {
       onToolCall: (toolName) => {
         toolCalls.push(toolName);
+        Promise.resolve(context.onToolCall?.(toolName)).catch((error) => {
+          logWarn(
+            "streaming_tool_call_error",
+            {},
+            {
+              "error.message": error instanceof Error ? error.message : String(error),
+              "gen_ai.tool.name": toolName
+            },
+            "Failed to deliver tool call event to stream coordinator"
+          );
+        });
       }
     };
     const baseAgentTools = createAgentTools(
@@ -9994,6 +10204,16 @@ async function generateAssistantReply(messageText, context = {}) {
     let needsSeparator = false;
     const unsubscribe = agent.subscribe((event) => {
       if (event.type === "message_start") {
+        Promise.resolve(context.onAssistantMessageStart?.()).catch((error) => {
+          logWarn(
+            "streaming_message_start_error",
+            {},
+            {
+              "error.message": error instanceof Error ? error.message : String(error)
+            },
+            "Failed to deliver assistant message start to stream coordinator"
+          );
+        });
         if (hasEmittedText) {
           needsSeparator = true;
         }
@@ -10385,7 +10605,194 @@ function createProgressReporter(args) {
   };
 }
 
-// src/handlers/oauth-resume.ts
+// src/chat/slack/reply.ts
+import { Buffer as Buffer2 } from "buffer";
+function isInterruptedVisibleReply(reply) {
+  return reply.diagnostics.outcome === "provider_error";
+}
+function buildChunkMessage(chunk, files) {
+  return {
+    markdown: chunk,
+    ...files ? { files } : {}
+  };
+}
+function buildTextPosts(args) {
+  const chunks = splitSlackReplyText(args.text, {
+    interrupted: args.interrupted
+  });
+  return chunks.map((chunk, index) => ({
+    message: buildChunkMessage(
+      chunk,
+      index === 0 ? args.firstFiles : void 0
+    ),
+    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
+      };
+    })
+  );
+}
+async function uploadReplyFilesBestEffort(args) {
+  try {
+    await uploadFilesToThread({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      files: await normalizeFileUploads(args.files)
+    });
+  } catch {
+  }
+}
+function getReplyMessageText(message) {
+  if (typeof message !== "object" || message === null) {
+    return void 0;
+  }
+  if ("markdown" in message && typeof message.markdown === "string") {
+    return message.markdown;
+  }
+  if ("raw" in message && typeof message.raw === "string") {
+    return message.raw;
+  }
+  return void 0;
+}
+function getReplyMessageFiles(message) {
+  if (typeof message === "object" && message !== null && "files" in message && Array.isArray(message.files)) {
+    return message.files;
+  }
+  return void 0;
+}
+function createSlackStreamAccumulator() {
+  let pendingCarriageReturn = false;
+  let streamedVisibleText = "";
+  let streamedRenderedText = "";
+  let overflowText = "";
+  let streamOverflowed = false;
+  const continuationBudget = getSlackStreamingContinuationBudget();
+  const normalizeDelta = (deltaText) => {
+    let text = deltaText;
+    if (pendingCarriageReturn) {
+      text = `\r${text}`;
+      pendingCarriageReturn = false;
+    }
+    if (text.endsWith("\r")) {
+      text = text.slice(0, -1);
+      pendingCarriageReturn = true;
+    }
+    return text.replace(/\r\n?/g, "\n");
+  };
+  return {
+    append(deltaText) {
+      const normalizedDeltaText = normalizeDelta(deltaText);
+      if (!normalizedDeltaText) {
+        return "";
+      }
+      if (streamOverflowed) {
+        overflowText += normalizedDeltaText;
+        return "";
+      }
+      const candidate = `${streamedVisibleText}${normalizedDeltaText}`;
+      const { prefix, renderedPrefix, rest } = takeSlackContinuationPrefix(
+        candidate,
+        continuationBudget
+      );
+      const additional = renderedPrefix.length > streamedRenderedText.length ? renderedPrefix.slice(streamedRenderedText.length) : "";
+      streamedVisibleText = prefix;
+      streamedRenderedText = renderedPrefix;
+      if (rest) {
+        overflowText += rest;
+        streamOverflowed = true;
+      }
+      return additional;
+    },
+    getOverflowText() {
+      return overflowText;
+    }
+  };
+}
+function planSlackReplyPosts(args) {
+  const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
+  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
+    reply: args.reply,
+    hasStreamedThreadReply: args.hasStreamedThreadReply
+  });
+  const interrupted = isInterruptedVisibleReply(args.reply);
+  const posts = [];
+  if (args.hasStreamedThreadReply) {
+    if (shouldPostThreadReply && args.streamedOverflowText) {
+      posts.push(
+        ...buildTextPosts({
+          text: args.streamedOverflowText,
+          interrupted,
+          firstStage: "thread_reply_continuation"
+        })
+      );
+    } else if (shouldPostThreadReply && interrupted) {
+      posts.push({
+        message: buildSlackOutputMessage(
+          getSlackInterruptionMarker().trimStart()
+        ),
+        stage: "thread_reply_continuation"
+      });
+    }
+  } else {
+    const textPosts = shouldPostThreadReply ? buildTextPosts({
+      text: args.reply.text,
+      interrupted,
+      firstFiles: attachFiles === "inline" ? replyFiles : void 0
+    }) : [];
+    posts.push(...textPosts);
+    if (attachFiles === "inline" && replyFiles && textPosts.length === 0) {
+      posts.push({
+        message: buildSlackOutputMessage("", replyFiles),
+        stage: "thread_reply"
+      });
+    } else if (shouldPostThreadReply && textPosts.length === 0) {
+      posts.push({
+        message: buildSlackOutputMessage(args.reply.text),
+        stage: "thread_reply"
+      });
+    }
+  }
+  if (attachFiles === "followup" && replyFiles) {
+    posts.push({
+      message: buildSlackOutputMessage("", replyFiles),
+      stage: "thread_reply_files_followup"
+    });
+  }
+  return posts;
+}
+async function postSlackApiReplyPosts(args) {
+  for (const post of args.posts) {
+    const text = getReplyMessageText(post.message);
+    if (text && text.trim().length > 0) {
+      await args.postMessage(args.channelId, args.threadTs, text);
+    }
+    const files = getReplyMessageFiles(post.message);
+    if (!files?.length) {
+      continue;
+    }
+    await uploadReplyFilesBestEffort({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      files
+    });
+  }
+}
+
+// src/chat/slack/resume.ts
 function resolveReplyTimeoutMs(explicitTimeoutMs) {
   if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
     return explicitTimeoutMs;
@@ -10531,11 +10938,15 @@ async function resumeSlackTurn(args) {
       )
     ]) : await replyPromise;
     await progress.stop();
-    if (args.onReply) {
-      await args.onReply(reply);
-    } else if (reply.text) {
-      await postSlackMessage(args.channelId, args.threadTs, reply.text);
-    }
+    await postSlackApiReplyPosts({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      posts: planSlackReplyPosts({
+        reply,
+        hasStreamedThreadReply: false
+      }),
+      postMessage: postSlackMessage
+    });
     await args.onSuccess?.(reply);
   } catch (error) {
     await progress.stop();
@@ -10592,7 +11003,6 @@ async function resumeAuthorizedRequest(args) {
     initialText: args.connectedText,
     failureText: args.failureText,
     generateReply: args.generateReply,
-    onReply: args.onReply,
     onSuccess: args.onSuccess,
     onFailure: args.onFailure,
     onAuthPause: args.onAuthPause,
@@ -10756,65 +11166,6 @@ function htmlResponse(kind) {
   const page = CALLBACK_PAGES[kind];
   return htmlCallbackResponse(page.title, page.message, page.status);
 }
-function extractSlackText(text, files) {
-  const message = buildSlackOutputMessage(text, files);
-  if (typeof message === "object" && message !== null && "markdown" in message && typeof message.markdown === "string") {
-    return message.markdown;
-  }
-  if (typeof message === "object" && message !== null && "raw" in message && typeof message.raw === "string") {
-    return message.raw;
-  }
-  return text;
-}
-async function normalizeFileUploads(files) {
-  const normalized = [];
-  for (const file of files) {
-    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());
-    }
-    normalized.push({
-      data,
-      filename: file.filename
-    });
-  }
-  return normalized;
-}
-async function deliverReplyToThread(channelId, threadTs, reply) {
-  const replyFiles = reply.files && reply.files.length > 0 ? reply.files : void 0;
-  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
-    reply,
-    hasStreamedThreadReply: false
-  });
-  if (shouldPostThreadReply) {
-    const text = extractSlackText(
-      reply.text,
-      attachFiles === "inline" ? replyFiles : void 0
-    );
-    if (text.trim().length > 0) {
-      await postSlackMessage(channelId, threadTs, text);
-    }
-  }
-  if (!replyFiles || attachFiles === "none") {
-    return;
-  }
-  const files = await normalizeFileUploads(replyFiles);
-  if (files.length === 0) {
-    return;
-  }
-  try {
-    await uploadFilesToThread({
-      channelId,
-      threadTs,
-      files
-    });
-  } catch {
-  }
-}
 async function buildResumeConversationContext(channelId, threadTs, sessionId) {
   const threadId = `slack:${channelId}:${threadTs}`;
   const conversation = coerceThreadConversationState(
@@ -10899,7 +11250,6 @@ async function resumeAuthorizedMcpTurn(args) {
   );
   await resumeAuthorizedRequest({
     messageText: authSession.userMessage,
-    provider,
     channelId: authSession.channelId,
     threadTs: authSession.threadTs,
     lockKey: authSession.conversationId,
@@ -10927,13 +11277,6 @@ async function resumeAuthorizedMcpTurn(args) {
       sandbox: getPersistedSandboxState(currentState),
       threadParticipants: buildThreadParticipants(conversation.messages)
     },
-    onReply: async (reply) => {
-      await deliverReplyToThread(
-        authSession.channelId,
-        authSession.threadTs,
-        reply
-      );
-    },
     onSuccess: async (reply) => {
       try {
         await persistCompletedReplyState(
@@ -11230,7 +11573,6 @@ async function resumePendingOAuthMessage(stored) {
   );
   await resumeAuthorizedRequest({
     messageText: stored.pendingMessage,
-    provider: stored.provider,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
     connectedText: `Your ${providerLabel} account is now connected. Processing your request...`,
@@ -11428,9 +11770,6 @@ async function GET5(request, provider, waitUntil) {
   });
 }
 
-// src/handlers/turn-resume.ts
-import { Buffer as Buffer3 } from "buffer";
-
 // src/chat/slack/context.ts
 function toTrimmedSlackString(value) {
   const normalized = toOptionalString(value);
@@ -11478,65 +11817,6 @@ function resolveSlackChannelIdFromMessage(message) {
 }
 
 // src/handlers/turn-resume.ts
-function extractSlackText2(text, files) {
-  const message = buildSlackOutputMessage(text, files);
-  if (typeof message === "object" && message !== null && "markdown" in message && typeof message.markdown === "string") {
-    return message.markdown;
-  }
-  if (typeof message === "object" && message !== null && "raw" in message && typeof message.raw === "string") {
-    return message.raw;
-  }
-  return text;
-}
-async function normalizeFileUploads2(files) {
-  const normalized = [];
-  for (const file of files) {
-    let data;
-    if (Buffer3.isBuffer(file.data)) {
-      data = file.data;
-    } else if (file.data instanceof ArrayBuffer) {
-      data = Buffer3.from(file.data);
-    } else {
-      data = Buffer3.from(await file.data.arrayBuffer());
-    }
-    normalized.push({
-      data,
-      filename: file.filename
-    });
-  }
-  return normalized;
-}
-async function deliverReplyToThread2(args) {
-  const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
-  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
-    reply: args.reply,
-    hasStreamedThreadReply: false
-  });
-  if (shouldPostThreadReply) {
-    const text = extractSlackText2(
-      args.reply.text,
-      attachFiles === "inline" ? replyFiles : void 0
-    );
-    if (text.trim().length > 0) {
-      await postSlackMessage(args.channelId, args.threadTs, text);
-    }
-  }
-  if (!replyFiles || attachFiles === "none") {
-    return;
-  }
-  const files = await normalizeFileUploads2(replyFiles);
-  if (files.length === 0) {
-    return;
-  }
-  try {
-    await uploadFilesToThread({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      files
-    });
-  } catch {
-  }
-}
 async function persistCompletedReplyState2(args) {
   const currentState = await getPersistedThreadState(
     args.checkpoint.conversationId
@@ -11651,13 +11931,6 @@ async function resumeTimedOutTurn(payload) {
       sandbox,
       threadParticipants: buildThreadParticipants(conversation.messages)
     },
-    onReply: async (reply) => {
-      await deliverReplyToThread2({
-        channelId: thread.channelId,
-        threadTs: thread.threadTs,
-        reply
-      });
-    },
     onSuccess: async (reply) => {
       try {
         await persistCompletedReplyState2({ checkpoint, reply });
@@ -11766,9 +12039,6 @@ async function POST(request, waitUntil) {
   return new Response("Accepted", { status: 202 });
 }
 
-// src/chat/app/production.ts
-import { createSlackAdapter } from "@chat-adapter/slack";
-
 // src/chat/services/subscribed-decision.ts
 import { z } from "zod";
 var replyDecisionSchema = z.object({
@@ -12615,6 +12885,15 @@ var MAX_USER_ATTACHMENTS = 3;
 var MAX_USER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 var MAX_MESSAGE_IMAGE_ATTACHMENTS = 3;
 var MAX_VISION_SUMMARY_CHARS = 500;
+function hasPotentialImageAttachment(attachments) {
+  return attachments?.some((attachment) => {
+    if (attachment.type === "image") {
+      return true;
+    }
+    const mimeType = attachment.mimeType ?? "";
+    return attachment.type === "file" && mimeType.startsWith("image/");
+  }) ?? false;
+}
 function isVisionEnabled() {
   return Boolean(botConfig.visionModelId);
 }
@@ -12957,6 +13236,7 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
       continue;
     }
     hydratedMessageIds.add(conversationMessage.id);
+    const existingMeta = conversationMessage.meta ?? {};
     const imageFiles = (reply.files ?? []).filter((file) => {
       const mimeType = toOptionalString(file.mimetype);
       return Boolean(
@@ -12964,10 +13244,15 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
       );
     }).slice(0, MAX_MESSAGE_IMAGE_ATTACHMENTS);
     if (imageFiles.length === 0) {
+      conversationMessage.meta = {
+        ...existingMeta,
+        slackTs: existingMeta.slackTs ?? ts,
+        imagesHydrated: true
+      };
+      mutated = true;
       continue;
     }
     const imageFileIds = imageFiles.map((file) => toOptionalString(file.id)).filter((fileId) => Boolean(fileId));
-    const existingMeta = conversationMessage.meta ?? {};
     conversationMessage.meta = {
       ...existingMeta,
       slackTs: existingMeta.slackTs ?? ts,
@@ -13196,6 +13481,14 @@ function getExecutionFailureReason(reply) {
   }
   return "empty assistant turn";
 }
+function shouldAutoStartStreaming(args) {
+  const { text, deltaCount } = args;
+  const trimmed = text.trim();
+  if (!trimmed || isPotentialRedundantReactionAckText(trimmed)) {
+    return false;
+  }
+  return deltaCount >= 2;
+}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
     if (message.author.isMe) {
@@ -13304,7 +13597,10 @@ function createReplyToThread(deps) {
         const textStream = createTextStreamBridge();
         let streamedReplyPromise;
         let pendingStreamText = "";
+        let pendingStreamDeltaCount = 0;
+        let awaitingPostToolAssistantMessage = false;
         let beforeFirstResponsePostCalled = false;
+        let streamedReplyState = createSlackStreamAccumulator();
         const beforeFirstResponsePost = async () => {
           if (beforeFirstResponsePostCalled) {
             return;
@@ -13330,6 +13626,51 @@ function createReplyToThread(deps) {
           startStreamingReply();
           textStream.push(pendingStreamText);
           pendingStreamText = "";
+          pendingStreamDeltaCount = 0;
+        };
+        const clearPendingStreamText = () => {
+          pendingStreamText = "";
+          pendingStreamDeltaCount = 0;
+        };
+        const discardPendingStreamPreview = () => {
+          clearPendingStreamText();
+          streamedReplyState = createSlackStreamAccumulator();
+        };
+        const finalizePendingStreamText = () => {
+          if (!pendingStreamText || streamedReplyPromise || isPotentialRedundantReactionAckText(pendingStreamText)) {
+            return;
+          }
+          flushPendingStreamText();
+        };
+        const queueVisibleStreamText = (text) => {
+          if (!text) {
+            return;
+          }
+          if (awaitingPostToolAssistantMessage) {
+            return;
+          }
+          if (streamedReplyPromise) {
+            textStream.push(text);
+            return;
+          }
+          pendingStreamText += text;
+          pendingStreamDeltaCount += 1;
+          if (isPotentialRedundantReactionAckText(pendingStreamText)) {
+            return;
+          }
+          if (!shouldAutoStartStreaming({
+            text: pendingStreamText,
+            deltaCount: pendingStreamDeltaCount
+          })) {
+            return;
+          }
+          flushPendingStreamText();
+        };
+        const appendVisibleStreamDelta = (deltaText) => {
+          if (awaitingPostToolAssistantMessage && !streamedReplyPromise) {
+            return;
+          }
+          queueVisibleStreamText(streamedReplyState.append(deltaText));
         };
         const postThreadReply = async (payload, stage) => {
           await beforeFirstResponsePost();
@@ -13402,19 +13743,26 @@ function createReplyToThread(deps) {
               if (explicitChannelPostIntent) {
                 return;
               }
-              if (streamedReplyPromise) {
-                textStream.push(deltaText);
+              appendVisibleStreamDelta(deltaText);
+            },
+            onAssistantMessageStart: () => {
+              if (!awaitingPostToolAssistantMessage) {
                 return;
               }
-              pendingStreamText += deltaText;
-              if (isPotentialRedundantReactionAckText(pendingStreamText)) {
-                return;
+              awaitingPostToolAssistantMessage = false;
+              discardPendingStreamPreview();
+            },
+            onToolCall: () => {
+              if (!streamedReplyPromise) {
+                awaitingPostToolAssistantMessage = true;
+                discardPendingStreamPreview();
               }
-              flushPendingStreamText();
             }
           });
           if (streamedReplyPromise) {
             flushPendingStreamText();
+          } else {
+            finalizePendingStreamText();
           }
           textStream.end();
           const diagnosticsContext = {
@@ -13488,28 +13836,32 @@ function createReplyToThread(deps) {
             }
           });
           const artifactStatePatch = reply.artifactStatePatch ? { ...reply.artifactStatePatch } : {};
-          const replyFiles = reply.files && reply.files.length > 0 ? reply.files : void 0;
-          const { shouldPostThreadReply, attachFiles: resolvedAttachFiles } = resolveReplyDelivery({
-            reply,
-            hasStreamedThreadReply: Boolean(streamedReplyPromise)
-          });
           const reactionPerformed = reply.diagnostics.toolCalls.includes(
             "slackMessageAddReaction"
           );
-          if (shouldPostThreadReply) {
+          const plannedPosts = planSlackReplyPosts({
+            reply,
+            hasStreamedThreadReply: Boolean(streamedReplyPromise),
+            streamedOverflowText: streamedReplyState.getOverflowText()
+          });
+          if (streamedReplyPromise) {
+            await streamedReplyPromise;
+          }
+          if (plannedPosts.length > 0) {
             if (!streamedReplyPromise) {
-              const sent = await postThreadReply(
-                buildSlackOutputMessage(
-                  reply.text,
-                  resolvedAttachFiles === "inline" ? replyFiles : void 0
-                ),
-                "thread_reply"
-              );
-              if (reactionPerformed && isRedundantReactionAckText(reply.text)) {
+              let sent;
+              for (const post of plannedPosts) {
+                sent = await postThreadReply(post.message, post.stage);
+              }
+              const firstPlannedMessage = plannedPosts[0]?.message;
+              const firstPlannedMessageHasFiles = typeof firstPlannedMessage === "object" && firstPlannedMessage !== null && "files" in firstPlannedMessage && Array.isArray(firstPlannedMessage.files) && firstPlannedMessage.files.length > 0;
+              if (sent && reactionPerformed && plannedPosts.length === 1 && !firstPlannedMessageHasFiles && isRedundantReactionAckText(reply.text)) {
                 await sent.delete();
               }
             } else {
-              await streamedReplyPromise;
+              for (const post of plannedPosts) {
+                await postThreadReply(post.message, post.stage);
+              }
             }
           }
           const shouldPersistArtifacts = Object.keys(artifactStatePatch).length > 0;
@@ -13585,12 +13937,6 @@ function createReplyToThread(deps) {
               );
             });
           }
-          if (shouldPostThreadReply && resolvedAttachFiles === "followup" && replyFiles) {
-            await postThreadReply(
-              buildSlackOutputMessage("", replyFiles),
-              "thread_reply_files_followup"
-            );
-          }
         } catch (error) {
           if (isRetryableTurnError(error, "mcp_auth_resume")) {
             shouldPersistFailureState = false;
@@ -13722,6 +14068,11 @@ async function initializeAssistantThread(event) {
 }
 
 // src/chat/runtime/turn-preparation.ts
+function hasPendingImageHydration(conversation) {
+  return conversation.messages.some(
+    (message) => isHumanConversationMessage(message) && !message.meta?.imagesHydrated
+  );
+}
 function createPrepareTurnState(deps) {
   return async function prepareTurnState(args) {
     const existingState = await args.thread.state;
@@ -13739,14 +14090,8 @@ function createPrepareTurnState(deps) {
       messageId: args.message.id,
       messageCreatedAtMs: args.message.metadata.dateSent.getTime()
     });
-    const messageHasPotentialImageAttachment = args.message.attachments.some(
-      (attachment) => {
-        if (attachment.type === "image") {
-          return true;
-        }
-        const mimeType = attachment.mimeType ?? "";
-        return attachment.type === "file" && mimeType.startsWith("image/");
-      }
+    const messageHasPotentialImageAttachment = hasPotentialImageAttachment(
+      args.message.attachments
     );
     const normalizedUserText = normalizeConversationText(args.userText) || "[non-text message]";
     const slackTs = getSlackMessageTs(args.message);
@@ -13771,7 +14116,8 @@ function createPrepareTurnState(deps) {
       conversation,
       incomingUserMessage
     );
-    if (isVisionEnabled() && (!conversation.vision.backfillCompletedAtMs || messageHasPotentialImageAttachment)) {
+    const shouldHydrateVisionContext = !conversation.vision.backfillCompletedAtMs || messageHasPotentialImageAttachment || hasPendingImageHydration(conversation);
+    if (isVisionEnabled() && shouldHydrateVisionContext) {
       await deps.hydrateConversationVisionContext(conversation, {
         threadId: args.context.threadId,
         channelId: args.context.channelId,
@@ -13867,7 +14213,7 @@ function createSlackRuntime(options) {
           slackTs,
           replied: false,
           skippedReason: decision.reason,
-          imagesHydrated: true
+          imagesHydrated: !hasPotentialImageAttachment(message.attachments)
         }
       });
       conversation.processing.activeTurnId = void 0;
@@ -14151,6 +14497,166 @@ var JuniorChat = class extends Chat {
   }
 };
 
+// src/chat/slack/adapter.ts
+import {
+  createSlackAdapter
+} from "@chat-adapter/slack";
+import {
+  StreamingMarkdownRenderer
+} from "chat";
+var STREAM_BUFFER_SIZE = 64;
+var CLIENT_STREAM_PATCHED = /* @__PURE__ */ Symbol("junior.slack.client_stream_patched");
+var ADAPTER_STREAM_PATCHED = /* @__PURE__ */ Symbol("junior.slack.adapter_stream_patched");
+function assertSlackAdapterInternals(internals) {
+  if (!internals.client || typeof internals.client.chatStream !== "function") {
+    throw new Error("Slack adapter client does not expose chatStream()");
+  }
+  if (typeof internals.stream !== "function") {
+    throw new Error("Slack adapter does not expose stream()");
+  }
+  if (typeof internals.decodeThreadId !== "function") {
+    throw new Error("Slack adapter does not expose decodeThreadId()");
+  }
+  if (typeof internals.getToken !== "function") {
+    throw new Error("Slack adapter does not expose getToken()");
+  }
+  if (!internals.logger || typeof internals.logger.debug !== "function" || typeof internals.logger.warn !== "function") {
+    throw new Error("Slack adapter does not expose logger debug/warn methods");
+  }
+}
+function shouldEagerFlushPlainText(text) {
+  return text.length > 0 && !text.includes("\n") && !/[`*~[\]|]/.test(text);
+}
+function getNextRenderableDelta(renderer, lastAppended) {
+  const committable = renderer.getCommittableText();
+  if (committable.startsWith(lastAppended)) {
+    const delta = committable.slice(lastAppended.length);
+    if (delta) {
+      return { delta, nextAppended: committable };
+    }
+  }
+  const rawText = renderer.getText();
+  if (shouldEagerFlushPlainText(rawText) && rawText.startsWith(lastAppended) && rawText.length > lastAppended.length) {
+    return {
+      delta: rawText.slice(lastAppended.length),
+      nextAppended: rawText
+    };
+  }
+  return { delta: "", nextAppended: lastAppended };
+}
+function patchSlackClientStream(adapter) {
+  const internals = adapter;
+  const { client: client2 } = internals;
+  if (client2[CLIENT_STREAM_PATCHED]) {
+    return;
+  }
+  const originalChatStream = client2.chatStream.bind(client2);
+  client2.chatStream = (params) => originalChatStream({
+    ...params,
+    buffer_size: STREAM_BUFFER_SIZE
+  });
+  client2[CLIENT_STREAM_PATCHED] = true;
+}
+function patchSlackAdapterStream(adapter) {
+  const internals = adapter;
+  if (internals[ADAPTER_STREAM_PATCHED]) {
+    return;
+  }
+  const originalStream = internals.stream.bind(adapter);
+  internals.stream = async function(threadId, textStream, options) {
+    if (!(options?.recipientUserId && options?.recipientTeamId)) {
+      return originalStream(threadId, textStream, options);
+    }
+    const { channel, threadTs } = internals.decodeThreadId(threadId);
+    internals.logger.debug("Slack: starting stream", { channel, threadTs });
+    const token = internals.getToken();
+    const streamer = internals.client.chatStream({
+      channel,
+      thread_ts: threadTs,
+      recipient_user_id: options.recipientUserId,
+      recipient_team_id: options.recipientTeamId,
+      ...options.taskDisplayMode ? { task_display_mode: options.taskDisplayMode } : {}
+    });
+    let first = true;
+    let lastAppended = "";
+    let structuredChunksSupported = true;
+    const renderer = new StreamingMarkdownRenderer();
+    const flushMarkdownDelta = async (delta) => {
+      if (delta.length === 0) {
+        return;
+      }
+      if (first) {
+        await streamer.append({ markdown_text: delta, token, chunks: [] });
+        first = false;
+        return;
+      }
+      await streamer.append({ markdown_text: delta });
+    };
+    const flushText = async () => {
+      const { delta, nextAppended } = getNextRenderableDelta(
+        renderer,
+        lastAppended
+      );
+      await flushMarkdownDelta(delta);
+      lastAppended = nextAppended;
+    };
+    const sendStructuredChunk = async (chunk) => {
+      if (!structuredChunksSupported) {
+        return;
+      }
+      await flushText();
+      try {
+        if (first) {
+          await streamer.append({ chunks: [chunk], token });
+          first = false;
+          return;
+        }
+        await streamer.append({ chunks: [chunk] });
+      } catch (error) {
+        structuredChunksSupported = false;
+        internals.logger.warn(
+          "Structured streaming chunk failed, falling back to text-only streaming. Ensure your Slack app manifest includes assistant_view, assistant:write scope, and @slack/web-api >= 7.14.0",
+          { chunkType: chunk.type, error }
+        );
+      }
+    };
+    const pushTextAndFlush = async (text) => {
+      renderer.push(text);
+      await flushText();
+    };
+    for await (const chunk of textStream) {
+      if (typeof chunk === "string") {
+        await pushTextAndFlush(chunk);
+      } else if (chunk.type === "markdown_text") {
+        await pushTextAndFlush(chunk.text);
+      } else {
+        await sendStructuredChunk(chunk);
+      }
+    }
+    renderer.finish();
+    await flushText();
+    const result = await streamer.stop(
+      options?.stopBlocks ? { blocks: options.stopBlocks } : void 0
+    );
+    const messageTs = result.message?.ts ?? result.ts;
+    internals.logger.debug("Slack: stream complete", { messageId: messageTs });
+    return {
+      id: messageTs,
+      threadId,
+      raw: result
+    };
+  };
+  internals[ADAPTER_STREAM_PATCHED] = true;
+}
+function createJuniorSlackAdapter(config) {
+  const adapter = createSlackAdapter(config);
+  const internals = adapter;
+  assertSlackAdapterInternals(internals);
+  patchSlackClientStream(adapter);
+  patchSlackAdapterStream(adapter);
+  return adapter;
+}
+
 // src/chat/queue/thread-message-dispatcher.ts
 function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2 = downloadPrivateSlackFile) {
   for (const attachment of message.attachments) {
@@ -14269,7 +14775,7 @@ function createProductionBot() {
         if (!signingSecret) {
           throw new Error("SLACK_SIGNING_SECRET is required");
         }
-        return createSlackAdapter({
+        return createJuniorSlackAdapter({
           logger: logger.child("slack"),
           signingSecret,
           ...botToken ? { botToken } : {},
@@ -14405,6 +14911,32 @@ function isMessageChangedEnvelope(value) {
 function textMentionsBot(text, botUserId) {
   return text.includes(`<@${botUserId}>`);
 }
+function getAttachmentType(mimeType) {
+  if (mimeType?.startsWith("image/")) {
+    return "image";
+  }
+  if (mimeType?.startsWith("video/")) {
+    return "video";
+  }
+  if (mimeType?.startsWith("audio/")) {
+    return "audio";
+  }
+  return "file";
+}
+function extractEditedMessageAttachments(files) {
+  if (!files || files.length === 0) {
+    return [];
+  }
+  return files.map((file) => ({
+    type: getAttachmentType(file.mimetype),
+    url: file.url_private_download ?? file.url_private,
+    name: file.name,
+    mimeType: file.mimetype,
+    size: file.size,
+    width: file.original_w,
+    height: file.original_h
+  }));
+}
 function extractMessageChangedMention(body, botUserId, adapter) {
   if (!isMessageChangedEnvelope(body)) return null;
   const { event } = body;
@@ -14430,7 +14962,7 @@ function extractMessageChangedMention(body, botUserId, adapter) {
     threadId,
     text: newText,
     isMention: true,
-    attachments: [],
+    attachments: extractEditedMessageAttachments(event.message.files),
     metadata: { dateSent: new Date(Number(messageTs) * 1e3), edited: true },
     formatted: { type: "root", children: [] },
     raw,
@@ -14483,6 +15015,7 @@ async function handleAuthenticatedSlackMessageChangedMention(args) {
     if (!result) {
       return false;
     }
+    rehydrateAttachmentFetchers(result.message);
     args.bot.processMessage(
       slackAdapter,
       result.threadId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "private": false,
   "publishConfig": {
     "access": "public"