@cursor/july 0.1.1

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

@@ -0,0 +1,32 @@
+/**
+ * Scaffold a Slack channel into an agent-serve project.
+ */
+export interface InitSlackOptions {
+    dir: string;
+    /** Display name for the Slack app. Defaults to directory basename. */
+    name?: string;
+    description?: string;
+    /**
+     * Env prefix for tokens (`MY_AGENT` → `MY_AGENT_SLACK_BOT_TOKEN`). Defaults to
+     * the directory basename so multi-agent serve can mount several Slack bots.
+     * Pass `""` to use the shared `SLACK_BOT_TOKEN` / `SLACK_APP_TOKEN` globals.
+     */
+    envPrefix?: string;
+    /**
+     * Subscribe the generated manifests to `message.channels` +
+     * `message.groups` for the opt-in channel watch
+     * (`engagement.channelPosts` on `slackChannel`).
+     */
+    channelPosts?: boolean;
+}
+export interface InitSlackResult {
+    rootDir: string;
+    files: string[];
+    envPrefix: string | undefined;
+    envKeys: {
+        bot: string;
+        app: string;
+    };
+}
+export declare function initSlackChannel(options: InitSlackOptions): Promise<InitSlackResult>;
+//# sourceMappingURL=init.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/init.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,sEAAsE;IACtE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACvC;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA+F1B"}

package/dist/channels/slack/init.js

@@ -0,0 +1,82 @@
+/**
+ * Scaffold a Slack channel into an agent-serve project.
+ */
+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 { mkdir, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { envPrefixFromName, slackEnvKeys } from "./credentials.js";
+import { buildSlackManifestPair } from "./manifest.js";
+export function initSlackChannel(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const rootDir = resolve(options.dir);
+        const name = (_a = options.name) !== null && _a !== void 0 ? _a : basename(rootDir);
+        const envPrefix = options.envPrefix === ""
+            ? undefined
+            : ((_b = options.envPrefix) !== null && _b !== void 0 ? _b : envPrefixFromName(basename(rootDir)));
+        const envKeys = slackEnvKeys(envPrefix);
+        const written = [];
+        const write = (rel, contents) => __awaiter(this, void 0, void 0, function* () {
+            const abs = join(rootDir, rel);
+            yield mkdir(join(abs, ".."), { recursive: true });
+            yield writeFile(abs, contents, { flag: "wx" });
+            written.push(rel);
+        });
+        const envPrefixLine = envPrefix === undefined
+            ? ""
+            : `  envPrefix: ${JSON.stringify(envPrefix)},\n`;
+        yield write("agent/channels/slack.ts", `import { slackChannel } from "@anysphere/agent-serve/channels/slack";
+
+/**
+ * Slack channel (Socket Mode).
+ *
+ * Tokens: ${envKeys.bot} + ${envKeys.app}
+ * (see .agent-serve/slack/env.example).
+ *
+ * Full setup: agent-serve slack setup
+ */
+export default slackChannel({
+${envPrefixLine}  // Streaming and thinking steps default to true.
+  suggestedPrompts: [
+    { title: "Help", message: "How can you help me?" },
+    { title: "Status", message: "What are you working on?" },
+  ],
+});
+`);
+        const pair = buildSlackManifestPair(Object.assign(Object.assign({ name }, (options.description === undefined
+            ? {}
+            : { description: options.description })), (options.channelPosts === true ? { channelPosts: true } : {})));
+        yield write(".agent-serve/slack/manifest.dev.json", `${JSON.stringify(pair.dev, null, 2)}\n`);
+        yield write(".agent-serve/slack/manifest.prod.json", `${JSON.stringify(pair.prod, null, 2)}\n`);
+        yield write(".agent-serve/slack/env.example", `# Copy to .env.local (or export in your shell). Use the *dev* Slack app
+# for local development; use the Prod app tokens in deployment secrets.
+#
+# Multi-agent serve needs a distinct Slack app (and token pair) per agent.
+
+${envKeys.bot}=xoxb-...
+${envKeys.app}=xapp-...
+`);
+        yield write(".agent-serve/slack/setup-status.json", `${JSON.stringify({
+            updatedAt: new Date().toISOString(),
+            envPrefix: envPrefix !== null && envPrefix !== void 0 ? envPrefix : null,
+            envKeys,
+            phases: {
+                generate: true,
+                createApps: false,
+                install: false,
+                env: false,
+                serve: false,
+                smoke: false,
+            },
+        }, null, 2)}\n`);
+        return { rootDir, files: written, envPrefix, envKeys };
+    });
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Socket Mode interactive payloads (Block Kit Approve/Deny).
+ */
+import type { ApprovalDecision, AuthContext, ChannelSession, PendingApproval } from "../../types.js";
+import { type SlackLog } from "./log.js";
+import type { SlackCredentials } from "./types.js";
+export interface SlackInteractiveDispatchDeps {
+    credentials: SlackCredentials | undefined;
+    getSession: (sessionId: string) => Promise<ChannelSession | null>;
+    resolveApproval: (sessionId: string, callId: string, decision: ApprovalDecision, auth: AuthContext | null) => Promise<PendingApproval>;
+    waitUntil: (promise: Promise<unknown>) => void;
+    log?: SlackLog;
+}
+/**
+ * Handle a Socket Mode `interactive` body. Returns true when this was
+ * an agent-serve approval action (handled or rejected with a reason).
+ */
+export declare function dispatchInteractiveFromPayload(payload: unknown, deps: SlackInteractiveDispatchDeps): Promise<boolean>;
+//# sourceMappingURL=interactive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interactive.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/interactive.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC1C,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAClE,eAAe,EAAE,CACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,WAAW,GAAG,IAAI,KACrB,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9B,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;IAC/C,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,4BAA4B,GACjC,OAAO,CAAC,OAAO,CAAC,CAyFlB"}

