@copilotkit/channels 0.1.0

package/dist/testing/fake-adapter.js

@@ -0,0 +1,273 @@
+/** A RunRenderer whose subscriber captures tool-call-end and custom (interrupt) events — used by run-loop tests. */
+export function makeFakeRunRenderer() {
+    const toolCalls = [];
+    let pending;
+    const subscriber = {
+        onToolCallEndEvent(p) {
+            toolCalls.push({
+                toolCallId: p.event.toolCallId,
+                toolCallName: p.toolCallName,
+                toolCallArgs: (p.toolCallArgs ?? {}),
+            });
+        },
+        onCustomEvent(p) {
+            const e = p.event;
+            if (e.name)
+                pending = { eventName: e.name, value: e.value };
+        },
+    };
+    let finishCalls = 0;
+    return {
+        subscriber,
+        async markInterrupted() { },
+        getCapturedToolCalls: () => toolCalls,
+        getPendingInterrupt: () => pending,
+        clearPendingInterrupt: () => {
+            pending = undefined;
+        },
+        async finish() {
+            finishCalls++;
+        },
+        get finishCalls() {
+            return finishCalls;
+        },
+    };
+}
+export class FakeAdapter {
+    platform = "fake";
+    capabilities;
+    ackDeadlineMs = 3000;
+    /** When true, `start()` rejects (set via constructor `failStart`). */
+    failStart;
+    /** When true, `registerCommands()` rejects (set via constructor `failRegisterCommands`). */
+    failRegisterCommands;
+    /** When true, `stop()` rejects (set via constructor `failStop`). */
+    failStop;
+    /** Set once `start()` has run to completion; lets tests assert a healthy adapter still started. */
+    started = false;
+    /**
+     * @param fakeOpts.paneMethods When `false`, the optional
+     *   `setSuggestedPrompts`/`setThreadTitle` methods are omitted (and the
+     *   matching capability flags cleared) so tests can exercise the
+     *   capability-gated `{ ok: false }` path. Defaults to present.
+     * @param fakeOpts.reactions When `false`, `addReaction`/`removeReaction` are
+     *   omitted and `supportsReactions` is cleared. Defaults to present.
+     * @param fakeOpts.nativeEphemeral When `true`, `postEphemeral` reports a
+     *   native success (`usedFallback: false`) and `supportsEphemeral` is set;
+     *   otherwise DM-fallback / `null` semantics apply and `supportsEphemeral`
+     *   is `false`.
+     * @param fakeOpts.modals When `false`, `renderModal`/`openModal` are omitted
+     *   and `supportsModals` is `false`. Defaults to present.
+     */
+    constructor(fakeOpts = {}) {
+        if (fakeOpts.platform)
+            this.platform = fakeOpts.platform;
+        this.failStart = fakeOpts.failStart === true;
+        this.failRegisterCommands = fakeOpts.failRegisterCommands === true;
+        this.failStop = fakeOpts.failStop === true;
+        const paneMethods = fakeOpts.paneMethods !== false;
+        this.capabilities = {
+            supportsModals: fakeOpts.modals !== false,
+            supportsTyping: false,
+            supportsReactions: fakeOpts.reactions !== false,
+            supportsStreaming: true,
+            supportsSuggestedPrompts: paneMethods,
+            supportsThreadTitle: paneMethods,
+            supportsEphemeral: fakeOpts.nativeEphemeral === true,
+        };
+        if (paneMethods) {
+            this.setSuggestedPrompts = async (target, prompts, opts) => {
+                this.suggestedPromptsCalls.push({ target, prompts, opts });
+                return { ok: true };
+            };
+            this.setThreadTitle = async (target, title) => {
+                this.threadTitleCalls.push({ target, title });
+                return { ok: true };
+            };
+        }
+        if (fakeOpts.reactions !== false) {
+            this.addReaction = async (_t, ref, e) => {
+                this.reactionsAdded.push({ ref, emoji: e });
+                return { ok: true };
+            };
+            this.removeReaction = async (_t, ref, e) => {
+                this.reactionsRemoved.push({ ref, emoji: e });
+                return { ok: true };
+            };
+        }
+        // Native ephemeral when nativeEphemeral === true; otherwise DM-fallback semantics.
+        this.postEphemeral = async (_t, user, ir, opts) => {
+            this.ephemeralPosts.push({ user, ir, opts });
+            if (this.capabilities.supportsEphemeral) {
+                return {
+                    ok: true,
+                    usedFallback: false,
+                    ref: { id: `eph-${++this.counter}` },
+                };
+            }
+            if (opts.fallbackToDM) {
+                return {
+                    ok: true,
+                    usedFallback: true,
+                    ref: { id: `dm-${++this.counter}` },
+                };
+            }
+            return null;
+        };
+        if (fakeOpts.modals !== false) {
+            this.renderModal = (ir) => ir;
+            this.openModal = async (_t, triggerId, ir) => {
+                this.openedModals.push({ triggerId, ir });
+                return { ok: true };
+            };
+        }
+    }
+    conversationStore = {
+        async getOrCreate(conversationKey, _replyTarget, makeAgent) {
+            return { agent: makeAgent(conversationKey) };
+        },
+    };
+    posted = [];
+    updated = [];
+    interactionsSeen = [];
+    lastRunRenderer;
+    /** History returned by getMessages(); override in tests. */
+    messages = [];
+    /** User returned by lookupUser(); override in tests. */
+    user;
+    /** Optional persistence backend the adapter provides (test-only); exercises createBot's store resolution. */
+    stateStore;
+    sink;
+    counter = 0;
+    /** Expose the registered sink so tests can invoke onTurn() directly for overlap/lock tests. */
+    getSink() {
+        if (!this.sink)
+            throw new Error("FakeAdapter: sink not set — call bot.start() first");
+        return this.sink;
+    }
+    async start(sink) {
+        if (this.failStart)
+            throw new Error("fake-adapter: start failed");
+        this.sink = sink;
+        this.started = true;
+    }
+    async stop() {
+        if (this.failStop)
+            throw new Error("fake-adapter: stop failed");
+    }
+    render(ir) {
+        return ir;
+    }
+    async post(_target, ir) {
+        this.posted.push(ir);
+        return { id: `msg-${++this.counter}` };
+    }
+    async update(ref, ir) {
+        this.updated.push({ ref, ir });
+    }
+    async stream(_target, chunks) {
+        let s = "";
+        for await (const c of chunks)
+            s += c;
+        this.posted.push([{ type: "text", props: { value: s } }]);
+        return { id: `msg-${++this.counter}` };
+    }
+    async delete(_ref) { }
+    createRunRenderer(_target) {
+        const r = makeFakeRunRenderer();
+        this.lastRunRenderer = r;
+        return r;
+    }
+    decodeInteraction(raw) {
+        return raw;
+    }
+    async lookupUser(_q) {
+        return this.user;
+    }
+    async getMessages(_target) {
+        return this.messages;
+    }
+    /** Suggested-prompt calls recorded by the capability-gated method (when present). */
+    suggestedPromptsCalls = [];
+    setSuggestedPrompts;
+    /** Thread-title calls recorded by the capability-gated method (when present). */
+    threadTitleCalls = [];
+    setThreadTitle;
+    // --- reactions ---
+    reactionsAdded = [];
+    reactionsRemoved = [];
+    addReaction;
+    removeReaction;
+    // --- ephemeral ---
+    ephemeralPosts = [];
+    postEphemeral;
+    // --- modals ---
+    openedModals = [];
+    renderModal;
+    openModal;
+    // --- test helpers ---
+    emitTurn(partial) {
+        void this.sink?.onTurn({
+            conversationKey: "c",
+            replyTarget: {},
+            userText: "",
+            platform: "fake",
+            ...partial,
+        });
+    }
+    emitThreadStarted(partial) {
+        return this.sink?.onThreadStarted({
+            conversationKey: "c",
+            replyTarget: {},
+            platform: "fake",
+            ...partial,
+        });
+    }
+    emitInteraction(partial) {
+        const evt = {
+            id: "",
+            conversationKey: "c",
+            replyTarget: {},
+            ...partial,
+        };
+        this.interactionsSeen.push(evt);
+        void this.sink?.onInteraction(evt);
+    }
+    emitCommand(partial) {
+        return this.sink?.onCommand({
+            text: "",
+            conversationKey: "c",
+            replyTarget: {},
+            platform: "fake",
+            ...partial,
+        });
+    }
+    emitReaction(partial) {
+        return this.sink?.onReaction({
+            added: true,
+            conversationKey: "c",
+            replyTarget: {},
+            messageId: "m1",
+            raw: {},
+            ...partial,
+        });
+    }
+    emitModalSubmit(partial) {
+        return this.sink?.onModalSubmit({
+            values: {},
+            platform: "fake",
+            raw: {},
+            ...partial,
+        });
+    }
+    emitModalClose(partial) {
+        return this.sink?.onModalClose({ platform: "fake", raw: {}, ...partial });
+    }
+    /** Commands handed to the adapter via `registerCommands`; asserts the capability hook fires. */
+    registeredCommands;
+    async registerCommands(commands) {
+        if (this.failRegisterCommands)
+            throw new Error("fake-adapter: registerCommands failed");
+        this.registeredCommands = commands;
+    }
+}

