@copilotkit/channels-slack 0.1.0

package/dist/__tests__/auto-close-streaming.test.js

@@ -0,0 +1,139 @@
+import { describe, it, expect } from "vitest";
+import { autoCloseOpenMarkdown } from "../auto-close-streaming.js";
+describe("autoCloseOpenMarkdown", () => {
+    // ── No-op cases ──────────────────────────────────────────────────
+    it("returns empty string unchanged", () => {
+        expect(autoCloseOpenMarkdown("")).toBe("");
+    });
+    it("returns plain text unchanged", () => {
+        expect(autoCloseOpenMarkdown("just plain text 123")).toBe("just plain text 123");
+    });
+    it("does not modify already-balanced markdown", () => {
+        expect(autoCloseOpenMarkdown("**bold** and *italic* and ~~strike~~")).toBe("**bold** and *italic* and ~~strike~~");
+    });
+    // ── Bold ──────────────────────────────────────────────────────────
+    it("closes an unbalanced **opening — `**hello` → `**hello**`", () => {
+        expect(autoCloseOpenMarkdown("**hello")).toBe("**hello**");
+    });
+    it("does NOT close a `**` with nothing after it", () => {
+        // Just opened — closing would render as `****`, which looks worse.
+        expect(autoCloseOpenMarkdown("hi **")).toBe("hi **");
+    });
+    it("closes `__bold` as `__bold__`", () => {
+        expect(autoCloseOpenMarkdown("__bold")).toBe("__bold__");
+    });
+    // ── Italic ───────────────────────────────────────────────────────
+    it("closes `*italic` → `*italic*`", () => {
+        expect(autoCloseOpenMarkdown("*italic")).toBe("*italic*");
+    });
+    it("closes `_italic` → `_italic_`", () => {
+        expect(autoCloseOpenMarkdown("_italic")).toBe("_italic_");
+    });
+    it("does NOT close a `*` with nothing after it", () => {
+        expect(autoCloseOpenMarkdown("text *")).toBe("text *");
+    });
+    // ── Strike ───────────────────────────────────────────────────────
+    it("closes `~~strike` → `~~strike~~`", () => {
+        expect(autoCloseOpenMarkdown("~~strike")).toBe("~~strike~~");
+    });
+    // ── Inline code ──────────────────────────────────────────────────
+    it("closes `` `code `` → `` `code` ``", () => {
+        expect(autoCloseOpenMarkdown("`code")).toBe("`code`");
+    });
+    it("doesn't touch content inside paired inline code", () => {
+        // `code with *stars*` — the stars are inside code, so no italic close.
+        expect(autoCloseOpenMarkdown("`code *stars*` and more")).toBe("`code *stars*` and more");
+    });
+    it("treats unbalanced markers INSIDE inline code as opaque", () => {
+        // `**foo` is inside an unclosed inline → we close the backtick, but
+        // don't try to close the `**` inside code.
+        expect(autoCloseOpenMarkdown("see `**foo")).toBe("see `**foo`");
+    });
+    // ── Fenced code ──────────────────────────────────────────────────
+    it("closes an open fence — adds `\\n```` after the content", () => {
+        const input = "```py\ndef foo():";
+        const out = autoCloseOpenMarkdown(input);
+        expect(out.startsWith(input)).toBe(true);
+        expect(out.trim().endsWith("```")).toBe(true);
+    });
+    it("does NOT close a bare ``` with nothing after it (just opened)", () => {
+        expect(autoCloseOpenMarkdown("```")).toBe("```");
+        expect(autoCloseOpenMarkdown("```py")).toBe("```py"); // language tag alone
+    });
+    it("balanced fences left untouched", () => {
+        const input = "before\n```\ncode\n```\nafter";
+        expect(autoCloseOpenMarkdown(input)).toBe(input);
+    });
+    it("balanced fence + unbalanced markers in surrounding text close correctly", () => {
+        // The fence is paired; the trailing `**hel` outside the fence needs close.
+        const input = "**hel ```code``` more text";
+        const out = autoCloseOpenMarkdown(input);
+        expect(out).toContain("**hel");
+        expect(out).toContain("```code```");
+        expect(out).toContain("**"); // close
+    });
+    it("markers inside paired fences don't count toward balance", () => {
+        // Inside the fence we have `**oops`, but the markdown text is balanced.
+        const input = "```\n**oops never closes\n``` after";
+        expect(autoCloseOpenMarkdown(input)).toBe(input);
+    });
+    // ── Nesting ──────────────────────────────────────────────────────
+    it("closes innermost first — `**bold _italic` → `**bold _italic_**`", () => {
+        expect(autoCloseOpenMarkdown("**bold _italic")).toBe("**bold _italic_**");
+    });
+    it("doesn't double-close already-balanced inner markers", () => {
+        expect(autoCloseOpenMarkdown("**bold _italic_ tail")).toBe("**bold _italic_ tail**");
+    });
+    // ── Stream-evolution: simulate consecutive deltas; the agent's eventual
+    // close should NOT cause double-closes in the produced text. ──
+    it("stream-evolution: agent eventually closes; auto-close adds nothing at that point", () => {
+        const states = [
+            "**h",
+            "**he",
+            "**hel",
+            "**hell",
+            "**hello",
+            "**hello*",
+            "**hello**",
+        ];
+        const out = states.map(autoCloseOpenMarkdown);
+        // Intermediate states are closed
+        expect(out[0]).toBe("**h**");
+        expect(out[4]).toBe("**hello**");
+        // Final state is unchanged (already balanced)
+        expect(out[out.length - 1]).toBe("**hello**");
+    });
+    it("stream-evolution for fenced code: closes mid-stream; goes silent on real close", () => {
+        const states = [
+            "```py\n",
+            "```py\ndef ",
+            "```py\ndef foo():",
+            "```py\ndef foo():\n    pass\n```",
+        ];
+        const out = states.map(autoCloseOpenMarkdown);
+        // First state: just opened — no content yet, don't auto-close
+        expect(out[0]).toBe("```py\n");
+        // Middle states: closed
+        expect(out[1].trim().endsWith("```")).toBe(true);
+        expect(out[2].trim().endsWith("```")).toBe(true);
+        // Final: agent emitted the close, balanced, no change
+        expect(out[3]).toBe(states[3]);
+    });
+    // ── Combined ────────────────────────────────────────────────────
+    it("closes bold before an unclosed fence opener, and closes the fence too", () => {
+        // `**bold ` is open bold then a space; `\`\`\`code\n` opens a fence with
+        // content. We close bold (with closer inserted before the trailing
+        // space, so the space stays adjacent to the fence) and close the fence.
+        const input = "**bold ```py\ndef foo():";
+        const out = autoCloseOpenMarkdown(input);
+        expect(out).toContain("**bold**"); // bold closed before fence
+        expect(out).toContain("def foo():"); // fence content preserved
+        expect(out.trim().endsWith("```")).toBe(true); // fence closed
+    });
+    // ── Sanity: long input ─────────────────────────────────────────
+    it("handles a long buffer with mixed structures", () => {
+        const lots = "**Bold opener** and `code` and *italic* and `unclosed inline";
+        const out = autoCloseOpenMarkdown(lots);
+        expect(out).toBe("**Bold opener** and `code` and *italic* and `unclosed inline`");
+    });
+});

