@geminixiang/mikan 1.0.0-beta.4 → 1.0.0-beta.40

package/dist/adapters/slack/context.js

@@ -1,14 +1,16 @@
+import { createConversationMessage, } from "../../adapter.js";
+import {} from "./bot.js";
 import { createSlackResponseContext } from "./response-lifecycle.js";
 import { planSlackAdapterSession } from "./session.js";
-const SLACK_FORMATTING_GUIDE = `## Slack Formatting (mrkdwn, NOT Markdown)
-Bold: *text*, Italic: _text_, Code: \`code\`, Block: \`\`\`code\`\`\`, Links: <url|text>
-Do NOT use **double asterisks** or [markdown](links).`;
 export function createSlackAdapters(event, slack, adapterOptions = {}) {
     const sessionPlan = planSlackAdapterSession(event, {
         initialMessageTs: adapterOptions.initialMessageTs,
     });
     const user = slack.getUser(event.user);
-    const message = {
+    const message = createConversationMessage({
+        platform: "slack",
+        conversationId: event.conversationId,
+        address: event.address,
         id: event.ts,
         sessionKey: sessionPlan.sessionKey,
         conversationKind: event.conversationKind,
@@ -20,18 +22,10 @@ export function createSlackAdapters(event, slack, adapterOptions = {}) {
             localPath: a.localPath,
         })),
         threadTs: event.thread_ts,
-    };
-    const platform = {
-        name: "slack",
-        formattingGuide: SLACK_FORMATTING_GUIDE,
-        channels: slack.getAllChannels().map((c) => ({ id: c.id, name: c.name })),
-        users: slack
-            .getAllUsers()
-            .map((u) => ({ id: u.id, userName: u.userName, displayName: u.displayName })),
-        diagnostics: {
-            showUsageSummary: true,
-        },
-    };
+    });
+    // The bot's getMessagingInfo() is the single authority for platform info;
+    // context factories compose from it instead of maintaining a second copy.
+    const platform = slack.getMessagingInfo();
     const responder = createSlackResponseContext({
         event,
         slack,
@@ -39,6 +33,6 @@ export function createSlackAdapters(event, slack, adapterOptions = {}) {
         replyMode: adapterOptions.replyMode ?? "top-level",
         message,
     });
-    return { message, responder, platform };
+    return { address: message.address, message, responder, platform };
 }
 //# sourceMappingURL=context.js.map