package/dist/testing/fake-agent.d.ts

@@ -0,0 +1,28 @@
+import { AbstractAgent } from "@ag-ui/client";
+import type { AgentSubscriber, RunAgentParameters, RunAgentResult } from "@ag-ui/client";
+import type { RunAgentInput } from "@ag-ui/core";
+/**
+ * One scripted `runAgent` invocation. Each step receives the subscriber the
+ * run-loop passed into `runAgent` and simulates the agent's behaviour by
+ * calling the subscriber's callbacks (e.g. `onToolCallEndEvent`,
+ * `onCustomEvent`, `onRunFinishedEvent`).
+ */
+export type FakeAgentScriptStep = (subscriber: AgentSubscriber) => void | Promise<void>;
+/**
+ * A scriptable fake `AbstractAgent` for exercising the run/tool/interrupt
+ * loop without a real backend. The constructor (or `setScript`) supplies an
+ * ordered list of steps; each `runAgent` call shifts and runs the next step.
+ */
+export declare class FakeAgent extends AbstractAgent {
+    private script;
+    /** Number of `runAgent` invocations seen — handy for loop-termination asserts. */
+    runAgentCalls: number;
+    /** Flipped to true by `abortRun()`. */
+    aborted: boolean;
+    constructor(script?: FakeAgentScriptStep[]);
+    setScript(script: FakeAgentScriptStep[]): void;
+    run(_input: RunAgentInput): ReturnType<AbstractAgent["run"]>;
+    runAgent(_parameters?: RunAgentParameters, subscriber?: AgentSubscriber): Promise<RunAgentResult>;
+    abortRun(): void;
+}
+//# sourceMappingURL=fake-agent.d.ts.map