package/dist/__tests__/built-ins.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=built-ins.test.d.ts.map

package/dist/__tests__/built-ins.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"built-ins.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/built-ins.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/built-ins.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi } from "vitest";
+import { lookupSlackUserTool, defaultSlackTools } from "../built-in-tools.js";
+import { defaultSlackContext, slackTaggingContext, slackFormattingContext, slackConversationModelContext, } from "../built-in-context.js";
+/**
+ * Build a minimal handler ctx whose `thread.lookupUser` is the only capability
+ * the lookup tool touches. The fake resolves to whatever `user` we hand it.
+ */
+function makeCtx(user) {
+    const lookupUser = vi.fn(async (_query) => user);
+    const thread = { lookupUser };
+    return {
+        ctx: { thread, platform: "slack" },
+        lookupUser,
+    };
+}
+describe("lookup_slack_user", () => {
+    it("resolves a user via thread.lookupUser and returns a <@USERID> mention", async () => {
+        const { ctx, lookupUser } = makeCtx({
+            id: "U001",
+            name: "Atai Barkai",
+            handle: "atai",
+            email: "atai@copilotkit.ai",
+        });
+        const r = (await lookupSlackUserTool.handler({ query: "atai" }, ctx));
+        expect(lookupUser).toHaveBeenCalledWith("atai");
+        expect(r.found).toBe(true);
+        expect(r.userId).toBe("U001");
+        expect(r.name).toBe("Atai Barkai");
+        expect(r.email).toBe("atai@copilotkit.ai");
+        expect(r.mention).toBe("<@U001>");
+    });
+    it("returns found:false (with the query echoed) when no user resolves", async () => {
+        const { ctx } = makeCtx(undefined);
+        const r = (await lookupSlackUserTool.handler({ query: "Nobody von Nope" }, ctx));
+        expect(r.found).toBe(false);
+        expect(r.query).toBe("Nobody von Nope");
+    });
+    it("returns a raw object (NOT a JSON string) for the run-loop to serialize", async () => {
+        const { ctx } = makeCtx({ id: "U002" });
+        const r = await lookupSlackUserTool.handler({ query: "sarah" }, ctx);
+        expect(typeof r).toBe("object");
+    });
+});
+describe("default consts", () => {
+    it("defaultSlackTools is just the lookup tool", () => {
+        expect(defaultSlackTools.map((t) => t.name)).toEqual(["lookup_slack_user"]);
+    });
+    it("defaultSlackContext is the tagging + formatting + conversation-model entries", () => {
+        expect(defaultSlackContext).toEqual([
+            slackTaggingContext,
+            slackFormattingContext,
+            slackConversationModelContext,
+        ]);
+    });
+    it("tagging entry references the lookup tool by name", () => {
+        expect(slackTaggingContext.value).toContain("lookup_slack_user");
+        expect(slackTaggingContext.value).toContain("<@USERID>");
+    });
+    it("formatting entry talks about Markdown -> mrkdwn", () => {
+        expect(slackFormattingContext.value).toContain("Markdown");
+        expect(slackFormattingContext.value).toContain("mrkdwn");
+    });
+    it("conversation-model entry talks about threads and DMs", () => {
+        expect(slackConversationModelContext.value).toContain("thread");
+        expect(slackConversationModelContext.value.toLowerCase()).toContain("dm");
+    });
+});

