@cursor/july 0.1.10 → 0.1.11

package/dist/channels/slack/eval-directive.js

@@ -0,0 +1,283 @@
+/**
+ * Built-in Slack `eval` directive — run playground evals from a mention/DM
+ * without per-agent custom handlers (parity with CLI / playground runs).
+ *
+ * Examples (after stripping @mentions / cursorAccount agent name):
+ *   eval
+ *   eval triage/open-incidents smoke
+ *   eval --tag oncall
+ *   eval list
+ *   eval status
+ *   eval help
+ */
+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 { EvalRunConflictError, EvalRunEmptyError, } from "../../internal/eval-run-store.js";
+import { stripLeadingSlackMentions } from "./stop.js";
+const EVAL_POLL_MS = 2000;
+const TYPING_STATUS_MAX = 50;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Normalize inbound Slack text for directive parsing: strip leading
+ * `<@U…>` mentions, leading `@U…` markdown mentions, and an optional
+ * cursorAccount agentName prefix (`OncallBuddy eval …`).
+ */
+export function normalizeSlackEvalDirectiveBody(text, options) {
+    var _a;
+    let body = stripLeadingSlackMentions(text);
+    // markdown form from slackTextToMarkdown / cursorAccount envelopes
+    while (/^@[A-Za-z0-9._-]+\s+/.test(body)) {
+        body = body.replace(/^@[A-Za-z0-9._-]+\s+/, "").trim();
+    }
+    const agentName = (_a = options === null || options === void 0 ? void 0 : options.agentName) === null || _a === void 0 ? void 0 : _a.trim();
+    if (agentName !== undefined && agentName.length > 0) {
+        const prefix = new RegExp(`^${escapeRegExp(agentName)}\\s+`, "i");
+        body = body.replace(prefix, "").trim();
+    }
+    return body;
+}
+/**
+ * Parse a Slack eval directive. Returns null when the message is not an
+ * eval command (falls through to the normal agent handler).
+ */
+export function parseSlackEvalDirective(text, options) {
+    var _a, _b, _c;
+    const body = normalizeSlackEvalDirectiveBody(text, options);
+    if (body.length === 0) {
+        return null;
+    }
+    const tokens = body.split(/\s+/).filter((t) => t.length > 0);
+    if (tokens.length === 0 || !/^eval$/i.test((_a = tokens[0]) !== null && _a !== void 0 ? _a : "")) {
+        return null;
+    }
+    const rest = tokens.slice(1);
+    if (rest.length === 0) {
+        return { kind: "run" };
+    }
+    const head = ((_b = rest[0]) !== null && _b !== void 0 ? _b : "").toLowerCase();
+    if (rest.length === 1 &&
+        (head === "help" || head === "-h" || head === "--help")) {
+        return { kind: "help" };
+    }
+    if (rest.length === 1 && (head === "list" || head === "ls")) {
+        return { kind: "list" };
+    }
+    if (rest.length === 1 && head === "status") {
+        return { kind: "status" };
+    }
+    const filterIds = [];
+    const tags = [];
+    for (let i = 0; i < rest.length; i++) {
+        const tok = (_c = rest[i]) !== null && _c !== void 0 ? _c : "";
+        if (tok === "--tag" || tok === "-t") {
+            const value = rest[i + 1];
+            if (value === undefined || value.length === 0) {
+                return { kind: "help" };
+            }
+            tags.push(value);
+            i += 1;
+            continue;
+        }
+        if (tok.startsWith("--tag=")) {
+            const value = tok.slice("--tag=".length);
+            if (value.length === 0) {
+                return { kind: "help" };
+            }
+            tags.push(value);
+            continue;
+        }
+        if (tok.startsWith("-t=") && tok.length > 3) {
+            tags.push(tok.slice(3));
+            continue;
+        }
+        if (tok.startsWith("-")) {
+            // Unknown flag — surface help rather than treating as an eval id.
+            return { kind: "help" };
+        }
+        filterIds.push(tok);
+    }
+    const run = { kind: "run" };
+    if (filterIds.length > 0) {
+        run.filterIds = filterIds;
+    }
+    if (tags.length > 0) {
+        run.tags = tags;
+    }
+    return run;
+}
+/** True when either raw Slack text or markdown form is an eval directive. */
+export function isSlackEvalDirective(text, markdown, options) {
+    return (parseSlackEvalDirective(text, options) !== null ||
+        parseSlackEvalDirective(markdown, options) !== null);
+}
+export function formatSlackEvalHelp() {
+    return [
+        "*Eval commands* (same batches as the playground / `agentkit eval --prod`):",
+        "• `eval` — run all evals",
+        "• `eval <id> [id…]` — run specific eval ids",
+        "• `eval --tag <tag>` — run evals with a tag (`-t` also works)",
+        "• `eval list` — list available evals",
+        "• `eval status` — show the active or latest eval run",
+        "• `eval help` — this message",
+    ].join("\n");
+}
+export function formatSlackEvalList(evals) {
+    if (evals.length === 0) {
+        return "No evals found under `evals/`.";
+    }
+    const lines = [`*${evals.length} eval(s):*`];
+    for (const item of evals) {
+        const tags = item.tags === undefined || item.tags.length === 0
+            ? ""
+            : ` _[${item.tags.join(", ")}]_`;
+        const desc = item.description === undefined || item.description === ""
+            ? ""
+            : ` — ${item.description}`;
+        lines.push(`• \`${item.id}\`${tags}${desc}`);
+    }
+    return lines.join("\n");
+}
+export function formatSlackEvalRunSummary(run) {
+    const { summary } = run;
+    const statusLabel = run.status === "completed"
+        ? "completed"
+        : run.status === "failed"
+            ? "failed"
+            : "running";
+    const lines = [
+        `*Eval run* \`${run.runId}\` — *${statusLabel}*`,
+        `• ${summary.passed} passed, ${summary.failed} failed, ${summary.total} total` +
+            (summary.done < summary.total
+                ? ` (${summary.done}/${summary.total} done)`
+                : ""),
+    ];
+    if (run.error !== undefined && run.error !== "") {
+        lines.push(`• error: ${run.error}`);
+    }
+    for (const c of run.cases) {
+        const mark = c.status !== "done"
+            ? c.status === "running"
+                ? "RUN "
+                : "….  "
+            : c.ok === true
+                ? "PASS"
+                : "FAIL";
+        const dur = c.durationMs === undefined
+            ? ""
+            : ` (${(c.durationMs / 1000).toFixed(1)}s)`;
+        const err = c.ok === false && c.error !== undefined && c.error !== ""
+            ? ` — ${c.error}`
+            : "";
+        lines.push(`\`${mark}\` \`${c.id}\`${dur}${err}`);
+    }
+    return lines.join("\n");
+}
+function truncateTyping(status) {
+    if (status.length <= TYPING_STATUS_MAX) {
+        return status;
+    }
+    return `${status.slice(0, TYPING_STATUS_MAX - 1)}…`;
+}
+function sleep(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    });
+}
+function safeTyping(binding, status) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield binding.thread.startTyping(truncateTyping(status));
+        }
+        catch (_a) {
+            // best-effort status
+        }
+    });
+}
+function safePost(binding, text) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield binding.thread.post(text);
+        }
+        catch (_a) {
+            // best-effort reply
+        }
+    });
+}
+/**
+ * Handle a parsed Slack eval directive against {@link HostEvalsApi}.
+ * Posts results in-thread; does not start an agent turn.
+ */
+export function handleSlackEvalDirective(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { directive, evals, binding } = args;
+        const pollMs = (_a = args.pollMs) !== null && _a !== void 0 ? _a : EVAL_POLL_MS;
+        if (directive.kind === "help") {
+            yield safePost(binding, formatSlackEvalHelp());
+            return;
+        }
+        if (directive.kind === "list") {
+            const listed = yield evals.list();
+            yield safePost(binding, formatSlackEvalList(listed.evals));
+            return;
+        }
+        if (directive.kind === "status") {
+            const { runs, activeRunId } = yield evals.listRunsWithActive();
+            const run = (_b = (activeRunId === undefined ? undefined : yield evals.get(activeRunId))) !== null && _b !== void 0 ? _b : runs[0];
+            if (run === undefined) {
+                yield safePost(binding, "No eval runs yet. Try `eval list` then `eval`.");
+                return;
+            }
+            yield safePost(binding, formatSlackEvalRunSummary(run));
+            return;
+        }
+        yield safeTyping(binding, "Starting evals…");
+        let run;
+        try {
+            run = yield evals.start({
+                filterIds: directive.filterIds,
+                tags: directive.tags,
+            });
+        }
+        catch (error) {
+            if (error instanceof EvalRunConflictError) {
+                const active = yield evals.get(error.activeRunId);
+                yield safePost(binding, active === undefined
+                    ? `An eval run is already in progress (\`${error.activeRunId}\`).`
+                    : `An eval run is already in progress:\n${formatSlackEvalRunSummary(active)}`);
+                return;
+            }
+            if (error instanceof EvalRunEmptyError) {
+                yield safePost(binding, "No matching evals. Try `eval list` or `eval help`.");
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            yield safePost(binding, `Failed to start evals: ${message}`);
+            return;
+        }
+        yield safePost(binding, `Started eval run \`${run.runId}\` (${run.summary.total} case(s)).`);
+        while (run.status === "running") {
+            yield safeTyping(binding, `Evals ${run.summary.done}/${run.summary.total}…`);
+            yield sleep(pollMs);
+            const next = yield evals.get(run.runId);
+            if (next === undefined) {
+                yield safePost(binding, `Eval run \`${run.runId}\` disappeared before completion.`);
+                return;
+            }
+            run = next;
+        }
+        yield safePost(binding, formatSlackEvalRunSummary(run));
+        yield safeTyping(binding, "Evals done.");
+    });
+}

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