package/dist/testing/fake-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-agent.d.ts","sourceRoot":"","sources":["../../src/testing/fake-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAChC,UAAU,EAAE,eAAe,KACxB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,aAAa;IAC1C,OAAO,CAAC,MAAM,CAAwB;IACtC,kFAAkF;IAClF,aAAa,SAAK;IAClB,uCAAuC;IACvC,OAAO,UAAS;gBAEJ,MAAM,GAAE,mBAAmB,EAAO;IAK9C,SAAS,CAAC,MAAM,EAAE,mBAAmB,EAAE,GAAG,IAAI;IAM9C,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAI7C,QAAQ,CACrB,WAAW,CAAC,EAAE,kBAAkB,EAChC,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,cAAc,CAAC;IASjB,QAAQ,IAAI,IAAI;CAG1B"}

package/dist/testing/fake-agent.js

@@ -0,0 +1,36 @@
+import { AbstractAgent } from "@ag-ui/client";
+/**
+ * A scriptable fake `AbstractAgent` for exercising the run/tool/interrupt
+ * loop without a real backend. The constructor (or `setScript`) supplies an
+ * ordered list of steps; each `runAgent` call shifts and runs the next step.
+ */
+export class FakeAgent extends AbstractAgent {
+    script;
+    /** Number of `runAgent` invocations seen — handy for loop-termination asserts. */
+    runAgentCalls = 0;
+    /** Flipped to true by `abortRun()`. */
+    aborted = false;
+    constructor(script = []) {
+        super({ agentId: "fake" });
+        this.script = [...script];
+    }
+    setScript(script) {
+        this.script = [...script];
+    }
+    // The base class declares `run` abstract. It's never invoked here because
+    // `runAgent` is overridden to drive the script directly (no rxjs stream).
+    run(_input) {
+        throw new Error("FakeAgent.run unused; runAgent is overridden");
+    }
+    async runAgent(_parameters, subscriber) {
+        this.runAgentCalls += 1;
+        const step = this.script.shift();
+        if (step && subscriber) {
+            await step(subscriber);
+        }
+        return { result: undefined, newMessages: [] };
+    }
+    abortRun() {
+        this.aborted = true;
+    }
+}

