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

package/dist/adapters/slack/bot.js

@@ -1,5 +1,6 @@
 import { SocketModeClient } from "@slack/socket-mode";
 import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
+import { readEnv } from "../../env-manifest.js";
 import { existsSync, readFileSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
@@ -13,13 +14,31 @@ import { isRecord, readTextFileIfExists } from "../../utils/file-guards.js";
 import { PRODUCT_NAME, formatForceStopped } from "../../platform-messages.js";
 import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, saveIncomingAttachments, withRetry, } from "../shared.js";
 import { processMessageIntake } from "../intake.js";
+import { AssistantThreadRegistry, handleAgentContextChanged, handleAgentDmOpened, handleAssistantThreadStarted, titleAssistantThread, } from "./assistant.js";
 import { createSlackAdapters } from "./context.js";
 import { hasMaterializedChatSession, registerThreadSession, } from "../../sessions/chat-history-sync.js";
 import { conversationIdOf } from "../../sessions/session-key.js";
 import { isSlackThreadSessionKey, planSlackAdapterSession, planSlackEventAnchorRun, resolveSlackSessionKey, } from "./session.js";
 import { reportUserFacingError } from "../../observability/sentry.js";
 import { renderSlackBlocks, resolveSlackMentions } from "./blocks.js";
+import { StreamStartLimiter } from "./stream-limits.js";
 const SLACK_EVENT_ANCHOR_TEXT = "Working on it...";
+/**
+ * Slack's per-call limit on `markdown_text`: "Limit this field to 12,000
+ * characters." mikan allows far more in a message, so streamed text is split
+ * to fit rather than truncated.
+ */
+const MAX_STREAM_TEXT_CHARS = 12_000;
+/** Slices `text` into pieces that each fit one streaming call. */
+export function chunkStreamText(text, limit = MAX_STREAM_TEXT_CHARS) {
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    for (let index = 0; index < text.length; index += limit) {
+        chunks.push(text.slice(index, index + limit));
+    }
+    return chunks;
+}
 // web-api v8 throws WebAPIRateLimitedError; the duck-typed shapes cover
 // platform `data.error === "rate_limited"` / 429 responses and older callers.
 function slackIsRateLimited(err) {
@@ -112,6 +131,15 @@ export class SlackMessagingBot {
         this.startupTs = null; // Messages older than this are just logged, not processed
         this.users = new Map();
         this.channels = new Map();
+        /** Which threads belong to the assistant pane, and their last known context. */
+        this.assistantThreads = new AssistantThreadRegistry();
+        /**
+         * Native response streams opened recently. Per bot rather than per module:
+         * the rate tier applies per workspace, and this bot is the connection to
+         * one — which also means a test constructing a bot gets a fresh budget
+         * instead of inheriting whatever ran before it.
+         */
+        this.streamStarts = new StreamStartLimiter();
         this.queues = new Map();
         this.eventsWatcher = null;
         this.handler = handler;
@@ -319,22 +347,54 @@ export class SlackMessagingBot {
             await this.webClient.chat.update(payload);
         });
     }