@@ -28,6 +28,7 @@ export * from "./cursor-account.js";
 export * from "./defaults.js";
 export * from "./dispatch.js";
 export * from "./doctor.js";
+export * from "./eval-directive.js";
 export * from "./event-id-dedupe.js";
 export * from "./inbound.js";
 export * from "./init.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC"}

package/dist/channels/slack/index.js

@@ -28,6 +28,7 @@ export * from "./cursor-account.js";
 export * from "./defaults.js";
 export * from "./dispatch.js";
 export * from "./doctor.js";
+export * from "./eval-directive.js";
 export * from "./event-id-dedupe.js";
 export * from "./inbound.js";
 export * from "./init.js";

package/dist/channels/slack/post-update-delivery.js

@@ -0,0 +1,318 @@
+/**
+ * Live-reply delivery strategies for the Slack default handlers.
+ *
+ * A single strategy owns how an in-progress reply is opened, updated,
+ * finalized, and cleaned up so the handlers in `defaults.ts` don't fork on the
+ * delivery mode at every event:
+ *
+ * - `stream`: Slack chat.startStream / appendStream / stopStream.
+ * - `post-update`: a chat.postMessage skeleton edited with chat.update. This is
+ *   the only path that preserves Cursor-account identity pinning (which only
+ *   covers postMessage).
+ *
+ * `buildDefaultEvents` selects one via {@link selectLiveDeliveryStrategy} up
+ * front and calls into it. All calls keep the same soft-fail / log behavior as
+ * the inlined logic they replaced.
+ */
+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 { appendChatStream, deleteMessage, postMessage, setThreadStatus, startChatStream, stopChatStream, updateMessage, } from "./api.js";
+import { SLACK_POST_UPDATE_MIN_INTERVAL_MS } from "./constants.js";
+import { computeStreamAppend } from "./stream.js";
+function createPostUpdateStrategy(deps) {
+    const { botToken, getLog } = deps;
+    return {
+        inlineToolSteps: false,
+        start(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, threadTs, sessionId }) {
+                const log = getLog();
+                try {
+                    const posted = yield postMessage({
+                        botToken,
+                        channel: channelId,
+                        text: "…",
+                        threadTs,
+                    });
+                    if (posted.ts !== "") {
+                        channel.state.streamTs = posted.ts;
+                        channel.state.streamChannelId = channelId;
+                        channel.state.lastPostedText = "";
+                        log.info("postMessage skeleton ok", {
+                            channel: channelId,
+                            message_ts: posted.ts,
+                            session: sessionId,
+                        });
+                    }
+                }
+                catch (error) {
+                    log.warn("postMessage skeleton failed", {
+                        error: error instanceof Error ? error.message : String(error),
+                        channel: channelId,
+                        session: sessionId,
+                    });
+                    // Transient proxy/network failures must not permanently disable
+                    // live delivery — only the stream path sets streamingUnavailable
+                    // when Slack reports the feature unsupported.
+                }
+            });
+        },
+        append(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                var _b;
+                const now = Date.now();
+                const isFirstUpdate = channel.state.lastPostedText === null ||
+                    channel.state.lastPostedText === "";
+                const lastAt = (_b = channel.state.lastPostUpdateAtMs) !== null && _b !== void 0 ? _b : 0;
+                const due = isFirstUpdate || now - lastAt >= SLACK_POST_UPDATE_MIN_INTERVAL_MS;
+                if (!due) {
+                    // Skip intermediate update; message.completed flushes full text.
+                    return;
+                }
+                const result = yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text,
+                });
+                if (!result.ok) {
+                    getLog().warn("chat.update failed", {
+                        error: result.error,
+                        channel: channelId,
+                        message_ts: streamTs,
+                        session: sessionId,
+                    });
+                    return;
+                }
+                channel.state.lastPostUpdateAtMs = now;
+                channel.state.lastPostedText = text;
+            });
+        },
+        finalize(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                const log = getLog();
+                const result = yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text,
+                });
+                channel.state.streamTs = null;
+                if (result.ok) {
+                    channel.state.lastPostedText = text;
+                    log.info("reply delivered via chat.update", {
+                        channel: channelId,
+                        message_ts: streamTs,
+                        session: sessionId,
+                        chars: text.length,
+                    });
+                    return { delivered: true };
+                }
+                log.warn("chat.update finalize failed; falling back to postMessage", {
+                    error: result.error,
+                    channel: channelId,
+                    message_ts: streamTs,
+                    session: sessionId,
+                });
+                // Only suppress the fallback when the skeleton already holds the exact
+                // final text. Partial updates must not permanently truncate.
+                if (channel.state.lastPostedText === text) {
+                    return { delivered: true };
+                }
+                // The skeleton still shows the placeholder or a stale partial and we're
+                // about to post the full reply as a fresh message. Best-effort delete the
+                // orphan so the thread doesn't show a duplicate.
+                yield deleteMessage({ botToken, channel: channelId, ts: streamTs });
+                return { delivered: false };
+            });
+        },
+        finalizeEmpty(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channelId, streamTs }) {
+                yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text: " ",
+                });
+            });
+        },
+        cleanupOrphan(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel }) {
+                var _b;
+                // A skeleton that was never finalized (e.g. an empty turn that produced
+                // no message.completed) would otherwise linger as a "…" placeholder
+                // forever. Best-effort delete it and clear typing.
+                const orphanTs = channel.state.streamTs;
+                if (orphanTs === null || orphanTs === "") {
+                    return;
+                }
+                const orphanChannelId = (_b = channel.state.streamChannelId) !== null && _b !== void 0 ? _b : channel.state.channelId;
+                if (orphanChannelId !== null && orphanChannelId !== "") {
+                    yield deleteMessage({
+                        botToken,
+                        channel: orphanChannelId,
+                        ts: orphanTs,
+                    });
+                }
+                channel.state.streamTs = null;
+                if (channel.state.channelId !== null && channel.state.threadTs !== null) {
+                    yield setThreadStatus({
+                        botToken,
+                        channelId: channel.state.channelId,
+                        threadTs: channel.state.threadTs,
+                        status: "",
+                    });
+                }
+            });
+        },
+        fail(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, errorText }) {
+                const updated = yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text: errorText,
+                });
+                channel.state.streamTs = null;
+                return { delivered: updated.ok };
+            });
+        },
+    };
+}
+function createStreamStrategy(deps) {
+    const { botToken, getLog } = deps;
+    return {
+        inlineToolSteps: true,
+        start(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, threadTs, sessionId }) {
+                const log = getLog();
+                const started = yield startChatStream({
+                    botToken,
+                    channel: channelId,
+                    thread_ts: threadTs,
+                    markdown_text: "",
+                });
+                if (!started.ok) {
+                    log.warn("chat.startStream unavailable", {
+                        error: started.error,
+                        channel: channelId,
+                        thread_ts: threadTs,
+                        session: sessionId,
+                    });
+                    if (started.unsupported === true) {
+                        channel.state.streamingUnavailable = true;
+                    }
+                    return;
+                }
+                channel.state.streamTs = started.ts;
+                channel.state.streamChannelId = started.channel;
+                channel.state.lastPostedText = "";
+                log.info("chat.startStream ok", {
+                    channel: started.channel,
+                    stream_ts: started.ts,
+                    session: sessionId,
+                });
+            });
+        },
+        append(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                const appendText = computeStreamAppend(channel.state.lastPostedText, text);
+                if (appendText === "") {
+                    return;
+                }
+                const result = yield appendChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    markdown_text: appendText,
+                });
+                if (!result.ok) {
+                    getLog().warn("appendStream failed", {
+                        error: result.error,
+                        channel: channelId,
+                        stream_ts: streamTs,
+                        session: sessionId,
+                    });
+                    if (result.unsupported === true) {
+                        channel.state.streamingUnavailable = true;
+                    }
+                    return;
+                }
+                channel.state.lastPostedText = text;
+            });
+        },
+        finalize(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                const log = getLog();
+                // Only send the unsent suffix — full text was already appended.
+                const appendText = computeStreamAppend(channel.state.lastPostedText, text);
+                const stopped = yield stopChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    markdown_text: appendText === "" ? undefined : appendText,
+                });
+                if (stopped.ok) {
+                    channel.state.streamTs = null;
+                    channel.state.lastPostedText = text;
+                    log.info("reply delivered via stream", {
+                        channel: channelId,
+                        stream_ts: streamTs,
+                        session: sessionId,
+                        chars: text.length,
+                    });
+                    return { delivered: true };
+                }
+                log.warn("chat.stopStream failed; falling back to postMessage", {
+                    error: stopped.error,
+                    channel: channelId,
+                    stream_ts: streamTs,
+                    session: sessionId,
+                });
+                if (stopped.unsupported === true) {
+                    channel.state.streamingUnavailable = true;
+                }
+                channel.state.streamTs = null;
+                // If we already streamed content, do not post the full reply again.
+                const alreadyStreamed = typeof channel.state.lastPostedText === "string" &&
+                    channel.state.lastPostedText.length > 0;
+                return { delivered: alreadyStreamed };
+            });
+        },
+        finalizeEmpty(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channelId, streamTs }) {
+                yield stopChatStream({ botToken, channel: channelId, ts: streamTs });
+            });
+        },
+        cleanupOrphan() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // The stream path closes its message in message.completed / turn.failed;
+                // there is nothing to clean up after turn.completed.
+            });
+        },
+        fail(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, errorText }) {
+                const stopped = yield stopChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    markdown_text: errorText,
+                });
+                channel.state.streamTs = null;
+                return { delivered: stopped.ok };
+            });
+        },
+    };
+}
+/** Pick the live-reply delivery strategy for a `buildDefaultEvents` instance. */
+export function selectLiveDeliveryStrategy(deps, usePostUpdate) {
+    return usePostUpdate
+        ? createPostUpdateStrategy(deps)
+        : createStreamStrategy(deps);
+}

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;AAGH,OAAO,KAAK,EACV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AAsCxB,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAC7D,OAAO,GAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,CAAC,GAAG;IAChD,SAAS,CAAC,EAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC;CACnC,GACL,iBAAiB,CAAC,iBAAiB,CAAC,CAqYtC"}
+{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AAsCxB,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAC7D,OAAO,GAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,CAAC,GAAG;IAChD,SAAS,CAAC,EAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC;CACnC,GACL,iBAAiB,CAAC,iBAAiB,CAAC,CAwYtC"}

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

@@ -90,6 +90,7 @@ export function slackChannel(options = {}) {
     const engagement = (_h = options.engagement) !== null && _h !== void 0 ? _h : {};
     const mentionsEnabled = engagement.mentions !== false;
     const directMessagesEnabled = engagement.directMessages !== false;
+    const evalCommandsEnabled = options.evalCommands !== false;
     const channelPosts = engagement.channelPosts;
     if (channelPosts !== undefined) {
         const entries = channelPosts.allow.filter((entry) => entry.trim() !== "");
@@ -130,7 +131,8 @@ export function slackChannel(options = {}) {
             onDirectMessage,
             credentials,
             eventIds, host: args.host, log: getLog(), mentionsEnabled,
-            directMessagesEnabled }, (args.hasContinuationSession === undefined
+            directMessagesEnabled,
+            evalCommandsEnabled }, (args.hasContinuationSession === undefined
             ? {}
             : { hasContinuationSession: args.hasContinuationSession })), (args.isContinuationBusy === undefined
             ? {}
@@ -238,7 +240,7 @@ export function slackChannel(options = {}) {
                             getBotId: () => botId,
                             log: getLog(),
                             dispatch: (message, eventId) => {
-                                args.waitUntil(dispatchInboundMessage(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ kind: "channel_post", message, handler: onChannelPost, send: args.send, credentials, host: args.host, log: getLog() }, (args.hasContinuationSession === undefined
+                                args.waitUntil(dispatchInboundMessage(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ kind: "channel_post", message, handler: onChannelPost, send: args.send, credentials, host: args.host, log: getLog(), evalCommandsEnabled }, (args.hasContinuationSession === undefined
                                     ? {}
                                     : {
                                         hasContinuationSession: args.hasContinuationSession,

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

@@ -332,6 +332,13 @@ export interface SlackChannelOptions {
      * entry at 50 chars). Defaults to Thinking… / Working on it… / Almost there….
      */
     loadingMessages?: string[];
+    /**
+     * Built-in Slack `eval` / `eval list` / `eval status` directive that runs
+     * playground eval batches (`host.evals` / `/v1/dev/evals/runs`) without an
+     * agent turn. Defaults to `true`. Set `false` to leave `eval …` for the
+     * model handler instead.
+     */
+    evalCommands?: boolean;
     /** Optional teardown (e.g. stop example-local debouncers). Runs after Socket Mode stops. */
     onStop?: () => void | Promise<void>;
 }