package/dist/testing/state-store-conformance.d.ts

@@ -0,0 +1,4 @@
+import type { StateStore } from "../state/state-store.js";
+/** Registers the full StateStore contract as Vitest tests against a backend. */
+export declare function runStateStoreConformance(name: string, make: () => StateStore | Promise<StateStore>, teardown?: (s: StateStore) => Promise<void>): void;
+//# sourceMappingURL=state-store-conformance.d.ts.map

package/dist/testing/state-store-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-store-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/state-store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,gFAAgF;AAChF,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,EAC5C,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAC1C,IAAI,CAwHN"}

package/dist/testing/state-store-conformance.js

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+/** Registers the full StateStore contract as Vitest tests against a backend. */
+export function runStateStoreConformance(name, make, teardown) {
+    describe(`StateStore conformance: ${name}`, () => {
+        let s;
+        beforeEach(async () => {
+            s = await make();
+        });
+        afterEach(async () => {
+            await teardown?.(s);
+        });
+        describe("kv", () => {
+            it("set/get/delete round-trips", async () => {
+                await s.kv.set("a", { n: 1 });
+                expect(await s.kv.get("a")).toEqual({ n: 1 });
+                await s.kv.delete("a");
+                expect(await s.kv.get("a")).toBeUndefined();
+            });
+            it("missing key is undefined", async () => expect(await s.kv.get("nope")).toBeUndefined());
+            it("expires after ttl", async () => {
+                await s.kv.set("t", 1, 30);
+                await new Promise((r) => setTimeout(r, 60));
+                expect(await s.kv.get("t")).toBeUndefined();
+            });
+        });
+        describe("list", () => {
+            it("appends oldest-first and ranges", async () => {
+                await s.list.append("L", "a");
+                await s.list.append("L", "b");
+                await s.list.append("L", "c");
+                expect(await s.list.range("L")).toEqual(["a", "b", "c"]);
+                expect(await s.list.range("L", 0, 1)).toEqual(["a", "b"]);
+            });
+            it("caps with maxLen on append (drops oldest)", async () => {
+                for (const v of ["a", "b", "c", "d"])
+                    await s.list.append("C", v, { maxLen: 2 });
+                expect(await s.list.range("C")).toEqual(["c", "d"]);
+            });
+            it("trim keeps newest maxLen", async () => {
+                for (const v of ["a", "b", "c"])
+                    await s.list.append("T", v);
+                await s.list.trim("T", 2);
+                expect(await s.list.range("T")).toEqual(["b", "c"]);
+            });
+            it("delete clears", async () => {
+                await s.list.append("D", "x");
+                await s.list.delete("D");
+                expect(await s.list.range("D")).toEqual([]);
+            });
+            it("mixed ttl/non-ttl append keeps whole-list expiry", async () => {
+                await s.list.append("M", "a", { ttlMs: 1000 });
+                await s.list.append("M", "b"); // no ttlMs: must not clobber the existing expiry
+                await new Promise((r) => setTimeout(r, 40));
+                expect((await s.list.range("M")).length).toBe(2);
+            });
+        });
+        describe("lock", () => {
+            it("acquire blocks a second acquire until release", async () => {
+                const a = await s.lock.acquire("k");
+                expect(a).not.toBeNull();
+                expect(await s.lock.acquire("k")).toBeNull();
+                await s.lock.release("k", a.token);
+                const b = await s.lock.acquire("k");
+                expect(b).not.toBeNull();
+            });
+            it("release with a stale token does not free a re-acquired lock", async () => {
+                const a = await s.lock.acquire("k", { ttlMs: 20 });
+                await new Promise((r) => setTimeout(r, 40)); // a expires
+                const b = await s.lock.acquire("k");
+                expect(b).not.toBeNull();
+                await s.lock.release("k", a.token); // stale — must NOT release b
+                expect(await s.lock.acquire("k")).toBeNull();
+                await s.lock.release("k", b.token);
+            });
+        });
+        describe("dedup", () => {
+            it("first seen false, second true, within ttl", async () => {
+                expect(await s.dedup.seen("e1", 1000)).toBe(false);
+                expect(await s.dedup.seen("e1", 1000)).toBe(true);
+            });
+            it("forgets after ttl", async () => {
+                expect(await s.dedup.seen("e2", 30)).toBe(false);
+                await new Promise((r) => setTimeout(r, 60));
+                expect(await s.dedup.seen("e2", 30)).toBe(false);
+            });
+        });
+        describe("queue", () => {
+            it("FIFO enqueue/dequeue/depth", async () => {
+                await s.queue.enqueue("q", 1);
+                await s.queue.enqueue("q", 2);
+                expect(await s.queue.depth("q")).toBe(2);
+                expect(await s.queue.dequeue("q")).toBe(1);
+                expect(await s.queue.dequeue("q")).toBe(2);
+                expect(await s.queue.dequeue("q")).toBeUndefined();
+            });
+            it("maxSize + drop-oldest evicts the head", async () => {
+                for (const v of [1, 2, 3])
+                    await s.queue.enqueue("q2", v, { maxSize: 2, onFull: "drop-oldest" });
+                expect(await s.queue.dequeue("q2")).toBe(2);
+                expect(await s.queue.dequeue("q2")).toBe(3);
+            });
+            it("maxSize + drop-newest rejects the incoming", async () => {
+                for (const v of [1, 2, 3])
+                    await s.queue.enqueue("q3", v, { maxSize: 2, onFull: "drop-newest" });
+                expect(await s.queue.dequeue("q3")).toBe(1);
+                expect(await s.queue.dequeue("q3")).toBe(2);
+            });
+        });
+        it("kv and lock keyspaces do not collide", async () => {
+            await s.kv.set("x", { v: 1 });
+            const a = await s.lock.acquire("x");
+            expect(a).not.toBeNull();
+            expect(await s.kv.get("x")).toEqual({ v: 1 });
+            await s.lock.release("x", a.token);
+        });
+    });
+}