+    /**
+     * Claim one native stream, or decline. Declining is not an error: the caller
+     * falls back to edit-based updates, which is a working answer rather than a
+     * degraded one, and costs no request against the tighter start tier.
+     */
+    tryReserveStreamStart() {
+        return this.streamStarts.tryReserve();
+    }
+    /**
+     * Open a stream, carrying text of any length.
+     *
+     * Slack caps `markdown_text` at 12,000 characters per call, and a long first
+     * render exceeds that easily — mikan allows 35,000 in a message. Rather than
+     * truncating (losing the answer) or failing (falling back to edit mode for
+     * the whole response), the opening call takes the first slice and the rest
+     * follows as appends before this resolves. The caller sees one operation
+     * that sent everything, so the renderer's idea of what has been streamed
+     * stays true.
+     *
+     * Splitting mid-word or mid-fence is harmless here: a stream concatenates,
+     * so Slack renders the reassembled text, not the pieces.
+     */
     async startMessageStream(channel, text, threadTs, recipientUserId) {
-        return slackRetry(async () => {
+        const [head, ...tail] = chunkStreamText(text);
+        const ts = await slackRetry(async () => {
             const result = await this.webClient.apiCall("chat.startStream", {
                 channel,
-                markdown_text: this.resolveMentions(text),
+                markdown_text: this.resolveMentions(head ?? ""),
                 ...(threadTs ? { thread_ts: threadTs } : {}),
                 ...(this.teamId ? { recipient_team_id: this.teamId } : {}),
                 ...(recipientUserId ? { recipient_user_id: recipientUserId } : {}),
             });
-            const ts = result.ts;
-            if (!ts)
+            const streamTs = result.ts;
+            if (!streamTs)
                 throw new Error("Slack chat.startStream did not return ts");
-            return ts;
+            return streamTs;
         });
+        for (const part of tail)
+            await this.appendStreamChunk(channel, ts, part);
+        return ts;
     }
+    /** Append a delta of any length, split to the per-call cap. */
     async appendMessageStream(channel, ts, text) {
+        for (const part of chunkStreamText(text)) {
+            await this.appendStreamChunk(channel, ts, part);
+        }
+    }
+    async appendStreamChunk(channel, ts, text) {
         return slackRetry(async () => {
             await this.webClient.apiCall("chat.appendStream", {
                 channel,
@@ -368,6 +428,69 @@ export class SlackMessagingBot {
             });
         });
     }
+    /** Offer starting points in a new assistant thread. */
+    async setAssistantSuggestedPrompts(channel, threadTs, prompts) {
+        return slackRetry(async () => {
+            // Omitting thread_ts pins the prompts to the DM itself, which is what
+            // the agent surface wants: there is no thread yet when it opens.
+            await this.webClient.assistant.threads.setSuggestedPrompts({
+                channel_id: channel,
+                ...(threadTs ? { thread_ts: threadTs } : {}),
+                prompts,
+            });
+        });
+    }
+    /** Name an assistant thread, which is what the sidebar conversation list shows. */
+    async setAssistantTitle(channel, threadTs, title) {
+        return slackRetry(async () => {
+            await this.webClient.assistant.threads.setTitle({
+                channel_id: channel,
+                thread_ts: threadTs,
+                title,
+            });
+        });
+    }
+    /** The assistant surface's view of this bot, handed to the lifecycle handlers. */
+    assistantOps() {
+        return {
+            postInThread: (channel, threadTs, text) => this.postInThread(channel, threadTs, text),
+            setSuggestedPrompts: (channel, threadTs, prompts) => this.setAssistantSuggestedPrompts(channel, threadTs, prompts),
+            setTitle: (channel, threadTs, title) => this.setAssistantTitle(channel, threadTs, title),
+            channelName: (channelId) => this.channels.get(channelId)?.name,
+        };
+    }
+    /**
+     * A new conversation opened in the assistant pane. Slack waits for the app
+     * to speak first here; staying silent is what makes the pane look broken.
+     */
+    handleAssistantThreadStarted({ event, ack }) {
+        ack();
+        const payload = event;
+        if (!payload.assistant_thread)
+            return;
+        void handleAssistantThreadStarted(this.assistantOps(), this.assistantThreads, payload.assistant_thread);
+    }
+    /**
+     * The person navigated to another channel while the pane is open. Slack
+     * sends this as `assistant_thread_context_changed` under `assistant_view`
+     * and `app_context_changed` under `agent_view`; the payload differs enough
+     * to normalize here rather than in the handler.
+     */
+    handleAgentContextChangedEvent({ event, ack, }) {
+        ack();
+        const payload = event;
+        if (payload.assistant_thread) {
+            handleAgentContextChanged(this.assistantThreads, payload.assistant_thread);
+            return;
+        }
+        const channelId = payload.channel_id ?? payload.channel;
+        if (channelId) {
+            handleAgentContextChanged(this.assistantThreads, {
+                channel_id: channelId,
+                context: payload.context,
+            });
+        }
+    }
     async postInThread(channel, threadTs, text) {
         return slackRetry(async () => {
             const payload = {
@@ -885,10 +1008,27 @@ export class SlackMessagingBot {
         this.socketClient.on("unable_to_socket_mode_start", (err) => {
             log.logWarning("Slack socket unable_to_start", err ? String(err) : "");
         });
+        // Which events Slack actually delivers is otherwise unknowable from here:
+        // a listener that never fires looks the same whether the subscription is
+        // missing, the app needs reinstalling, or the surface never emits it at
+        // all. Off by default — this is one line per event on a busy workspace.
+        if (readEnv("SLACK_TRACE_EVENTS")) {
+            this.socketClient.on("slack_event", ({ type, body }) => {
+                const inner = body?.event;
+                log.logInfo(`Slack socket event: ${type ?? "?"}${inner?.type ? ` → ${inner.type}` : ""}${inner?.tab ? ` (tab: ${inner.tab})` : ""}`);
+            });
+        }
         this.socketClient.on("app_mention", (payload) => this.handleAppMention(payload));
         this.socketClient.on("message", (payload) => this.handleMessageEvent(payload));
         this.socketClient.on("slash_commands", (payload) => void this.handleSlashCommand(payload));
         this.socketClient.on("app_home_opened", (payload) => this.handleAppHomeOpened(payload));
+        // The assistant surface's lifecycle. Both events were already subscribed
+        // in the app manifest and then dropped on the floor, which is why the pane
+        // opened empty and the sidebar filled with untitled conversations.
+        this.socketClient.on("assistant_thread_started", (payload) => this.handleAssistantThreadStarted(payload));
+        this.socketClient.on("assistant_thread_context_changed", (payload) => this.handleAgentContextChangedEvent(payload));
+        // agent_view's spelling of the same signal.
+        this.socketClient.on("app_context_changed", (payload) => this.handleAgentContextChangedEvent(payload));
         this.socketClient.on("block_actions", (payload) => void this.handleBlockAction(payload));
         this.socketClient.on("interactive", (payload) => void this.handleBlockAction(payload));
     }
@@ -992,6 +1132,12 @@ export class SlackMessagingBot {
         }
         const isThreadReply = !!e.thread_ts;
         const sessionKey = isDM ? resolveSlackSessionKey(e.channel, e.thread_ts) : undefined;
+        // Name the conversation from the first thing the person said. Guarded on
+        // the assistant registry, so classic DM threads are untouched, and it
+        // claims the title once per thread.
+        if (isDM && e.thread_ts && e.text) {
+            void titleAssistantThread(this.assistantOps(), this.assistantThreads, e.channel, e.thread_ts, this.stripOwnMention(e.text));
+        }
         const slackEvent = createConversationEvent({
             platform: "slack",
             conversationId: e.channel,
@@ -1072,6 +1218,16 @@ export class SlackMessagingBot {
     handleAppHomeOpened({ event, ack }) {
         const e = event;
         ack();
+        // Under agent_view this is how Slack says "the person opened the app's
+        // DM" — the signal assistant_thread_started used to carry. It fires on
+        // every open, not once per conversation, so this path refreshes the
+        // pinned prompts and deliberately does not greet.
+        if (e.tab === "messages") {
+            if (e.channel) {
+                void handleAgentDmOpened(this.assistantOps(), this.assistantThreads, e.channel, e.context);
+            }
+            return;
+        }
         if (e.tab !== "home")
             return;
         this.webClient.views