package/dist/__tests__/chunked-message-stream.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=chunked-message-stream.test.d.ts.map

package/dist/__tests__/chunked-message-stream.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunked-message-stream.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/chunked-message-stream.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/chunked-message-stream.test.js

@@ -0,0 +1,226 @@
+import { describe, it, expect } from "vitest";
+import { ChunkedMessageStream } from "../chunked-message-stream.js";
+function makeFakeSlack(updateDurationMs = 0) {
+    const posts = [];
+    const updates = [];
+    let counter = 0;
+    return {
+        posts,
+        updates,
+        postPlaceholder: async (text) => {
+            counter++;
+            const ts = `${counter}.0`;
+            posts.push({ ts, text });
+            return ts;
+        },
+        updateAt: async (ts, text) => {
+            if (updateDurationMs > 0)
+                await new Promise((r) => setTimeout(r, updateDurationMs));
+            updates.push({ ts, text });
+        },
+    };
+}
+const longString = (n) => "lorem ipsum ".repeat(Math.ceil(n / 12)).slice(0, n);
+describe("ChunkedMessageStream", () => {
+    it("stays as a single message when buffer fits in one chunk", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 100,
+            minIntervalMs: 0,
+        });
+        s.append("short reply");
+        await s.finish();
+        expect(slack.posts).toHaveLength(1);
+        expect(slack.posts[0].text).toBe("_thinking…_");
+        expect(slack.updates.at(-1)?.text).toBe("short reply");
+    });
+    it("splits into multiple messages when buffer exceeds the limit", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 50,
+            minIntervalMs: 0,
+        });
+        s.append(longString(200));
+        await s.finish();
+        expect(slack.posts.length).toBeGreaterThanOrEqual(4);
+        // First placeholder = thinking, rest = continued
+        expect(slack.posts[0].text).toBe("_thinking…_");
+        expect(slack.posts[1].text).toBe("_…(continued)_");
+    });
+    it("frozen boundaries don't move — already-posted chunks never shrink", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 50,
+            minIntervalMs: 0,
+        });
+        s.append(longString(60));
+        await s.finish();
+        const chunkAfter1 = slack.updates.filter((u) => u.ts === "1.0").at(-1)?.text ?? "";
+        // Now feed a fresh stream the same prefix and see that chunk 1 keeps
+        // the same content even when extra growth happens.
+        const slack2 = makeFakeSlack();
+        const s2 = new ChunkedMessageStream({
+            ...slack2,
+            limit: 50,
+            minIntervalMs: 0,
+        });
+        s2.append(longString(60));
+        // Let the first dispatch settle by yielding briefly.
+        await new Promise((r) => setTimeout(r, 5));
+        s2.append(longString(120));
+        await s2.finish();
+        const chunkAfter1_b = slack2.updates.filter((u) => u.ts === "1.0").at(-1)?.text ?? "";
+        expect(chunkAfter1).toBe(chunkAfter1_b);
+    });
+    it("prefers to break at newlines, then spaces", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 30,
+            minIntervalMs: 0,
+        });
+        s.append("first paragraph here.\nsecond paragraph here.\nthird here.");
+        await s.finish();
+        const chunk1 = slack.updates.filter((u) => u.ts === "1.0").at(-1)?.text ?? "";
+        // Should not contain a partial word — last char should be a space or newline boundary.
+        expect(chunk1.endsWith("\n") || chunk1.endsWith(" ") || /\.[\s]?$/.test(chunk1)).toBe(true);
+    });
+    it("concatenated chunks equal the full buffer (no characters lost)", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 40,
+            minIntervalMs: 0,
+        });
+        const full = longString(300);
+        s.append(full);
+        await s.finish();
+        // Take the last update per ts in posted order
+        const final = {};
+        for (const u of slack.updates)
+            final[u.ts] = u.text;
+        const concatenated = Object.entries(final)
+            .sort(([a], [b]) => Number(a) - Number(b))
+            .map(([, v]) => v)
+            .join("");
+        expect(concatenated).toBe(full);
+    });
+    it("applies the transform per chunk before chat.update", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 100,
+            minIntervalMs: 0,
+            transform: (t) => t.toUpperCase(),
+        });
+        s.append("hello world");
+        await s.finish();
+        expect(slack.updates.at(-1)?.text).toBe("HELLO WORLD");
+    });
+    it("block-keeps-whole: a fenced block that fits in a new chunk goes whole into the next message", async () => {
+        // 200 chars of prose + a 60-char fenced block. With limit=120, the
+        // ideal boundary would land inside the fence. The block-keeps-whole
+        // logic should pull the boundary back to BEFORE the fence so chunk 2
+        // contains the entire fence cleanly.
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 120,
+            minIntervalMs: 0,
+        });
+        // Prose just under the limit, so we end up with exactly two chunks.
+        const prose = "lorem ipsum dolor sit amet ".repeat(4); // 108 chars
+        const block = "```python\nprint('hi')\nprint('bye')\n```";
+        const fullText = prose + block;
+        s.append(fullText);
+        await s.finish();
+        expect(slack.posts.length).toBeGreaterThanOrEqual(2);
+        // Find the FINAL state of each chunk message
+        const finals = {};
+        for (const u of slack.updates)
+            finals[u.ts] = u.text;
+        const chunk1 = finals["1.0"] ?? "";
+        const chunk2 = finals["2.0"] ?? "";
+        // Chunk 1 must not contain the fence at all — the block moved to chunk 2.
+        expect(chunk1.includes("```")).toBe(false);
+        // Chunk 2 must contain the whole block.
+        expect(chunk2.includes("```python")).toBe(true);
+        expect(chunk2.trim().endsWith("```")).toBe(true);
+        expect(chunk2.includes("print('hi')")).toBe(true);
+        expect(chunk2.includes("print('bye')")).toBe(true);
+    });
+    it("fallback: a block too big to fit in one chunk uses the re-opener path", async () => {
+        // Make a block bigger than the limit so the boundary can't move
+        // back without leaving chunk N empty. Re-opener prefix is used instead.
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 80,
+            minIntervalMs: 0,
+        });
+        const code = "x = 1\n".repeat(40); // ~240 chars of code
+        const fullText = "preamble. ```python\n" + code + "```";
+        s.append(fullText);
+        await s.finish();
+        expect(slack.posts.length).toBeGreaterThanOrEqual(2);
+        const finals = {};
+        for (const u of slack.updates)
+            finals[u.ts] = u.text;
+        const chunk2 = finals["2.0"] ?? "";
+        // Chunk 2 must begin with a fence opener (re-opener path).
+        expect(chunk2.startsWith("```python\n")).toBe(true);
+    });
+    it("continuation chunk re-opens a fence when the boundary is inside ```python", async () => {
+        // Reproduces the user-reported python decorators bug: a long fenced
+        // code block split across two Slack messages → chunk 2 must start
+        // with the fence opener (and the chunk 1 will close with ``` thanks
+        // to autoCloseOpenMarkdown applied via the transform).
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 80,
+            minIntervalMs: 0,
+        });
+        // Synthesise enough code in one fence to overflow the limit.
+        const longCode = Array.from({ length: 12 }, (_, i) => `print(${i})`).join("\n");
+        const fullText = "```python\n" + longCode + "\n```";
+        s.append(fullText);
+        await s.finish();
+        expect(slack.posts.length).toBeGreaterThan(1); // multiple messages
+        // The text of each subsequent message (after applying our manual mrkdwn-free transform here)
+        // is checked via slack.updates. Examine the SECOND chunk's last text:
+        const lastForSecondTs = [...slack.updates]
+            .reverse()
+            .find((u) => u.ts === "2.0");
+        expect(lastForSecondTs?.text.startsWith("```python\n")).toBe(true);
+    });
+    it("continuation chunk re-opens a fence without language when none was specified", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 60,
+            minIntervalMs: 0,
+        });
+        const fullText = "```\n" + "abcdefghij\n".repeat(10) + "```";
+        s.append(fullText);
+        await s.finish();
+        expect(slack.posts.length).toBeGreaterThan(1);
+        const second = [...slack.updates].reverse().find((u) => u.ts === "2.0");
+        expect(second?.text.startsWith("```\n")).toBe(true);
+    });
+    it("finish() is idempotent and safe to call without any appends", async () => {
+        const slack = makeFakeSlack();
+        const s = new ChunkedMessageStream({
+            ...slack,
+            limit: 100,
+            minIntervalMs: 0,
+        });
+        await s.finish();
+        await s.finish();
+        expect(slack.posts).toHaveLength(0);
+        expect(slack.updates).toHaveLength(0);
+    });
+});