package/dist/thread-capabilities.test.d.ts

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

package/dist/thread-capabilities.test.d.ts.map

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

package/dist/thread-capabilities.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { createBot } from "./create-bot.js";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+describe("onThreadStarted routing", () => {
+    it("invokes registered handlers with the thread and user", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        const seen = [];
+        bot.onThreadStarted(({ thread, user }) => {
+            seen.push({ user: user?.id, platform: thread.platform });
+        });
+        await bot.start();
+        await fake.emitThreadStarted({ user: { id: "U1", name: "Ada" } });
+        expect(seen).toEqual([{ user: "U1", platform: "fake" }]);
+    });
+    it("invokes every registered handler in order", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        const order = [];
+        bot.onThreadStarted(() => {
+            order.push(1);
+        });
+        bot.onThreadStarted(() => {
+            order.push(2);
+        });
+        await bot.start();
+        await fake.emitThreadStarted();
+        expect(order).toEqual([1, 2]);
+    });
+    it("is a no-op when no handler is registered", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        await bot.start();
+        // Should not throw.
+        await expect(Promise.resolve(fake.emitThreadStarted())).resolves.toBeUndefined();
+    });
+});
+describe("Thread.setSuggestedPrompts / setTitle capability gating", () => {
+    it("delegates to the adapter when supported", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        const results = [];
+        bot.onThreadStarted(async ({ thread }) => {
+            results.push(await thread.setSuggestedPrompts([{ title: "Triage", message: "Triage my issues" }], { title: "Try" }));
+            results.push(await thread.setTitle("My conversation"));
+        });
+        await bot.start();
+        await fake.emitThreadStarted({ replyTarget: { channel: "D1" } });
+        expect(results).toEqual([{ ok: true }, { ok: true }]);
+        expect(fake.suggestedPromptsCalls).toHaveLength(1);
+        expect(fake.suggestedPromptsCalls[0]).toMatchObject({
+            target: { channel: "D1" },
+            prompts: [{ title: "Triage", message: "Triage my issues" }],
+            opts: { title: "Try" },
+        });
+        expect(fake.threadTitleCalls).toEqual([
+            { target: { channel: "D1" }, title: "My conversation" },
+        ]);
+    });
+    it("returns { ok: false } without throwing when unsupported", async () => {
+        const fake = new FakeAdapter({ paneMethods: false });
+        const bot = createBot({ adapters: [fake] });
+        const results = [];
+        bot.onThreadStarted(async ({ thread }) => {
+            results.push(await thread.setSuggestedPrompts([]));
+            results.push(await thread.setTitle("nope"));
+        });
+        await bot.start();
+        await fake.emitThreadStarted();
+        expect(results[0].ok).toBe(false);
+        expect(results[0].error).toMatch(/does not support suggested prompts/);
+        expect(results[1].ok).toBe(false);
+        expect(results[1].error).toMatch(/does not support thread titles/);
+        expect(fake.suggestedPromptsCalls).toHaveLength(0);
+        expect(fake.threadTitleCalls).toHaveLength(0);
+    });
+});