package/dist/channels/slack/interactive.js

@@ -0,0 +1,142 @@
+/**
+ * Socket Mode interactive payloads (Block Kit Approve/Deny).
+ */
+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 { decisionFromActionId, parseApprovalActionValue } from "./approvals.js";
+import { buildSlackInteractiveApprovalAuth } from "./auth.js";
+import { defaultSlackLog } from "./log.js";
+/**
+ * Handle a Socket Mode `interactive` body. Returns true when this was
+ * an agent-serve approval action (handled or rejected with a reason).
+ */
+export function dispatchInteractiveFromPayload(payload, deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        var _b, _c, _d, _e;
+        const log = (_b = deps.log) !== null && _b !== void 0 ? _b : defaultSlackLog;
+        const parsed = parseBlockActionsPayload(payload);
+        if (parsed === null) {
+            return false;
+        }
+        const decision = decisionFromActionId(parsed.actionId);
+        const value = parseApprovalActionValue(parsed.value);
+        if (decision === null || value === null) {
+            return false;
+        }
+        log.info("interactive approval", {
+            decision,
+            session: value.sessionId,
+            call_id: value.callId,
+            user: parsed.userId,
+            channel: parsed.channelId,
+        });
+        const session = yield deps.getSession(value.sessionId);
+        if (session === null) {
+            log.warn("interactive approval: unknown session", {
+                session: value.sessionId,
+            });
+            return true;
+        }
+        const attrs = (_c = (_a = session.info.auth) === null || _a === void 0 ? void 0 : _a.attributes) !== null && _c !== void 0 ? _c : {};
+        const sessionChannel = (_d = attrs.channel_id) !== null && _d !== void 0 ? _d : "";
+        const sessionThread = (_e = attrs.thread_ts) !== null && _e !== void 0 ? _e : "";
+        if (sessionChannel !== "" &&
+            parsed.channelId !== "" &&
+            sessionChannel !== parsed.channelId) {
+            log.warn("interactive approval: channel mismatch", {
+                session: value.sessionId,
+                expected: sessionChannel,
+                got: parsed.channelId,
+            });
+            return true;
+        }
+        if (sessionThread !== "" &&
+            parsed.threadTs !== "" &&
+            sessionThread !== parsed.threadTs) {
+            log.warn("interactive approval: thread mismatch", {
+                session: value.sessionId,
+                expected: sessionThread,
+                got: parsed.threadTs,
+            });
+            return true;
+        }
+        const sessionAuth = session.info.auth;
+        if (sessionAuth === undefined || sessionAuth === null) {
+            log.warn("interactive approval: session has no auth", {
+                session: value.sessionId,
+            });
+            return true;
+        }
+        const teamId = attrs.team_id;
+        const clickingAuth = buildSlackInteractiveApprovalAuth(Object.assign(Object.assign({ sessionAuth, channelId: parsed.channelId || sessionChannel, threadTs: parsed.threadTs || sessionThread }, (teamId === undefined || teamId === "" ? {} : { teamId })), { clickingUserId: parsed.userId }));
+        try {
+            yield deps.resolveApproval(value.sessionId, value.callId, decision, clickingAuth);
+        }
+        catch (error) {
+            log.warn("interactive approval resolve failed", {
+                session: value.sessionId,
+                call_id: value.callId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return true;
+    });
+}
+function parseBlockActionsPayload(payload) {
+    if (typeof payload !== "object" || payload === null) {
+        return null;
+    }
+    const record = payload;
+    if (record.type !== "block_actions") {
+        return null;
+    }
+    const actions = record.actions;
+    if (!Array.isArray(actions) || actions.length === 0) {
+        return null;
+    }
+    const first = actions[0];
+    if (typeof first !== "object" || first === null) {
+        return null;
+    }
+    const action = first;
+    if (typeof action.action_id !== "string" ||
+        typeof action.value !== "string") {
+        return null;
+    }
+    const channel = typeof record.channel === "object" && record.channel !== null
+        ? record.channel
+        : {};
+    const message = typeof record.message === "object" && record.message !== null
+        ? record.message
+        : {};
+    const user = typeof record.user === "object" && record.user !== null
+        ? record.user
+        : {};
+    const channelId = typeof channel.id === "string" ? channel.id : "";
+    const messageTs = typeof message.ts === "string" ? message.ts : "";
+    const threadTs = typeof message.thread_ts === "string"
+        ? message.thread_ts
+        : typeof record.container === "object" &&
+            record.container !== null &&
+            typeof record.container.thread_ts ===
+                "string"
+            ? record.container.thread_ts
+            : messageTs;
+    const userId = typeof user.id === "string" ? user.id : "";
+    return {
+        actionId: action.action_id,
+        value: action.value,
+        channelId,
+        threadTs,
+        userId,
+        messageTs,
+    };
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Slack deep links for threads / messages.
+ */
+/** Build a web permalink that opens a Slack thread in the browser. */
+export declare function slackThreadPermalink(args: {
+    channelId: string;
+    threadTs: string;
+    teamId?: string;
+}): string | null;
+//# sourceMappingURL=links.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/links.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,GAAG,IAAI,CAahB"}

package/dist/channels/slack/links.js

@@ -0,0 +1,19 @@
+/**
+ * Slack deep links for threads / messages.
+ */
+/** Build a web permalink that opens a Slack thread in the browser. */
+export function slackThreadPermalink(args) {
+    var _a;
+    const channelId = args.channelId.trim();
+    const threadTs = args.threadTs.trim();
+    if (channelId === "" || threadTs === "") {
+        return null;
+    }
+    const teamId = (_a = args.teamId) === null || _a === void 0 ? void 0 : _a.trim();
+    if (teamId !== undefined && teamId !== "" && teamId !== "unknown") {
+        // Client deep link opens the thread pane in the right workspace.
+        return `https://app.slack.com/client/${encodeURIComponent(teamId)}/${encodeURIComponent(channelId)}/thread/${encodeURIComponent(channelId)}-${encodeURIComponent(threadTs)}`;
+    }
+    const pTs = `p${threadTs.replace(".", "")}`;
+    return `https://app.slack.com/archives/${encodeURIComponent(channelId)}/${pTs}?thread_ts=${encodeURIComponent(threadTs)}`;
+}

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

@@ -0,0 +1,75 @@
+/**
+ * Live-reply delivery for Slack `chat.startStream` / append / stop.
+ *
+ * Cursor-account channels do not use this path — they reply with a single
+ * final `chat.postMessage` and put thinking on `assistant.threads.setStatus`
+ * (no message edits).
+ */
+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 LiveDeliveryDeps {
+    botToken: SlackBotToken | undefined;
+    getLog: () => SlackLog;
+}
+/**
+ * How the default handlers deliver an in-progress reply. Methods write live
+ * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
+ * `streamingUnavailable`) on `channel.state` directly.
+ */
+export interface LiveDeliveryStrategy {
+    /** True when tool-call thinking steps can be appended to the live message. */
+    readonly inlineToolSteps: boolean;
+    /** Open the live message (stream start). */
+    start(args: {
+        channel: SlackChannel;
+        channelId: string;
+        threadTs: string;
+        sessionId: string;
+    }): Promise<void>;
+    /** Push the latest cumulative text to the live message (throttled). */
+    append(args: {
+        channel: SlackChannel;
+        channelId: string;
+        streamTs: string;
+        text: string;
+        sessionId: string;
+    }): Promise<void>;
+    /**
+     * Flush the final reply text. `delivered` is false only when the caller must
+     * post the full reply as a fresh message (finalize failed on partial text).
+     */
+    finalize(args: {
+        channel: SlackChannel;
+        channelId: string;
+        streamTs: string;
+        text: string;
+        sessionId: string;
+    }): Promise<{
+        delivered: boolean;
+    }>;
+    /** Close the live message when the turn produced no final text. */
+    finalizeEmpty(args: {
+        channel: SlackChannel;
+        channelId: string;
+        streamTs: string;
+    }): Promise<void>;
+    /** Best-effort remove a live message left open after the turn ended. */
+    cleanupOrphan(args: {
+        channel: SlackChannel;
+    }): Promise<void>;
+    /** Deliver the error text into the live message; `delivered` gates a fallback post. */
+    fail(args: {
+        channel: SlackChannel;
+        channelId: string;
+        streamTs: string;
+        errorText: string;
+        sessionId: string;
+    }): Promise<{
+        delivered: boolean;
+    }>;
+}
+export declare function createStreamDeliveryStrategy(deps: LiveDeliveryDeps): LiveDeliveryStrategy;
+export {};
+//# sourceMappingURL=live-delivery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"live-delivery.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/live-delivery.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,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;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,4CAA4C;IAC5C,KAAK,CAAC,IAAI,EAAE;QACV,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,uEAAuE;IACvE,MAAM,CAAC,IAAI,EAAE;QACX,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE;QACb,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACpC,mEAAmE;IACnE,aAAa,CAAC,IAAI,EAAE;QAClB,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB,wEAAwE;IACxE,aAAa,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,uFAAuF;IACvF,IAAI,CAAC,IAAI,EAAE;QACT,OAAO,EAAE,YAAY,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrC;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,gBAAgB,GACrB,oBAAoB,CA6HtB"}

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

@@ -0,0 +1,143 @@
+/**
+ * Live-reply delivery for Slack `chat.startStream` / append / stop.
+ *
+ * Cursor-account channels do not use this path — they reply with a single
+ * final `chat.postMessage` and put thinking on `assistant.threads.setStatus`
+ * (no message edits).
+ */
+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, startChatStream, stopChatStream } from "./api.js";
+import { computeStreamAppend } from "./stream.js";
+export function createStreamDeliveryStrategy(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 };
+            });
+        },
+    };
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Shared logging for the Slack channel pack.
+ *
+ * Uses the same `(line: string) => void` contract as ServeOptions.logger.
+ * Lines always start with `[agent-serve/slack]` so Socket Mode docs and greps
+ * keep working. Optional key=value fields carry correlation ids.
+ */
+export type SlackLogWrite = (line: string) => void;
+export type SlackLogLevel = "debug" | "info" | "warn" | "error";
+export type SlackLogFields = Record<string, string | number | boolean | null | undefined>;
+export interface SlackLog {
+    /** Raw sink used by Socket Mode (already-prefixed lines ok). */
+    write: SlackLogWrite;
+    debug: (message: string, fields?: SlackLogFields) => void;
+    info: (message: string, fields?: SlackLogFields) => void;
+    warn: (message: string, fields?: SlackLogFields) => void;
+    error: (message: string, fields?: SlackLogFields) => void;
+}
+/** Format `key=value` pairs; omit null/undefined. */
+export declare function formatSlackLogFields(fields?: SlackLogFields): string;
+export declare function formatSlackLogLine(level: SlackLogLevel, message: string, fields?: SlackLogFields): string;
+export declare function createSlackLogger(write?: SlackLogWrite): SlackLog;
+/** Default logger when none is injected (console). */
+export declare const defaultSlackLog: SlackLog;
+//# sourceMappingURL=log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/log.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAEnD,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEhE,MAAM,MAAM,cAAc,GAAG,MAAM,CACjC,MAAM,EACN,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAC7C,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,gEAAgE;IAChE,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1D,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IACzD,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IACzD,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;CAC3D;AAED,qDAAqD;AACrD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAgBpE;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,CAGR;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,GAAE,aAA2C,GACjD,QAAQ,CAuBV;AAED,sDAAsD;AACtD,eAAO,MAAM,eAAe,EAAE,QAA8B,CAAC"}