package/dist/adapters/slack/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/adapters/slack/context.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAIvD,MAAM,sBAAsB,GAAG;;sDAEuB,CAAC;AAEvD,MAAM,UAAU,mBAAmB,CACjC,KAAiB,EACjB,KAAwB,EACxB,cAAc,GAAwB,EAAE;IAMxC,MAAM,WAAW,GAAG,uBAAuB,CAAC,KAAK,EAAE;QACjD,gBAAgB,EAAE,cAAc,CAAC,gBAAgB;KAClD,CAAC,CAAC;IACH,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEvC,MAAM,OAAO,GAAwB;QACnC,EAAE,EAAE,KAAK,CAAC,EAAE;QACZ,UAAU,EAAE,WAAW,CAAC,UAAU;QAClC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,MAAM,EAAE,KAAK,CAAC,IAAI;QAClB,QAAQ,EAAE,IAAI,EAAE,QAAQ;QACxB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,WAAW,EAAE,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACjD,IAAI,EAAE,CAAC,CAAC,QAAQ;YAChB,SAAS,EAAE,CAAC,CAAC,SAAS;SACvB,CAAC,CAAC;QACH,QAAQ,EAAE,KAAK,CAAC,SAAS;KAC1B,CAAC;IAEF,MAAM,QAAQ,GAAkB;QAC9B,IAAI,EAAE,OAAO;QACb,eAAe,EAAE,sBAAsB;QACvC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QACzE,KAAK,EAAE,KAAK;aACT,WAAW,EAAE;aACb,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/E,WAAW,EAAE;YACX,gBAAgB,EAAE,IAAI;SACvB;KACF,CAAC;IAEF,MAAM,SAAS,GAAG,0BAA0B,CAAC;QAC3C,KAAK;QACL,KAAK;QACL,WAAW;QACX,SAAS,EAAE,cAAc,CAAC,SAAS,IAAI,WAAW;QAClD,OAAO;KACR,CAAC,CAAC;IAEH,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;AAC1C,CAAC","sourcesContent":["import type { ConversationMessage, ConversationResponder, MessagingInfo } from \"../../adapter.js\";\nimport { type SlackMessagingBot, type SlackEvent } from \"./bot.js\";\nimport { createSlackResponseContext } from \"./response-lifecycle.js\";\nimport { planSlackAdapterSession } from \"./session.js\";\nexport type { SlackAdapterOptions } from \"./types.js\";\nimport type { SlackAdapterOptions } from \"./types.js\";\n\nconst SLACK_FORMATTING_GUIDE = `## Slack Formatting (mrkdwn, NOT Markdown)\nBold: *text*, Italic: _text_, Code: \\`code\\`, Block: \\`\\`\\`code\\`\\`\\`, Links: <url|text>\nDo NOT use **double asterisks** or [markdown](links).`;\n\nexport function createSlackAdapters(\n  event: SlackEvent,\n  slack: SlackMessagingBot,\n  adapterOptions: SlackAdapterOptions = {},\n): {\n  message: ConversationMessage;\n  responder: ConversationResponder;\n  platform: MessagingInfo;\n} {\n  const sessionPlan = planSlackAdapterSession(event, {\n    initialMessageTs: adapterOptions.initialMessageTs,\n  });\n  const user = slack.getUser(event.user);\n\n  const message: ConversationMessage = {\n    id: event.ts,\n    sessionKey: sessionPlan.sessionKey,\n    conversationKind: event.conversationKind,\n    userId: event.user,\n    userName: user?.userName,\n    text: event.text,\n    attachments: (event.attachments || []).map((a) => ({\n      name: a.original,\n      localPath: a.localPath,\n    })),\n    threadTs: event.thread_ts,\n  };\n\n  const platform: MessagingInfo = {\n    name: \"slack\",\n    formattingGuide: SLACK_FORMATTING_GUIDE,\n    channels: slack.getAllChannels().map((c) => ({ id: c.id, name: c.name })),\n    users: slack\n      .getAllUsers()\n      .map((u) => ({ id: u.id, userName: u.userName, displayName: u.displayName })),\n    diagnostics: {\n      showUsageSummary: true,\n    },\n  };\n\n  const responder = createSlackResponseContext({\n    event,\n    slack,\n    sessionPlan,\n    replyMode: adapterOptions.replyMode ?? \"top-level\",\n    message,\n  });\n\n  return { message, responder, platform };\n}\n"]}
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/adapters/slack/context.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,GAI1B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAA2C,MAAM,UAAU,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAKvD,MAAM,UAAU,mBAAmB,CACjC,KAAiB,EACjB,KAAwB,EACxB,cAAc,GAAwB,EAAE;IAOxC,MAAM,WAAW,GAAG,uBAAuB,CAAC,KAAK,EAAE;QACjD,gBAAgB,EAAE,cAAc,CAAC,gBAAgB;KAClD,CAAC,CAAC;IACH,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEvC,MAAM,OAAO,GAAG,yBAAyB,CAAC;QACxC,QAAQ,EAAE,OAAO;QACjB,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,EAAE,EAAE,KAAK,CAAC,EAAE;QACZ,UAAU,EAAE,WAAW,CAAC,UAAU;QAClC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,MAAM,EAAE,KAAK,CAAC,IAAI;QAClB,QAAQ,EAAE,IAAI,EAAE,QAAQ;QACxB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,WAAW,EAAE,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACjD,IAAI,EAAE,CAAC,CAAC,QAAQ;YAChB,SAAS,EAAE,CAAC,CAAC,SAAS;SACvB,CAAC,CAAC;QACH,QAAQ,EAAE,KAAK,CAAC,SAAS;KAC1B,CAAC,CAAC;IAEH,0EAA0E;IAC1E,0EAA0E;IAC1E,MAAM,QAAQ,GAAkB,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAEzD,MAAM,SAAS,GAAG,0BAA0B,CAAC;QAC3C,KAAK;QACL,KAAK;QACL,WAAW;QACX,SAAS,EAAE,cAAc,CAAC,SAAS,IAAI,WAAW;QAClD,OAAO;KACR,CAAC,CAAC;IAEH,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;AACpE,CAAC","sourcesContent":["import {\n  createConversationMessage,\n  type ConversationMessage,\n  type ConversationResponder,\n  type MessagingInfo,\n} from \"../../adapter.js\";\nimport { type SlackMessagingBot, type SlackEvent } from \"./bot.js\";\nimport { createSlackResponseContext } from \"./response-lifecycle.js\";\nimport { planSlackAdapterSession } from \"./session.js\";\nexport type { SlackAdapterOptions } from \"./types.js\";\nimport type { SlackAdapterOptions } from \"./types.js\";\nimport type { OfficeAddress } from \"../../adapter.js\";\n\nexport function createSlackAdapters(\n  event: SlackEvent,\n  slack: SlackMessagingBot,\n  adapterOptions: SlackAdapterOptions = {},\n): {\n  address: OfficeAddress;\n  message: ConversationMessage;\n  responder: ConversationResponder;\n  platform: MessagingInfo;\n} {\n  const sessionPlan = planSlackAdapterSession(event, {\n    initialMessageTs: adapterOptions.initialMessageTs,\n  });\n  const user = slack.getUser(event.user);\n\n  const message = createConversationMessage({\n    platform: \"slack\",\n    conversationId: event.conversationId,\n    address: event.address,\n    id: event.ts,\n    sessionKey: sessionPlan.sessionKey,\n    conversationKind: event.conversationKind,\n    userId: event.user,\n    userName: user?.userName,\n    text: event.text,\n    attachments: (event.attachments || []).map((a) => ({\n      name: a.original,\n      localPath: a.localPath,\n    })),\n    threadTs: event.thread_ts,\n  });\n\n  // The bot's getMessagingInfo() is the single authority for platform info;\n  // context factories compose from it instead of maintaining a second copy.\n  const platform: MessagingInfo = slack.getMessagingInfo();\n\n  const responder = createSlackResponseContext({\n    event,\n    slack,\n    sessionPlan,\n    replyMode: adapterOptions.replyMode ?? \"top-level\",\n    message,\n  });\n\n  return { address: message.address, message, responder, platform };\n}\n"]}

