@cursor/july 0.1.97 → 0.1.100

package/dist/channels/slack/live-delivery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-delivery.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/live-delivery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE,KAAK,YAAY,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,MAAM,EAAE,MAAM,QAAQ,CAAC;CACxB;AAED,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,yEAAyE;IACzE,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,YAAY,CACV,IAAI,EAAE,UAAU,GAAG;QAAE,MAAM,EAAE,eAAe,EAAE,CAAA;KAAE,GAC/C,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB;;;OAGG;IACH,QAAQ,CACN,IAAI,EAAE,UAAU,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAClC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACnC,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,IAAI,CACF,IAAI,EAAE,UAAU,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GACvC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACpC;AAmBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,gBAAgB,GACrB,oBAAoB,CA0PtB"}
+{"version":3,"file":"live-delivery.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/live-delivery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAQ1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE,KAAK,YAAY,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,MAAM,EAAE,MAAM,QAAQ,CAAC;CACxB;AAED,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,yEAAyE;IACzE,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,YAAY,CACV,IAAI,EAAE,UAAU,GAAG;QAAE,MAAM,EAAE,eAAe,EAAE,CAAA;KAAE,GAC/C,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB;;;OAGG;IACH,QAAQ,CACN,IAAI,EAAE,UAAU,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAClC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACnC,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,IAAI,CACF,IAAI,EAAE,UAAU,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GACvC,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACpC;AAmBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,gBAAgB,GACrB,oBAAoB,CA2VtB"}

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,9 @@ 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 { 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 +44,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(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,7 +69,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.streamFull = false;
+        channel.state.lastPostedText = openingText;
+        channel.state.streamBlockText = openingText;
         log.info("chat.startStream ok", {
             channel: started.channel,
             stream_ts: started.ts,
@@ -87,12 +99,12 @@ export function createStreamDeliveryStrategy(deps) {
         return opened ? activeStreamTs(args.channel) : null;
     });
     const stopWithSuffix = (args) => __awaiter(this, void 0, void 0, function* () {
-        const appendText = computeStreamAppend(args.channel.state.lastPostedText, args.text);
+        const appendText = computeStreamAppend(args.channel.state.streamBlockText, 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) {
@@ -115,11 +127,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,
@@ -129,7 +197,7 @@ export function createStreamDeliveryStrategy(deps) {
                 if (ts === null) {
                     return;
                 }
-                const appendText = computeStreamAppend(channel.state.lastPostedText, text);
+                const appendText = computeStreamAppend(channel.state.streamBlockText, text);
                 if (appendText === "") {
                     return;
                 }
@@ -137,7 +205,7 @@ export function createStreamDeliveryStrategy(deps) {
                     botToken,
                     channel: channelId,
                     ts,
-                    markdown_text: appendText,
+                    chunks: [markdownChunk(appendText)],
                 });
                 if (!result.ok) {
                     getLog().warn("appendStream failed", {
@@ -146,16 +214,18 @@ 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;
+                channel.state.streamBlockText = text;
             });
         },
         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,
@@ -175,6 +245,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;
             });
         },
@@ -190,12 +270,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 = computeStreamAppend(channel.state.streamBlockText, 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,
@@ -205,6 +284,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/progress-delivery.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Mid-turn thread progress when `chat.startStream` is unavailable.
+ * One editable message; `setThreadStatus` stays on the caller.
+ */
+import type { ChannelEventContext } from "../../types.js";
+import type { SlackLog } from "./log.js";
+import type { SlackBotToken, SlackChannelState } from "./types.js";
+type SlackChannel = ChannelEventContext<SlackChannelState>;
+export interface ProgressDeliveryDeps {
+    botToken: SlackBotToken | undefined;
+    getLog: () => SlackLog;
+}
+export interface ProgressDelivery {
+    upsert(args: {
+        channel: SlackChannel;
+        text: string;
+    }): Promise<void>;
+    replace(args: {
+        channel: SlackChannel;
+        text: string;
+    }): Promise<boolean>;
+    clear(args: {
+        channel: SlackChannel;
+    }): Promise<void>;
+}
+export declare function createProgressDelivery(deps: ProgressDeliveryDeps): ProgressDelivery;
+export {};
+//# sourceMappingURL=progress-delivery.d.ts.map

package/dist/channels/slack/progress-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-delivery.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/progress-delivery.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE,KAAK,YAAY,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,MAAM,EAAE,MAAM,QAAQ,CAAC;CACxB;AAOD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrE,OAAO,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzE,KAAK,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,oBAAoB,GACzB,gBAAgB,CAsGlB"}

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

@@ -0,0 +1,115 @@
+/**
+ * Mid-turn thread progress when `chat.startStream` is unavailable.
+ * One editable message; `setThreadStatus` stays on the caller.
+ */
+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 { deleteMessage, postMessage, updateMessage } from "./api.js";
+function activeProgressTs(state) {
+    const ts = state.progressTs;
+    return ts == null || ts === "" ? null : ts;
+}
+export function createProgressDelivery(deps) {
+    const { botToken, getLog } = deps;
+    const clear = (args) => __awaiter(this, void 0, void 0, function* () {
+        const state = args.channel.state;
+        const ts = activeProgressTs(state);
+        state.progressTs = null;
+        if (ts === null || state.channelId === null) {
+            return;
+        }
+        const deleted = yield deleteMessage({
+            botToken,
+            channel: state.channelId,
+            ts,
+        });
+        if (!deleted.ok) {
+            getLog().warn("progress delete failed", {
+                error: deleted.error,
+                channel: state.channelId,
+                progress_ts: ts,
+            });
+        }
+    });
+    return {
+        upsert(args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const state = args.channel.state;
+                if (state.channelId === null ||
+                    state.threadTs === null ||
+                    args.text === "") {
+                    return;
+                }
+                const existing = activeProgressTs(state);
+                if (existing !== null) {
+                    const updated = yield updateMessage({
+                        botToken,
+                        channel: state.channelId,
+                        ts: existing,
+                        text: args.text,
+                    });
+                    if (updated.ok) {
+                        return;
+                    }
+                    getLog().warn("progress update failed; posting a new message", {
+                        error: updated.error,
+                        channel: state.channelId,
+                        thread_ts: state.threadTs,
+                        progress_ts: existing,
+                    });
+                    yield clear({ channel: args.channel });
+                }
+                try {
+                    const posted = yield postMessage({
+                        botToken,
+                        channel: state.channelId,
+                        threadTs: state.threadTs,
+                        text: args.text,
+                    });
+                    state.progressTs = posted.ts;
+                }
+                catch (error) {
+                    getLog().warn(`progress post failed: ${error instanceof Error ? error.message : String(error)}`, {
+                        channel: state.channelId,
+                        thread_ts: state.threadTs,
+                    });
+                }
+            });
+        },
+        replace(args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const state = args.channel.state;
+                const ts = activeProgressTs(state);
+                if (ts === null || state.channelId === null || args.text === "") {
+                    return false;
+                }
+                const updated = yield updateMessage({
+                    botToken,
+                    channel: state.channelId,
+                    ts,
+                    text: args.text,
+                });
+                if (!updated.ok) {
+                    getLog().warn("progress replace failed", {
+                        error: updated.error,
+                        channel: state.channelId,
+                        progress_ts: ts,
+                    });
+                    return false;
+                }
+                state.lastPostedText = args.text;
+                state.lastBotMessageTs = ts;
+                state.progressTs = null;
+                return true;
+            });
+        },
+        clear,
+    };
+}

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"}