package/dist/channels/slack/log.js

@@ -0,0 +1,47 @@
+/**
+ * Shared logging for the Slack channel pack.
+ *
+ * Uses the same `(line: string) => void` contract as ServeOptions.logger.
+ * Lines always start with `[agent-serve/slack]` so Socket Mode docs and greps
+ * keep working. Optional key=value fields carry correlation ids.
+ */
+/** Format `key=value` pairs; omit null/undefined. */
+export function formatSlackLogFields(fields) {
+    if (fields === undefined) {
+        return "";
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        const rendered = typeof value === "string" && /[\s=]/.test(value)
+            ? JSON.stringify(value)
+            : String(value);
+        parts.push(`${key}=${rendered}`);
+    }
+    return parts.length === 0 ? "" : ` ${parts.join(" ")}`;
+}
+export function formatSlackLogLine(level, message, fields) {
+    const levelTag = level === "info" ? "" : `${level} `;
+    return `[agent-serve/slack] ${levelTag}${message}${formatSlackLogFields(fields)}`;
+}
+export function createSlackLogger(write = (line) => console.log(line)) {
+    const emit = (level, message, fields) => {
+        write(formatSlackLogLine(level, message, fields));
+    };
+    return {
+        write(line) {
+            // Preserve Socket Mode messages that already include the prefix.
+            write(line.startsWith("[agent-serve/slack]")
+                ? line
+                : `[agent-serve/slack] ${line}`);
+        },
+        debug: (message, fields) => emit("debug", message, fields),
+        info: (message, fields) => emit("info", message, fields),
+        warn: (message, fields) => emit("warn", message, fields),
+        error: (message, fields) => emit("error", message, fields),
+    };
+}
+/** Default logger when none is injected (console). */
+export const defaultSlackLog = createSlackLogger();