package/dist/adapters/slack/response-lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/adapters/slack/response-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAkB,MAAM,kBAAkB,CAAC;AASnG,OAAO,EAA2B,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAC5F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AA+D1D,wBAAgB,0BAA0B,CAAC,EACzC,KAAK,EACL,KAAK,EACL,WAAW,EACX,SAAS,EACT,OAAO,GACR,EAAE;IACD,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,iBAAiB,CAAC;IACzB,WAAW,EAAE,uBAAuB,CAAC;IACrC,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;IAClC,OAAO,EAAE,mBAAmB,CAAC;CAC9B,GAAG,qBAAqB,CAmaxB"}
+{"version":3,"file":"response-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/adapters/slack/response-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAkB,MAAM,kBAAkB,CAAC;AAInG,OAAO,EAA2B,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAE5F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAwE1D,wBAAgB,0BAA0B,CAAC,EACzC,KAAK,EACL,KAAK,EACL,WAAW,EACX,SAAS,EACT,OAAO,GACR,EAAE;IACD,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,iBAAiB,CAAC;IACzB,WAAW,EAAE,uBAAuB,CAAC;IACrC,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;IAClC,OAAO,EAAE,mBAAmB,CAAC;CAC9B,GAAG,qBAAqB,CAiKxB"}

package/dist/adapters/slack/response-lifecycle.js

@@ -1,8 +1,9 @@
 import * as log from "../../log.js";
-import { createChatResponseErrorReporter, formatToolArgs, splitText, } from "../shared.js";
-import { BufferedResponseStream } from "../streaming.js";
+import { createProgressiveRenderer } from "../progressive-renderer.js";
+import { formatToolArgs, splitText } from "../shared.js";
 import { buildMrkdwnContextBlock } from "./bot.js";
