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

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

@@ -1,8 +1,15 @@
 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;
+/**
+ * Slack's own SDK buffers streamed output at this size before sending, for
+ * exactly the reason we do: appends are rate-limited per call, so forwarding
+ * every token spends the budget on latency nobody can perceive.
+ */
+const STREAM_MIN_DELTA_CHARS = 256;
 const MAX_THREAD_LENGTH = 20000;
 const FALLBACK_MAIN_LENGTH = 3000;
 const WORKING_INDICATOR = " ...";
@@ -13,28 +20,43 @@ function isSlackMsgTooLong(err) {
     const message = err instanceof Error ? err.message : String(err);
     return data?.error === "msg_too_long" || message.includes("msg_too_long");
 }
+/**
+ * Where to cut a response that has to be truncated.
+ *
+ * Back off to the last line break rather than slicing at the exact budget: a
+ * hard cut lands mid-word, and since the notice is inserted between the two
+ * halves, the line cannot be read whole in either place. Only back off within
+ * reach of the limit — a response with no line break in its final quarter has
+ * nothing better to offer, and losing a quarter of it would be worse.
+ */
+function truncationCut(text, limit) {
+    if (text.length <= limit)
+        return text.length;
+    const lastBreak = text.lastIndexOf("\n", limit);
+    return lastBreak > limit * 0.75 ? lastBreak : limit;
+}
 function fallbackLongSlackText(text, overflowLink, prefixLength = FALLBACK_MAIN_LENGTH) {
     const suffix = overflowLink
         ? `\n\n_(message too long for Slack; continued in thread; session view: <${overflowLink}|open>)_`
         : "\n\n_(message too long for Slack; continued in thread)_";
-    return `${text.slice(0, prefixLength)}${suffix}`;
+    const cut = truncationCut(text, prefixLength);
+    return { text: `${text.slice(0, cut)}${suffix}`, cut };
 }
 async function postSlackTextWithFallback(post, text, overflowLink) {
     let prefixLength = FALLBACK_MAIN_LENGTH;
-    let lastErr;
     for (;;) {
-        const fallbackText = fallbackLongSlackText(text, overflowLink, prefixLength);
+        const fallback = fallbackLongSlackText(text, overflowLink, prefixLength);
         try {
-            const result = await post(fallbackText);
-            return { result, text: fallbackText, prefixLength };
+            await post(fallback.text);
+            // The continuation resumes from where the text was actually cut, which
+            // is not the nominal budget once it backs off to a line break.
+            return { text: fallback.text, prefixLength: fallback.cut };
         }
         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,351 +73,203 @@ 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;
+    /** The tail of an over-long response, awaiting delivery to a thread. */
+    let pendingContinuation = "";
+    let continuationAnchor = null;
+    /** How much of that tail the thread already holds. */
+    let continuationSent = "";
     const onAssistantStatusError = (label, err) => {
         if (assistantStatusFailureWarned)
             return;
         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)
+    /**
+     * Deliver the tail of an over-long response to its thread.
+     *
+     * Called only at points where the response is final, and idempotent, so the
+     * replace path and the end of the run can both call it without the thread
+     * seeing anything twice. Sending the whole remainder in one message is also
+     * what keeps it faithful: Slack trims message text, so every extra split is
+     * a chance to drop the whitespace it lands on.
+     */
+    const flushContinuation = async () => {
+        if (!pendingContinuation || pendingContinuation === continuationSent)
             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);
+        const isExtension = pendingContinuation.startsWith(continuationSent);
+        const unsent = isExtension
+            ? pendingContinuation.slice(continuationSent.length)
+            : pendingContinuation;
+        if (!unsent.trim())
             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);
-        }
+        await postThreadDiagnostic(isExtension && continuationSent
+            ? unsent
+            : `_(continued from truncated message)_\n\n${unsent}`, {}, continuationAnchor);
+        continuationSent = pendingContinuation;
     };
-    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);
+    // Reserve before choosing, not after failing: exceeding the start tier
+    // costs a wasted request and a visibly worse first response, and the
+    // buffered path is a working answer rather than a degraded one.
+    const streamKind = replyInThread && rootTs && slack.tryReserveStreamStart() ? "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),
+                minDeltaChars: STREAM_MIN_DELTA_CHARS,
             }
-            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));
-        },
-        setTyping: async (isTyping) => {
-            if (isTyping && !messageTs && rootTs) {
-                try {
-                    const statusText = eventFilename ? `Starting event: ${eventFilename}` : "Thinking";
-                    await slack.setAssistantStatus(channelId, rootTs, statusText);
-                }
-                catch (err) {
-                    // Assistant API not available — first respond() call will create the message.
-                    onAssistantStatusError("typing", err);
-                }
             }
         },
-        uploadFile: async (filePath, title) => {
-            await slack.uploadFile(channelId, filePath, title, rootTs);
+        onFinish: async (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));
+            }
+            // The run is over, so a truncated response has to hand over its tail now
+            // or lose it — the notice on the main message already promised it.
+            await flushContinuation();
         },
-        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);
+        isTooLongError: isSlackMsgTooLong,
+        handleTooLong: async (text, operation, options, responseId, write, getResponseId) => {
+            let overflowLink;
+            const resolveOverflowLink = () => {
+                if (overflowLink === undefined && options?.createOverflowLink) {
+                    overflowLink = options.createOverflowLink();
                 }
-            }, () => ({ working }));
+                return overflowLink;
+            };
+            const fallback = await postSlackTextWithFallback(write, text, resolveOverflowLink());
+            // The truncation notice promises a thread continuation unconditionally,
+            // so every path that prints it has to deliver one. Gating delivery on
+            // the final "replace" dropped the tail whenever a run ended on the
+            // post-stream canonical render instead — silent data loss behind a
+            // message that claimed the rest was elsewhere.
+            //
+            // Incremental renders reach this repeatedly as the text grows, so the
+            // tail is only recorded here and delivered once the response is final.
+            // Posting each increment as it arrived produced a thread of dozens of
+            // fragments, and every fragment boundary that landed on a space lost it,
+            // since Slack trims message text.
+            pendingContinuation = text.slice(fallback.prefixLength).trimStart();
+            continuationAnchor = replyInThread
+                ? (rootTs ?? getResponseId() ?? responseId)
+                : (getResponseId() ?? responseId);
+            // A replace is already the final word on this response; anything else
+            // waits for the run to finish.
+            if (operation === "replace")
+                await flushContinuation();
+            return fallback;
         },
-        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;
+        uploadFile: (filePath, title) => slack.uploadFile(channelId, filePath, title, replyInThread ? rootTs : undefined),
+        react: async (emoji) => {
+            if (!eventFilename)
+                await slack.addReaction(channelId, event.ts, emoji);
         },
-    };
+    });
     return responder;
 }
 //# sourceMappingURL=response-lifecycle.js.map