package/dist/thread-ephemeral.test.d.ts

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

package/dist/thread-ephemeral.test.d.ts.map

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

package/dist/thread-ephemeral.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { createBot } from "./create-bot.js";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+async function runOnMessage(fake, fn) {
+    const bot = createBot({ adapters: [fake] });
+    bot.onMessage(fn);
+    await bot.start();
+    fake.emitTurn({ userText: "hi", user: { id: "U1" } });
+    await new Promise((r) => setTimeout(r, 0));
+}
+describe("Thread.postEphemeral", () => {
+    it("posts natively when the surface supports it (usedFallback=false)", async () => {
+        const fake = new FakeAdapter({ nativeEphemeral: true });
+        let res;
+        await runOnMessage(fake, async ({ thread, message }) => {
+            res = await thread.postEphemeral(message.user, "psst", {
+                fallbackToDM: false,
+            });
+        });
+        expect(res).toMatchObject({ ok: true, usedFallback: false });
+        expect(fake.ephemeralPosts).toHaveLength(1);
+        // Renderable was bound to IR before reaching the adapter.
+        expect(Array.isArray(fake.ephemeralPosts[0].ir)).toBe(true);
+    });
+    it("DM-falls-back when native is unsupported and fallbackToDM=true (usedFallback=true)", async () => {
+        const fake = new FakeAdapter({ nativeEphemeral: false });
+        let res;
+        await runOnMessage(fake, async ({ thread, message }) => {
+            res = await thread.postEphemeral(message.user, "psst", {
+                fallbackToDM: true,
+            });
+        });
+        expect(res).toMatchObject({ ok: true, usedFallback: true });
+    });
+    it("returns null when native unsupported and fallbackToDM=false", async () => {
+        const fake = new FakeAdapter({ nativeEphemeral: false });
+        let res = "sentinel";
+        await runOnMessage(fake, async ({ thread, message }) => {
+            res = await thread.postEphemeral(message.user, "psst", {
+                fallbackToDM: false,
+            });
+        });
+        expect(res).toBeNull();
+    });
+});

package/dist/thread-reactions.test.d.ts

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

package/dist/thread-reactions.test.d.ts.map

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

package/dist/thread-reactions.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { emoji } from "@copilotkit/channels-ui";
+import { createBot } from "./create-bot.js";
+import { FakeAdapter } from "./testing/fake-adapter.js";
+describe("Thread.react / unreact", () => {
+    it("delegates to the adapter when supported", async () => {
+        const fake = new FakeAdapter();
+        const bot = createBot({ adapters: [fake] });
+        const results = [];
+        bot.onMessage(async ({ thread, message }) => {
+            results.push(await thread.react(message.ref, emoji.thumbs_up));
+            results.push(await thread.unreact(message.ref, emoji.thumbs_up));
+        });
+        await bot.start();
+        fake.emitTurn({ userText: "hi" });
+        await new Promise((r) => setTimeout(r, 0));
+        expect(results).toEqual([{ ok: true }, { ok: true }]);
+        expect(fake.reactionsAdded).toEqual([
+            { ref: { id: "" }, emoji: "thumbs_up" },
+        ]);
+        expect(fake.reactionsRemoved).toEqual([
+            { ref: { id: "" }, emoji: "thumbs_up" },
+        ]);
+    });
+    it("returns { ok: false } without throwing when unsupported", async () => {
+        const fake = new FakeAdapter({ reactions: false });
+        const bot = createBot({ adapters: [fake] });
+        let res;
+        bot.onMessage(async ({ thread, message }) => {
+            res = await thread.react(message.ref, emoji.heart);
+        });
+        await bot.start();
+        fake.emitTurn({ userText: "hi" });
+        await new Promise((r) => setTimeout(r, 0));
+        expect(res.ok).toBe(false);
+        expect(res.error).toMatch(/does not support reactions/);
+    });
+});