-const MAX_MAIN_LENGTH = 35000; // Best-effort streaming cap; final responses use Slack error-driven fallback.
+import { renderSlackBlocks } from "./blocks.js";
+const MAX_MAIN_LENGTH = 35000;
 const MAX_THREAD_LENGTH = 20000;
 const FALLBACK_MAIN_LENGTH = 3000;
 const WORKING_INDICATOR = " ...";
@@ -21,20 +22,17 @@ function fallbackLongSlackText(text, overflowLink, prefixLength = FALLBACK_MAIN_
 }
 async function postSlackTextWithFallback(post, text, overflowLink) {
     let prefixLength = FALLBACK_MAIN_LENGTH;
-    let lastErr;
     for (;;) {
         const fallbackText = fallbackLongSlackText(text, overflowLink, prefixLength);
         try {
-            const result = await post(fallbackText);
-            return { result, text: fallbackText, prefixLength };
+            await post(fallbackText);
+            return { text: fallbackText, prefixLength };
         }
         catch (err) {
             if (!isSlackMsgTooLong(err))
                 throw err;
-            lastErr = err;
-            if (prefixLength === 0) {
-                throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
-            }
+            if (prefixLength === 0)
+                throw err;
             prefixLength = Math.max(0, Math.floor(prefixLength / 2));
         }
     }
@@ -51,8 +49,28 @@ function formatSlackToolResult(result) {
     text += `*Result:*\n\`\`\`\n${result.result}\n\`\`\``;
     return text;
 }
+function closeOpenFences(text) {
+    let openMarker = null;
+    for (const line of text.split("\n")) {
+        const marker = line.match(/^\s*(`{3,}|~{3,})/)?.[1];
+        if (marker === undefined)
+            continue;
+        if (openMarker === null)
+            openMarker = marker;
+        else if (marker[0] === openMarker[0] && marker.length >= openMarker.length)
+            openMarker = null;
+    }
+    return openMarker ? `${text}\n${openMarker}` : text;
+}
+function needsCanonicalRender(text) {
+    return renderSlackBlocks(text).blocks.some((block) => block.type === "table");
+}
 export function createSlackResponseContext({ event, slack, sessionPlan, replyMode, message, }) {
-    let messageTs = sessionPlan.initialMessageTs ?? null;
+    const channelId = event.channel;
+    const conversationId = event.conversationId;
+    const eventFilename = event.ts.match(/^event:([^:]+(?:\.json)?)/)?.[1];
+    const { rootTs, isThreaded } = sessionPlan;
+    const replyInThread = Boolean(rootTs && (isThreaded || replyMode === "thread"));
     let assistantStatusFailureWarned = false;
     const onAssistantStatusError = (label, err) => {
         if (assistantStatusFailureWarned)
@@ -60,342 +78,127 @@ export function createSlackResponseContext({ event, slack, sessionPlan, replyMod
         assistantStatusFailureWarned = true;
         log.logWarning(`Slack setAssistantStatus failed (${label}; further occurrences suppressed for this session)`, err instanceof Error ? err.message : String(err));
     };
-    const threadMessageTs = [];
-    let accumulatedText = "";
-    let isWorking = true;
-    let mainResponseLogged = false;
-    let streamActive = false;
-    let streamUnavailable = false;
-    let streamedText = "";
-    let updatePromise = Promise.resolve();
-    const channelId = event.channel;
-    const conversationId = event.conversationId;
-    // Slack message timestamps are numeric; event-file triggers use `event:<filename>`.
-    const eventFilename = event.ts.match(/^event:([^:]+(?:\.json)?)/)?.[1];
-    const { rootTs, isThreaded } = sessionPlan;
-    const replyInThread = Boolean(rootTs && (isThreaded || replyMode === "thread"));
-    /**
-     * Post the first visible reply.
-     * Default Slack behavior is now top-level channel replies.
-     * If the triggering message is already inside a thread, stay in that thread.
-     */
-    const postFirstMessage = async (text) => {
-        if (replyInThread && rootTs) {
-            return slack.postInThread(channelId, rootTs, text);
-        }
-        return slack.postMessage(channelId, text);
-    };
-    const postDiagnosticDirect = async (text, options) => {
-        const threadAnchor = messageTs ?? rootTs;
+    const postThreadDiagnostic = async (text, options = {}, responseId) => {
+        const threadAnchor = responseId ?? rootTs;
         if (!threadAnchor)
-            return;
+            return [];
+        const ids = [];
         for (const part of splitText(text, MAX_THREAD_LENGTH, formatSlackContinuation)) {
-            if (options?.style === "muted") {
-                const ts = await slack.postInThreadBlocks(channelId, threadAnchor, part, [
+            if (options.style === "muted") {
+                ids.push(await slack.postInThreadBlocks(channelId, threadAnchor, part, [
                     buildMrkdwnContextBlock(part),
-                ]);
-                threadMessageTs.push(ts);
+                ]));
             }
             else {
-                const diagnosticText = options?.style === "error" ? `_${part}_` : part;
-                const ts = await slack.postInThread(channelId, threadAnchor, diagnosticText);
-                threadMessageTs.push(ts);
+                ids.push(await slack.postInThread(channelId, threadAnchor, options.style === "error" ? `_${part}_` : part));
             }
         }
+        return ids;
     };
-    const reportResponseError = createChatResponseErrorReporter(() => ({
-        platform: "slack",
-        conversationId,
-        channelId,
-        messageId: message.id,
-        sessionKey: message.sessionKey,
-        responseMessageId: messageTs,
-        threadTs: rootTs,
-        conversationKind: message.conversationKind,
-        isThreaded,
-    }));
-    const postOrUpdateMain = async (body, handleMsgTooLong = true) => {
-        const writeMain = async (text) => {
-            if (messageTs) {
-                await slack.updateMessage(channelId, messageTs, text);
-                return;
-            }
-            if (replyInThread && rootTs) {
-                messageTs = await slack.postInThread(channelId, rootTs, text);
-                return messageTs;
-            }
-            messageTs = await postFirstMessage(text);
-            return messageTs;
-        };
-        try {
-            await writeMain(body);
-        }
-        catch (err) {
-            if (!handleMsgTooLong || !isSlackMsgTooLong(err))
-                throw err;
-            const fallback = await postSlackTextWithFallback(writeMain, body);
-            accumulatedText = fallback.text;
-            stream.setText(accumulatedText);
-        }
-    };
-    const abandonActiveStream = async () => {
-        if (!streamActive || !messageTs)
-            return;
-        const failedStreamTs = messageTs;
-        streamActive = false;
-        streamedText = "";
-        await slack.stopMessageStream(channelId, failedStreamTs).catch(() => undefined);
-        if (messageTs === failedStreamTs)
-            messageTs = null;
-    };
-    const startOrAppendStream = async (text, displayText) => {
-        if (streamUnavailable) {
-            await postOrUpdateMain(displayText);
-            return;
-        }
-        try {
-            if (messageTs && streamActive) {
-                if (!text.startsWith(streamedText)) {
-                    await abandonActiveStream();
-                    await postOrUpdateMain(displayText);
-                    return;
-                }
-                const delta = text.slice(streamedText.length);
-                if (delta) {
-                    await slack.appendMessageStream(channelId, messageTs, delta);
-                    streamedText = text;
-                }
-                return;
-            }
-            if (!replyInThread || !rootTs) {
-                streamUnavailable = true;
-                await postOrUpdateMain(displayText);
-                return;
-            }
-            messageTs = await slack.startMessageStream(channelId, text, rootTs, event.user);
-            streamActive = true;
-            streamedText = text;
-        }
-        catch (err) {
-            streamUnavailable = true;
-            log.logWarning("Slack streaming unavailable; falling back to chat.update", err instanceof Error ? err.message : String(err));
-            await abandonActiveStream();
-            await postOrUpdateMain(displayText);
-        }
-    };
-    const stream = new BufferedResponseStream({
-        flush: async (text) => {
-            accumulatedText = text;
-            const mainLimit = isWorking ? MAX_MAIN_LENGTH - WORKING_INDICATOR.length : MAX_MAIN_LENGTH;
-            if (accumulatedText.length > mainLimit) {
-                accumulatedText =
-                    accumulatedText.substring(0, mainLimit - TRUNCATION_NOTE_INCREMENTAL.length) +
-                        TRUNCATION_NOTE_INCREMENTAL;
-                stream.setText(accumulatedText);
-            }
-            const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-            await startOrAppendStream(text, displayText);
+    const streamKind = replyInThread && rootTs ? "native" : "buffered";
+    const { responder } = createProgressiveRenderer({
+        label: "Slack",
+        maxLength: MAX_MAIN_LENGTH,
+        initialResponseId: sessionPlan.initialMessageTs ?? null,
+        formatContinuation: formatSlackContinuation,
+        errorPrefix: "",
+        workingIndicator: streamKind === "buffered" ? WORKING_INDICATOR : undefined,
+        formatProvisional: (text, working) => {
+            const closed = closeOpenFences(text);
+            return working ? `${closed}${WORKING_INDICATOR}` : closed;
         },
-        finish: async (text) => {
-            accumulatedText = text;
-            isWorking = false;
-            if (streamActive && messageTs) {
-                try {
-                    if (!accumulatedText.startsWith(streamedText)) {
-                        await abandonActiveStream();
-                        await postOrUpdateMain(accumulatedText);
-                        return;
-                    }
-                    const delta = accumulatedText.slice(streamedText.length);
-                    if (delta) {
-                        await slack.appendMessageStream(channelId, messageTs, delta);
-                        streamedText = accumulatedText;
-                    }
-                    await slack.stopMessageStream(channelId, messageTs);
-                    streamActive = false;
-                    streamedText = "";
-                    return;
-                }
-                catch (err) {
-                    streamUnavailable = true;
-                    log.logWarning("Slack streaming unavailable; falling back to chat.update", err instanceof Error ? err.message : String(err));
-                    await abandonActiveStream();
-                }
-            }
-            if (messageTs || accumulatedText) {
-                await postOrUpdateMain(accumulatedText);
-            }
+        prepareSource: (text, working) => {
+            const limit = working ? MAX_MAIN_LENGTH - WORKING_INDICATOR.length : MAX_MAIN_LENGTH;
+            if (text.length <= limit)
+                return text;
+            return `${text.slice(0, Math.max(0, limit - TRUNCATION_NOTE_INCREMENTAL.length))}${TRUNCATION_NOTE_INCREMENTAL}`;
         },
-    });
-    const queueResponseOperation = async (label, operation, work, context) => {
-        updatePromise = updatePromise.then(async () => {
-            try {
-                await work();
+        supportsDeltas: true,
+        stream: streamKind === "native"
+            ? {
+                start: (text) => slack.startMessageStream(channelId, text, rootTs, event.user),
+                append: (id, delta) => slack.appendMessageStream(channelId, id, delta),
+                stop: (id) => slack.stopMessageStream(channelId, id),
             }
-            catch (err) {
-                log.logWarning(`Slack ${label} error`, err instanceof Error ? err.message : String(err));
-                reportResponseError(err, operation, context(err));
+            : undefined,
+        needsCanonicalRender,
+        formatToolResult: formatSlackToolResult,
+        responseErrorContext: (responseId) => ({
+            platform: "slack",
+            conversationId,
+            channelId,
+            messageId: message.id,
+            sessionKey: message.sessionKey,
+            responseMessageId: responseId,
+            threadTs: rootTs,
+            conversationKind: message.conversationKind,
+            isThreaded,
+        }),
+        post: (text) => replyInThread && rootTs
+            ? slack.postInThread(channelId, rootTs, text)
+            : slack.postMessage(channelId, text),
+        update: (id, text) => slack.updateMessage(channelId, id, text),
+        postExtra: (text, responseId) => slack.postInThread(channelId, responseId ?? rootTs ?? "", text),
+        postDiagnostic: postThreadDiagnostic,
+        delete: async (id) => {
+            if (rootTs) {
+                await slack
+                    .setAssistantStatus(channelId, rootTs, "")
+                    .catch((err) => onAssistantStatusError("clear-on-delete", err));
             }
-        });
-        await updatePromise;
-    };
-    const responder = {
-        respond: async (text) => {
-            await queueResponseOperation("respond", "respond", async () => {
-                accumulatedText = accumulatedText ? `${accumulatedText}\n${text}` : text;
-                const mainLimit = isWorking
-                    ? MAX_MAIN_LENGTH - WORKING_INDICATOR.length
-                    : MAX_MAIN_LENGTH;
-                if (accumulatedText.length > mainLimit) {
-                    accumulatedText =
-                        accumulatedText.substring(0, mainLimit - TRUNCATION_NOTE_INCREMENTAL.length) +
-                            TRUNCATION_NOTE_INCREMENTAL;
-                }
-                stream.setText(accumulatedText);
-                const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-                await startOrAppendStream(text, displayText);
-            }, () => ({
-                phase: messageTs ? "update" : "initial_post",
-                textLength: text.length,
-                accumulatedLength: accumulatedText.length,
-            }));
+            await slack.deleteMessage(channelId, id);
         },
-        appendResponseDelta: async (delta) => {
-            await queueResponseOperation("appendResponseDelta", "respond", async () => {
-                await stream.append(delta);
-            }, () => ({ textLength: delta.length, accumulatedLength: stream.getText().length }));
+        deleteExtra: (id) => slack.deleteMessage(channelId, String(id)),
+        setTyping: async (isTyping, responseId) => {
+            if (isTyping && !responseId && rootTs) {
+                const statusText = eventFilename ? `Starting event: ${eventFilename}` : "Thinking";
+                await slack
+                    .setAssistantStatus(channelId, rootTs, statusText)
+                    .catch((err) => onAssistantStatusError("typing", err));
+            }
         },
-        finishResponse: async (finalText) => {
-            await queueResponseOperation("finishResponse", "set_working", async () => {
-                await stream.finish(finalText);
-                accumulatedText = stream.getText();
-                if (messageTs && accumulatedText.trim() && !mainResponseLogged) {
-                    slack.logBotResponse(channelId, accumulatedText, messageTs, replyInThread ? rootTs : undefined);
-                    mainResponseLogged = true;
-                }
-                if (!rootTs)
-                    return;
+        onWorkingChanged: async (working, responseId) => {
+            if (!working && responseId && rootTs) {
                 await slack
                     .setAssistantStatus(channelId, rootTs, "")
                     .catch((err) => onAssistantStatusError("clear-on-idle", err));
-            }, () => ({ finalTextLength: finalText?.length }));
-        },
-        replaceResponse: async (text, options) => {
-            await queueResponseOperation("replaceResponse", "replace_response", async () => {
-                // Lazy: only mint a token if Slack actually rejects the message.
-                let overflowLink;
-                const resolveOverflowLink = () => {
-                    if (overflowLink === undefined && options?.createOverflowLink) {
-                        overflowLink = options.createOverflowLink();
-                    }
-                    return overflowLink;
-                };
-                accumulatedText = text;
-                stream.setText(accumulatedText);
-                const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-                try {
-                    if (streamActive && messageTs) {
-                        await slack.stopMessageStream(channelId, messageTs);
-                        streamActive = false;
-                        streamedText = "";
-                    }
-                    await postOrUpdateMain(displayText, false);
-                }
-                catch (err) {
-                    if (!isSlackMsgTooLong(err))
-                        throw err;
-                    const link = resolveOverflowLink();
-                    const fallback = await postSlackTextWithFallback(async (body) => {
-                        await postOrUpdateMain(body);
-                    }, text, link);
-                    accumulatedText = fallback.text;
-                    const continuation = text.slice(fallback.prefixLength).trimStart();
-                    if (continuation) {
-                        await postDiagnosticDirect(`_(continued from truncated message)_\n\n${continuation}`);
-                    }
-                }
-            }, () => ({
-                textLength: text.length,
-                hadExistingResponse: Boolean(messageTs),
-            }));
-        },
-        respondDiagnostic: async (text, options) => {
-            await queueResponseOperation("respondDiagnostic", "respond_diagnostic", async () => {
-                await postDiagnosticDirect(text, options);
-            }, () => ({
-                textLength: text.length,
-                style: options?.style,
-            }));
+            }
         },
-        respondToolResult: async (result) => {
-            await responder.respondDiagnostic(formatSlackToolResult(result));
+        onFinish: (text, responseId) => {
+            if (responseId && text.trim()) {
+                slack.logBotResponse(channelId, text, responseId, replyInThread ? rootTs : undefined);
+            }
+            if (rootTs) {
+                void slack
+                    .setAssistantStatus(channelId, rootTs, "")
+                    .catch((err) => onAssistantStatusError("clear-on-idle", err));
+            }
         },
-        setTyping: async (isTyping) => {
-            if (isTyping && !messageTs && rootTs) {
-                try {
-                    const statusText = eventFilename ? `Starting event: ${eventFilename}` : "Thinking";
-                    await slack.setAssistantStatus(channelId, rootTs, statusText);
+        handleTooLong: async (text, operation, options, responseId, write, getResponseId) => {
+            let overflowLink;
+            const resolveOverflowLink = () => {
+                if (overflowLink === undefined && options?.createOverflowLink) {
+                    overflowLink = options.createOverflowLink();
                 }
-                catch (err) {
-                    // Assistant API not available — first respond() call will create the message.
-                    onAssistantStatusError("typing", err);
+                return overflowLink;
+            };
+            const fallback = await postSlackTextWithFallback(write, text, operation === "replace" ? resolveOverflowLink() : undefined);
+            if (operation === "replace") {
+                const continuation = text.slice(fallback.prefixLength).trimStart();
+                if (continuation) {
+                    await postThreadDiagnostic(`_(continued from truncated message)_\n\n${continuation}`, {}, replyInThread
+                        ? (rootTs ?? getResponseId() ?? responseId)
+                        : (getResponseId() ?? responseId));
                 }
             }
+            return fallback;
         },
-        uploadFile: async (filePath, title) => {
-            await slack.uploadFile(channelId, filePath, title, rootTs);
+        uploadFile: (filePath, title) => slack.uploadFile(channelId, filePath, title, replyInThread ? rootTs : undefined),
+        react: async (emoji) => {
+            if (!eventFilename)
+                await slack.addReaction(channelId, event.ts, emoji);
         },
-        setWorking: async (working) => {
-            await queueResponseOperation("setWorking", "set_working", async () => {
-                isWorking = working;
-                if (messageTs) {
-                    const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-                    const updates = streamActive && !isWorking
-                        ? [
-                            slack.stopMessageStream(channelId, messageTs).then(() => {
-                                streamActive = false;
-                            }),
-                        ]
-                        : [slack.updateMessage(channelId, messageTs, displayText)];
-                    if (!working && rootTs) {
-                        updates.push(slack
-                            .setAssistantStatus(channelId, rootTs, "")
-                            .catch((err) => onAssistantStatusError("clear-on-idle", err)));
-                    }
-                    await Promise.all(updates);
-                }
-            }, () => ({ working }));
-        },
-        deleteResponse: async () => {
-            updatePromise = updatePromise.then(async () => {
-                // Clear assistant status first
-                if (rootTs) {
-                    try {
-                        await slack.setAssistantStatus(channelId, rootTs, "");
-                    }
-                    catch {
-                        // Ignore errors clearing status
-                    }
-                }
-                // Delete thread messages first (in reverse order)
-                for (let i = threadMessageTs.length - 1; i >= 0; i--) {
-                    try {
-                        await slack.deleteMessage(channelId, threadMessageTs[i]);
-                    }
-                    catch {
-                        // Ignore errors deleting thread messages
-                    }
-                }
-                threadMessageTs.length = 0;
-                // Then delete main message
-                if (messageTs) {
-                    await slack.deleteMessage(channelId, messageTs);
-                    messageTs = null;
-                }
-            });
-            await updatePromise;
-        },
-    };
+    });
     return responder;
 }
 //# sourceMappingURL=response-lifecycle.js.map