package/dist/__tests__/conversation-store.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=conversation-store.test.d.ts.map

package/dist/__tests__/conversation-store.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-store.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/conversation-store.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/conversation-store.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect, vi } from "vitest";
+import { SlackConversationStore } from "../conversation-store.js";
+import { DM_SCOPE } from "../types.js";
+const BOT = "UBOT0001";
+const ATAI = "UATAI001";
+function makeFakeClient(opts) {
+    const client = {
+        conversations: {
+            replies: vi.fn(async (_args) => {
+                if (opts.throwOnReplies)
+                    throw new Error("api down");
+                return { ok: true, messages: opts.replies ?? [] };
+            }),
+            history: vi.fn(async (_args) => ({
+                ok: true,
+                messages: opts.history ?? [],
+            })),
+        },
+    };
+    return client;
+}
+function makeAgent() {
+    return {
+        messages: [],
+        threadId: "",
+    };
+}
+describe("SlackConversationStore", () => {
+    it("mints a unique threadId per turn under a stable conversation prefix", async () => {
+        const client = makeFakeClient({ replies: [] });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        const s1 = await store.getOrCreate({ channelId: "C1", scope: "100.0" }, { channel: "C1", threadTs: "100.0" }, () => makeAgent());
+        const s2 = await store.getOrCreate({ channelId: "C1", scope: "100.0" }, { channel: "C1", threadTs: "100.0" }, () => makeAgent());
+        // Threads are unique per turn so the server-side LangGraph thread never
+        // accumulates internal messages across turns (the "Message not found"
+        // balloon). Slack is the durable history; each turn rebuilds from it.
+        expect(s1.threadId).not.toBe(s2.threadId);
+        // …but both carry the stable conversation prefix so the turn's origin
+        // stays identifiable (and recovery can fall back to it).
+        expect(s1.threadId).toMatch(/^slack-C1-100\.0-/);
+        expect(s2.threadId).toMatch(/^slack-C1-100\.0-/);
+    });
+    it("populates agent.messages from the thread history fetched via Slack", async () => {
+        const client = makeFakeClient({
+            replies: [
+                { ts: "100.0", user: ATAI, text: `<@${BOT}> hello` },
+                { ts: "100.5", user: BOT, text: "Hi back!" },
+                { ts: "101.0", user: ATAI, text: "follow-up" },
+            ],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        const s = await store.getOrCreate({ channelId: "C1", scope: "100.0" }, { channel: "C1", threadTs: "100.0" }, () => makeAgent());
+        const msgs = s.agent.messages;
+        expect(msgs.map((m) => ({ r: m.role, c: m.content }))).toEqual([
+            { r: "user", c: "hello" }, // bot mention stripped
+            { r: "assistant", c: "Hi back!" },
+            { r: "user", c: "follow-up" },
+        ]);
+    });
+    it("folds consecutive bot messages into one assistant turn (chunked replies)", async () => {
+        const client = makeFakeClient({
+            replies: [
+                { ts: "100.0", user: ATAI, text: `<@${BOT}> long question` },
+                { ts: "100.5", user: BOT, text: "First chunk of the answer." },
+                { ts: "100.6", user: BOT, text: "Second chunk." },
+                { ts: "100.7", user: BOT, text: "Third and final chunk." },
+            ],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        const s = await store.getOrCreate({ channelId: "C1", scope: "100.0" }, { channel: "C1", threadTs: "100.0" }, () => makeAgent());
+        const msgs = s.agent.messages;
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].role).toBe("assistant");
+        expect(msgs[1].content).toContain("First chunk");
+        expect(msgs[1].content).toContain("Second chunk.");
+        expect(msgs[1].content).toContain("Third and final chunk.");
+    });
+    it("skips status messages and the thinking placeholder", async () => {
+        const client = makeFakeClient({
+            replies: [
+                { ts: "100.0", user: ATAI, text: `<@${BOT}> please search` },
+                { ts: "100.5", user: BOT, text: "_thinking…_" },
+                { ts: "100.6", user: BOT, text: ":wrench: Calling `search`…" },
+                { ts: "100.7", user: BOT, text: ":white_check_mark: `search`" },
+                { ts: "100.8", user: BOT, text: "Here are the results." },
+            ],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        const s = await store.getOrCreate({ channelId: "C1", scope: "100.0" }, { channel: "C1", threadTs: "100.0" }, () => makeAgent());
+        const msgs = s.agent.messages;
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].content).toBe("Here are the results.");
+    });
+    it("ignores subtyped messages (edits, joins, etc.)", async () => {
+        const client = makeFakeClient({
+            replies: [
+                { ts: "100.0", user: ATAI, text: "<@" + BOT + "> hi" },
+                { ts: "100.1", subtype: "channel_join", text: "joined" },
+                { ts: "100.2", subtype: "message_changed", user: ATAI, text: "edited" },
+            ],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        const s = await store.getOrCreate({ channelId: "C1", scope: "100.0" }, { channel: "C1", threadTs: "100.0" }, () => makeAgent());
+        const msgs = s.agent.messages;
+        expect(msgs).toHaveLength(1);
+    });
+    it("DM scope uses conversations.history (chronological after reverse) instead of replies", async () => {
+        // Slack returns history newest-first; the store reverses it.
+        const client = makeFakeClient({
+            history: [
+                { ts: "200.0", user: ATAI, text: "third" },
+                { ts: "100.0", user: BOT, text: "second" },
+                { ts: "50.0", user: ATAI, text: "first" },
+            ],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        const s = await store.getOrCreate({ channelId: "D1", scope: DM_SCOPE }, { channel: "D1" }, () => makeAgent());
+        const msgs = s.agent.messages;
+        expect(msgs.map((m) => m.content)).toEqual(["first", "second", "third"]);
+    });
+    it("has() returns true after the bot has replied; uses Slack lookup on cache miss", async () => {
+        const client = makeFakeClient({
+            replies: [
+                { ts: "100.0", user: ATAI, text: "<@" + BOT + "> hi" },
+                { ts: "100.5", user: BOT, text: "Hello!" },
+            ],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        // Fresh store, no in-process cache — must hit Slack to discover ownership.
+        expect(await store.has({ channelId: "C1", scope: "100.0" })).toBe(true);
+        // Second call should be cached (no extra Slack call).
+        expect(await store.has({ channelId: "C1", scope: "100.0" })).toBe(true);
+        expect(client.conversations.replies.mock.calls
+            .length).toBe(1);
+    });
+    it("has() returns false for threads we've never replied in", async () => {
+        const client = makeFakeClient({
+            replies: [{ ts: "100.0", user: ATAI, text: "hey everyone" }],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        expect(await store.has({ channelId: "C1", scope: "100.0" })).toBe(false);
+    });
+    it("has() returns false gracefully when Slack API fails", async () => {
+        const client = makeFakeClient({ throwOnReplies: true });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        expect(await store.has({ channelId: "C1", scope: "100.0" })).toBe(false);
+    });
+    it("getOrCreate marks the conversation as owned even when Slack history doesn't yet include the bot's reply", async () => {
+        // After an @mention, the bot will reply within seconds. A follow-up
+        // arriving before the bot's reply lands shouldn't be silently dropped.
+        const client = makeFakeClient({
+            replies: [{ ts: "100.0", user: ATAI, text: "<@" + BOT + "> hi" }],
+        });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        await store.getOrCreate({ channelId: "C1", scope: "100.0" }, { channel: "C1", threadTs: "100.0" }, () => makeAgent());
+        // Now has() should be true even though the bot hasn't replied to Slack
+        // yet — getOrCreate eagerly marked it.
+        expect(await store.has({ channelId: "C1", scope: "100.0" })).toBe(true);
+    });
+    it("save() is a no-op (Slack is the source of truth)", () => {
+        const client = makeFakeClient({ replies: [] });
+        const store = new SlackConversationStore({
+            client: client,
+            botUserId: BOT,
+            botToken: "xoxb-test",
+        });
+        expect(() => store.save({ channelId: "C1", scope: "100.0" }, {})).not.toThrow();
+    });
+});

package/dist/__tests__/download-files.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=download-files.test.d.ts.map