@cursor/july 0.1.99 → 0.1.101

package/dist/channels/slack/live-delivery.js

@@ -8,6 +8,11 @@
  * Assistant-pane threads only render stream APIs. Start lazily with the
  * first real markdown/chunks plus recipient ids — empty startStream is
  * rejected or never attaches.
+ *
+ * Every call speaks `chunks`. Slack pins a stream's mode at start: text
+ * opened as bare `markdown_text` rejects later `task_update` appends with
+ * `streaming_mode_mismatch`, so assistant text goes out as `markdown_text`
+ * chunks and tool steps can land in the same message.
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -18,8 +23,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { appendChatStream, startChatStream, stopChatStream } from "./api.js";
-import { computeStreamAppend } from "./stream.js";
+import { appendChatStream, postMessage, startChatStream, stopChatStream, } from "./api.js";
+import { highlightCodeFences } from "./code-fences.js";
+import { SLACK_MARKDOWN_TEXT_MAX_LEN } from "./constants.js";
+import { computeStreamAppend, markdownChunk, } from "./stream.js";
 function streamRecipients(channel) {
     const user = channel.state.triggeringUserId;
     const team = channel.state.teamId;
@@ -38,13 +45,17 @@ export function createStreamDeliveryStrategy(deps) {
         if (activeStreamTs(channel) !== null) {
             return true;
         }
-        const hasMarkdown = markdown_text !== undefined && markdown_text !== "";
-        const hasChunks = chunks !== undefined && chunks.length > 0;
-        if (!hasMarkdown && !hasChunks) {
+        const openingText = markdown_text !== null && markdown_text !== void 0 ? markdown_text : "";
+        const opening = [];
+        if (openingText !== "") {
+            opening.push(markdownChunk(highlightCodeFences(openingText)));
+        }
+        opening.push(...(chunks !== null && chunks !== void 0 ? chunks : []));
+        if (opening.length === 0) {
             return false;
         }
         const log = getLog();
-        const started = yield startChatStream(Object.assign({ botToken, channel: channelId, thread_ts: threadTs, markdown_text: hasMarkdown ? markdown_text : undefined, chunks: hasChunks ? chunks : undefined }, streamRecipients(channel)));
+        const started = yield startChatStream(Object.assign({ botToken, channel: channelId, thread_ts: threadTs, chunks: opening }, streamRecipients(channel)));
         if (!started.ok) {
             log.warn("chat.startStream unavailable", {
                 error: started.error,
@@ -59,8 +70,9 @@ export function createStreamDeliveryStrategy(deps) {
         }
         channel.state.streamTs = started.ts;
         channel.state.streamChannelId = started.channel;
-        channel.state.lastPostedText = hasMarkdown ? (markdown_text !== null && markdown_text !== void 0 ? markdown_text : "") : "";
-        channel.state.streamBlockText = channel.state.lastPostedText;
+        channel.state.streamFull = false;
+        channel.state.lastPostedText = openingText;
+        channel.state.streamBlockText = openingText;
         log.info("chat.startStream ok", {
             channel: started.channel,
             stream_ts: started.ts,
@@ -87,13 +99,19 @@ export function createStreamDeliveryStrategy(deps) {
         });
         return opened ? activeStreamTs(args.channel) : null;
     });
+    /**
+     * What to append for the new cumulative text, as Slack should see it: the
+     * block text on both sides goes through the same fence rewrite, so the
+     * delta lines up with what the stream already holds.
+     */
+    const streamDelta = (channel, text) => { var _a; return computeStreamAppend(highlightCodeFences((_a = channel.state.streamBlockText) !== null && _a !== void 0 ? _a : ""), highlightCodeFences(text)); };
     const stopWithSuffix = (args) => __awaiter(this, void 0, void 0, function* () {
-        const appendText = computeStreamAppend(args.channel.state.streamBlockText, args.text);
+        const appendText = streamDelta(args.channel, args.text);
         const stopped = yield stopChatStream({
             botToken,
             channel: args.channelId,
             ts: args.ts,
-            markdown_text: appendText === "" ? undefined : appendText,
+            chunks: appendText === "" ? undefined : [markdownChunk(appendText)],
         });
         args.channel.state.streamTs = null;
         if (stopped.ok) {
@@ -116,11 +134,67 @@ export function createStreamDeliveryStrategy(deps) {
         yield stopChatStream({ botToken, channel: channelId, ts: orphanTs });
         channel.state.streamTs = null;
     });
+    /**
+     * `msg_too_long` means the message is full: every further append would
+     * fail the same way, so appends stop until `finalize` continues the reply
+     * in a new message.
+     */
+    const noteAppendFailure = (channel, result) => {
+        if (result.unsupported === true) {
+            channel.state.streamingUnavailable = true;
+        }
+        if (result.error === "msg_too_long") {
+            channel.state.streamFull = true;
+        }
+    };
+    /**
+     * The streamed message is full. Close it as it stands so it stops spinning
+     * and post the rest as a new thread message. Most of the answer is on Slack
+     * either way, so the reply counts as delivered even if that post fails: a
+     * duplicate would be worse than a lost tail.
+     */
+    const continueOverflow = (args) => __awaiter(this, void 0, void 0, function* () {
+        const { channel, channelId, ts, remainder, sessionId } = args;
+        const log = getLog();
+        yield stopChatStream({ botToken, channel: channelId, ts });
+        channel.state.streamTs = null;
+        const threadTs = channel.state.threadTs;
+        if (remainder === "" || threadTs === null || threadTs === "") {
+            return;
+        }
+        try {
+            const posted = yield postMessage({
+                botToken,
+                channel: channelId,
+                text: remainder,
+                threadTs,
+                plainText: remainder.length >= SLACK_MARKDOWN_TEXT_MAX_LEN,
+            });
+            channel.state.lastBotMessageTs = posted.ts;
+            log.info("reply overflowed the stream; continued in a new message", {
+                channel: channelId,
+                stream_ts: ts,
+                session: sessionId,
+                continued_chars: remainder.length,
+            });
+        }
+        catch (error) {
+            log.warn("stream overflow continuation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                channel: channelId,
+                stream_ts: ts,
+                session: sessionId,
+            });
+        }
+    });
     return {
         inlineToolSteps: true,
         open,
         append(_a) {
             return __awaiter(this, arguments, void 0, function* ({ channel, channelId, text, sessionId }) {
+                if (channel.state.streamFull === true) {
+                    return;
+                }
                 const ts = yield ensureOpen({
                     channel,
                     channelId,
@@ -130,7 +204,7 @@ export function createStreamDeliveryStrategy(deps) {
                 if (ts === null) {
                     return;
                 }
-                const appendText = computeStreamAppend(channel.state.streamBlockText, text);
+                const appendText = streamDelta(channel, text);
                 if (appendText === "") {
                     return;
                 }
@@ -138,7 +212,7 @@ export function createStreamDeliveryStrategy(deps) {
                     botToken,
                     channel: channelId,
                     ts,
-                    markdown_text: appendText,
+                    chunks: [markdownChunk(appendText)],
                 });
                 if (!result.ok) {
                     getLog().warn("appendStream failed", {
@@ -147,9 +221,7 @@ export function createStreamDeliveryStrategy(deps) {
                         stream_ts: ts,
                         session: sessionId,
                     });
-                    if (result.unsupported === true) {
-                        channel.state.streamingUnavailable = true;
-                    }
+                    noteAppendFailure(channel, result);
                     return;
                 }
                 channel.state.lastPostedText = text;
@@ -158,6 +230,9 @@ export function createStreamDeliveryStrategy(deps) {
         },
         appendChunks(_a) {
             return __awaiter(this, arguments, void 0, function* ({ channel, channelId, chunks, sessionId }) {
+                if (channel.state.streamFull === true) {
+                    return false;
+                }
                 const hadStream = activeStreamTs(channel) !== null;
                 const ts = yield ensureOpen({
                     channel,
@@ -177,6 +252,16 @@ export function createStreamDeliveryStrategy(deps) {
                     ts,
                     chunks,
                 });
+                if (!result.ok) {
+                    getLog().warn("appendStream chunks failed", {
+                        error: result.error,
+                        channel: channelId,
+                        stream_ts: ts,
+                        session: sessionId,
+                        chunks: chunks.length,
+                    });
+                    noteAppendFailure(channel, result);
+                }
                 return result.ok;
             });
         },
@@ -192,12 +277,11 @@ export function createStreamDeliveryStrategy(deps) {
                 if (ts === null) {
                     return { delivered: false };
                 }
-                const stopped = yield stopWithSuffix({
-                    channel,
-                    channelId,
-                    ts,
-                    text,
-                });
+                // Measured before the stop attempt mutates stream state.
+                const remainder = streamDelta(channel, text);
+                const stopped = channel.state.streamFull === true
+                    ? { ok: false, error: "msg_too_long" }
+                    : yield stopWithSuffix({ channel, channelId, ts, text });
                 if (stopped.ok) {
                     log.info("reply delivered via stream", {
                         channel: channelId,
@@ -207,6 +291,17 @@ export function createStreamDeliveryStrategy(deps) {
                     });
                     return { delivered: true };
                 }
+                if (stopped.error === "msg_too_long") {
+                    yield continueOverflow({
+                        channel,
+                        channelId,
+                        ts,
+                        remainder,
+                        sessionId,
+                    });
+                    channel.state.lastPostedText = text;
+                    return { delivered: true };
+                }
                 log.warn("chat.stopStream failed; falling back to postMessage", {
                     error: stopped.error,
                     channel: channelId,

package/dist/channels/slack/reasoning-card.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The "Thinking" task card that receives the model's reasoning as it streams.
+ * Slack appends a card's `details` across updates, so the card is fed
+ * deltas: the part of the current reasoning block already on Slack, plus a
+ * buffer of what has not gone out yet.
+ */
+import type { ChannelEventContext } from "../../types.js";
+import type { ResolvedSlackReasoningCard } from "./reply-options.js";
+import { type StreamTaskChunk } from "./stream.js";
+import type { SlackChannelState } from "./types.js";
+type Channel = ChannelEventContext<SlackChannelState>;
+type CardStatus = "in_progress" | "complete";
+export interface ReasoningCard {
+    /** Buffer the current reasoning block's cumulative text; flushes when due. */
+    append(args: {
+        channel: Channel;
+        sessionId: string;
+        text: string;
+    }): Promise<void>;
+    /** Send buffered text and set the card status. */
+    flush(args: {
+        channel: Channel;
+        sessionId: string;
+        status: CardStatus;
+    }): Promise<void>;
+    /** The next reasoning block appends after a blank line. */
+    endBlock(channel: Channel): void;
+    inProgress(channel: Channel): boolean;
+}
+/** Delivers one chunk into the reply stream; `false` when nothing went out. */
+export type SendCardChunk = (args: {
+    channel: Channel;
+    sessionId: string;
+    chunk: StreamTaskChunk;
+}) => Promise<boolean>;
+export declare function createReasoningCard(card: ResolvedSlackReasoningCard, send: SendCardChunk): ReasoningCard;
+export {};
+//# sourceMappingURL=reasoning-card.d.ts.map

package/dist/channels/slack/reasoning-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-card.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/reasoning-card.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAoB,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAOxE,KAAK,OAAO,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;AACtD,KAAK,UAAU,GAAG,aAAa,GAAG,UAAU,CAAC;AAE7C,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,MAAM,CAAC,IAAI,EAAE;QACX,OAAO,EAAE,OAAO,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,kDAAkD;IAClD,KAAK,CAAC,IAAI,EAAE;QACV,OAAO,EAAE,OAAO,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,UAAU,CAAC;KACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;CACvC;AAED,+EAA+E;AAC/E,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,eAAe,CAAC;CACxB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAevB,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,0BAA0B,EAChC,IAAI,EAAE,aAAa,GAClB,aAAa,CA8Ef"}

package/dist/channels/slack/reasoning-card.js

@@ -0,0 +1,104 @@
+/**
+ * The "Thinking" task card that receives the model's reasoning as it streams.
+ * Slack appends a card's `details` across updates, so the card is fed
+ * deltas: the part of the current reasoning block already on Slack, plus a
+ * buffer of what has not gone out yet.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { truncateCardText } from "./stream.js";
+const FLUSH_MS = 1000;
+const FLUSH_CHARS = 160;
+const CARD_ID = "reasoning";
+const BLOCK_SEPARATOR = "\n\n";
+function cardState(state) {
+    if (state.reasoningCard === undefined) {
+        state.reasoningCard = {
+            status: null,
+            blockSent: null,
+            pending: "",
+            lastFlushMs: null,
+            chars: 0,
+        };
+    }
+    return state.reasoningCard;
+}
+export function createReasoningCard(card, send) {
+    const flush = (_a) => __awaiter(this, [_a], void 0, function* ({ channel, sessionId, status, }) {
+        const state = cardState(channel.state);
+        if (state.pending === "" &&
+            (state.status === status || state.status === null)) {
+            return;
+        }
+        const chunk = {
+            type: "task_update",
+            id: CARD_ID,
+            title: card.title,
+            status,
+        };
+        if (state.pending !== "") {
+            chunk.details = state.pending;
+        }
+        // Stamped on the attempt, so a failing stream is retried at most once
+        // per flush window instead of once per token.
+        state.lastFlushMs = Date.now();
+        if (!(yield send({ channel, sessionId, chunk }))) {
+            return;
+        }
+        state.chars += state.pending.length;
+        state.pending = "";
+        state.status = status;
+    });
+    return {
+        flush,
+        append(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, sessionId, text }) {
+                var _b;
+                const state = cardState(channel.state);
+                if (state.chars >= card.maxChars) {
+                    return;
+                }
+                const sent = (_b = state.blockSent) !== null && _b !== void 0 ? _b : 0;
+                let delta;
+                if (sent > 0 && text.length >= sent) {
+                    delta = text.slice(sent);
+                }
+                else {
+                    const hasText = state.chars + state.pending.length > 0;
+                    delta = `${hasText ? BLOCK_SEPARATOR : ""}${text}`;
+                }
+                state.blockSent = text.length;
+                if (delta === "") {
+                    return;
+                }
+                let pending = `${state.pending}${delta}`;
+                const room = card.maxChars - state.chars;
+                if (pending.length > room) {
+                    pending = truncateCardText(pending, room);
+                    state.chars = card.maxChars - pending.length;
+                }
+                state.pending = pending;
+                const due = state.lastFlushMs === null ||
+                    Date.now() - state.lastFlushMs >= FLUSH_MS ||
+                    pending.length >= FLUSH_CHARS;
+                if (due) {
+                    yield flush({ channel, sessionId, status: "in_progress" });
+                }
+            });
+        },
+        endBlock(channel) {
+            cardState(channel.state).blockSent = null;
+        },
+        inProgress(channel) {
+            var _a;
+            return ((_a = channel.state.reasoningCard) === null || _a === void 0 ? void 0 : _a.status) === "in_progress";
+        },
+    };
+}

package/dist/channels/slack/redact.d.ts

@@ -0,0 +1,2 @@
+export declare function redactSecretTokens(text: string): string;
+//# sourceMappingURL=redact.d.ts.map

package/dist/channels/slack/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/redact.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/channels/slack/redact.js

@@ -0,0 +1,5 @@
+/** Credential shapes that must never reach a Slack thread verbatim. */
+const SECRET_TOKEN = /\b(crsr_|xox[baprs]-|sk-|Bearer\s+)\S+/gi;
+export function redactSecretTokens(text) {
+    return text.replace(SECRET_TOKEN, "[redacted]");
+}

package/dist/channels/slack/reply-options.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Resolve `slackChannel({ reply, toolLabels })` — and the deprecated
+ * `streaming` / `thinkingSteps` / `loadingMessages` flags — into one config
+ * the default event handlers read.
+ */
+import type { SlackChannelOptions, SlackToolCall, SlackToolCardGroup, SlackToolResult } from "./types.js";
+export type SlackReplyMode = "post" | "stream";
+export interface ResolvedSlackStatus {
+    reasoning: boolean;
+    /** `false`, or the line to show when tool calls start. */
+    tools: false | ((calls: readonly SlackToolCall[]) => string);
+    idle: string[];
+}
+export interface ResolvedSlackToolCards {
+    group: SlackToolCardGroup;
+    details?: (call: SlackToolCall) => string | undefined;
+    output?: (result: SlackToolResult) => string | undefined;
+}
+export interface ResolvedSlackReasoningCard {
+    title: string;
+    maxChars: number;
+}
+export interface ResolvedSlackReply {
+    mode: SlackReplyMode;
+    status: ResolvedSlackStatus;
+    toolCards: false | ResolvedSlackToolCards;
+    reasoningCard: false | ResolvedSlackReasoningCard;
+    toolLabel: (toolName: string) => string;
+    /** Author-facing notices about deprecated options that were honored. */
+    deprecations: string[];
+}
+export declare const DEFAULT_REASONING_CARD_TITLE = "Thinking";
+/** A modest share of `SLACK_MARKDOWN_TEXT_MAX_LEN`, which the whole streamed message shares. */
+export declare const DEFAULT_REASONING_CARD_MAX_CHARS = 1500;
+type ReplyInputs = Pick<SlackChannelOptions, "reply" | "toolLabels" | "streaming" | "thinkingSteps"> & {
+    loadingMessages?: readonly string[];
+};
+export declare function resolveSlackReply(options: ReplyInputs): ResolvedSlackReply;
+export {};
+//# sourceMappingURL=reply-options.d.ts.map

package/dist/channels/slack/reply-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-options.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/reply-options.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,mBAAmB,EAGnB,aAAa,EACb,kBAAkB,EAElB,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/C,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,0DAA0D;IAC1D,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,KAAK,MAAM,CAAC,CAAC;IAC7D,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,MAAM,GAAG,SAAS,CAAC;IACtD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,MAAM,GAAG,SAAS,CAAC;CAC1D;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,SAAS,EAAE,KAAK,GAAG,sBAAsB,CAAC;IAC1C,aAAa,EAAE,KAAK,GAAG,0BAA0B,CAAC;IAClD,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IACxC,wEAAwE;IACxE,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,eAAO,MAAM,4BAA4B,aAAa,CAAC;AACvD,gGAAgG;AAChG,eAAO,MAAM,gCAAgC,OAAO,CAAC;AAErD,KAAK,WAAW,GAAG,IAAI,CACrB,mBAAmB,EACnB,OAAO,GAAG,YAAY,GAAG,WAAW,GAAG,eAAe,CACvD,GAAG;IAAE,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AA2H5C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,kBAAkB,CAkD1E"}

package/dist/channels/slack/reply-options.js

@@ -0,0 +1,150 @@
+/**
+ * Resolve `slackChannel({ reply, toolLabels })` — and the deprecated
+ * `streaming` / `thinkingSteps` / `loadingMessages` flags — into one config
+ * the default event handlers read.
+ */
+import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import { defaultToolCardDetails } from "./tool-cards.js";
+export const DEFAULT_REASONING_CARD_TITLE = "Thinking";
+/** A modest share of `SLACK_MARKDOWN_TEXT_MAX_LEN`, which the whole streamed message shares. */
+export const DEFAULT_REASONING_CARD_MAX_CHARS = 1500;
+function resolveToolLabel(labels) {
+    if (labels === undefined) {
+        return (toolName) => toolName;
+    }
+    const lookup = typeof labels === "function" ? labels : (name) => labels[name];
+    return (toolName) => {
+        const label = lookup(toolName);
+        return label === undefined || label === "" ? toolName : label;
+    };
+}
+function defaultToolStatusLine(toolLabel) {
+    return (calls) => {
+        const names = [...new Set(calls.map((call) => toolLabel(call.toolName)))];
+        return `Running ${names.join(", ")}…`;
+    };
+}
+function resolveIdle(idle) {
+    const cleaned = (idle !== null && idle !== void 0 ? idle : []).filter((line) => line.trim() !== "");
+    return cleaned.length > 0 ? cleaned : [...SLACK_DEFAULT_LOADING_MESSAGES];
+}
+function resolveReasoningCard(option) {
+    var _a;
+    if (option === undefined || option === false) {
+        return false;
+    }
+    const options = option === true ? {} : option;
+    const title = (_a = options.title) === null || _a === void 0 ? void 0 : _a.trim();
+    return {
+        title: title === undefined || title === ""
+            ? DEFAULT_REASONING_CARD_TITLE
+            : title,
+        maxChars: options.maxChars !== undefined && options.maxChars > 0
+            ? options.maxChars
+            : DEFAULT_REASONING_CARD_MAX_CHARS,
+    };
+}
+function resolveToolCards(option) {
+    var _a, _b;
+    const cards = option.toolCards;
+    if (cards === undefined || cards === false) {
+        return false;
+    }
+    if (cards === true) {
+        return { group: "per-tool", details: defaultToolCardDetails };
+    }
+    const group = (_a = cards.group) !== null && _a !== void 0 ? _a : "per-tool";
+    if (cards.collapsible === false) {
+        return { group };
+    }
+    return {
+        group,
+        details: (_b = cards.details) !== null && _b !== void 0 ? _b : defaultToolCardDetails,
+        output: cards.output,
+    };
+}
+/**
+ * Map the deprecated flags onto a `reply` shape with their old defaults
+ * (streaming on, per-call cards on), so a config that only sets these keeps
+ * behaving as it did. `null` when none of them is set.
+ */
+function legacyReplyOptions(options) {
+    const idle = options.loadingMessages;
+    if (options.streaming === undefined &&
+        options.thinkingSteps === undefined &&
+        idle === undefined) {
+        return null;
+    }
+    const deprecations = [];
+    const mode = options.streaming === false ? "post" : "stream";
+    // What legacy streaming showed: one title-only card per call.
+    const cards = options.thinkingSteps === false ? false : LEGACY_CARDS;
+    const replacement = mode === "post"
+        ? 'reply: { mode: "post" }'
+        : cards === false
+            ? 'reply: { mode: "stream" }'
+            : 'reply: { mode: "stream", toolCards: { group: "per-call", collapsible: false } }';
+    if (idle !== undefined) {
+        deprecations.push(`slackChannel({ loadingMessages }) is deprecated; use reply: { mode: "${mode}", status: { idle: [...] } }.`);
+    }
+    if (options.streaming !== undefined) {
+        deprecations.push(`slackChannel({ streaming: ${String(options.streaming)} }) is deprecated; use ${replacement}.`);
+    }
+    if (options.thinkingSteps !== undefined) {
+        deprecations.push(mode === "post"
+            ? "slackChannel({ thinkingSteps }) has no effect in post mode; remove it."
+            : `slackChannel({ thinkingSteps: ${String(options.thinkingSteps)} }) is deprecated; use ${replacement}.`);
+    }
+    const status = { idle };
+    if (mode === "post") {
+        return { reply: { mode, status }, deprecations };
+    }
+    return { reply: { mode, status, toolCards: cards }, deprecations };
+}
+const LEGACY_CARDS = { group: "per-call", collapsible: false };
+export function resolveSlackReply(options) {
+    var _a;
+    const deprecations = [];
+    let reply = { mode: "post" };
+    const legacy = legacyReplyOptions(options);
+    if (options.reply !== undefined) {
+        reply = options.reply;
+        if (legacy !== null) {
+            const ignored = ["streaming", "thinkingSteps", "loadingMessages"].filter((key) => options[key] !== undefined);
+            deprecations.push(`slackChannel({ ${ignored.join(", ")} }) is ignored because reply is set; remove the deprecated option${ignored.length === 1 ? "" : "s"}.`);
+        }
+    }
+    else if (legacy !== null) {
+        reply = legacy.reply;
+        deprecations.push(...legacy.deprecations);
+    }
+    const toolLabel = resolveToolLabel(options.toolLabels);
+    const statusInput = (_a = reply.status) !== null && _a !== void 0 ? _a : {};
+    const status = {
+        reasoning: statusInput.reasoning !== false,
+        tools: statusInput.tools === false
+            ? false
+            : typeof statusInput.tools === "function"
+                ? statusInput.tools
+                : defaultToolStatusLine(toolLabel),
+        idle: resolveIdle(statusInput.idle),
+    };
+    if (reply.mode === "post") {
+        return {
+            mode: "post",
+            status,
+            toolCards: false,
+            reasoningCard: false,
+            toolLabel,
+            deprecations,
+        };
+    }
+    return {
+        mode: "stream",
+        status,
+        toolCards: resolveToolCards(reply),
+        reasoningCard: resolveReasoningCard(reply.reasoningCard),
+        toolLabel,
+        deprecations,
+    };
+}

package/dist/channels/slack/slack-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAEV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AA2CxB,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,GACjB,mBAAmB,GAAG,SAAS,CAEjC;AAED,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,aAAa,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GAC9C,uBAAuB,GAAG,SAAS,CAYrC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,GAAE,mBAAwB,GACjC,iBAAiB,CAAC,iBAAiB,CAAC,CA4atC"}
+{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAEV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AA4CxB,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,GACjB,mBAAmB,GAAG,SAAS,CAEjC;AAED,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,aAAa,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GAC9C,uBAAuB,GAAG,SAAS,CAYrC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,GAAE,mBAAwB,GACjC,iBAAiB,CAAC,iBAAiB,CAAC,CAgbtC"}

package/dist/channels/slack/slack-channel.js

@@ -26,6 +26,7 @@ import { dispatchInboundFromEventBody, dispatchInboundMessage, emptySlackChannel
 import { createEventIdDedupe } from "./event-id-dedupe.js";
 import { dispatchBlockAction, dispatchInteractiveFromPayload, } from "./interactive.js";
 import { createSlackLogger } from "./log.js";
+import { resolveSlackReply } from "./reply-options.js";
 import { startSlackSocketMode, } from "./socket-mode.js";
 import { buildToolApprovalEvents } from "./tool-approval-events.js";
 /** Options used to construct a slack channel — for host-level credential binding. */
@@ -70,7 +71,8 @@ export function slackChannel(authored = {}) {
     }
     const credentials = (_a = options.credentials) !== null && _a !== void 0 ? _a : credentialsFromEnv(options.envPrefix);
     const envKeys = slackEnvKeys(options.envPrefix);
-    const loadingMessages = options.loadingMessages;
+    const reply = resolveSlackReply(options);
+    const loadingMessages = reply.status.idle;
     const policy = options.policy;
     const blockExternals = resolveSlackBlockExternals(policy);
     const defaultInbound = createDefaultOnInbound(loadingMessages, policy);
@@ -107,11 +109,13 @@ export function slackChannel(authored = {}) {
     if (options.deliverDefaults !== false) {
         Object.assign(events, buildDefaultEvents({
             credentials,
+            reply: options.reply,
+            toolLabels: options.toolLabels,
             streaming: options.streaming,
             thinkingSteps: options.thinkingSteps,
+            loadingMessages: options.loadingMessages,
             suggestedPrompts: options.suggestedPrompts,
             suggestedPromptsTitle: options.suggestedPromptsTitle,
-            loadingMessages,
             getLog,
         }));
     }
@@ -145,9 +149,9 @@ export function slackChannel(authored = {}) {
         auth: [allowAll()],
         state: emptySlackChannelState(),
         routes: [],
-        meta: Object.assign({ kind: "slack" }, (channelPosts === undefined
+        meta: Object.assign(Object.assign({ kind: "slack" }, (channelPosts === undefined
             ? {}
-            : { slackChannelPosts: [...channelPosts.allow] })),
+            : { slackChannelPosts: [...channelPosts.allow] })), { deprecations: reply.deprecations }),
         receive(input_1, _a) {
             return __awaiter(this, arguments, void 0, function* (input, { send }) {
                 var _b;