@copilotkit/channels-slack 0.1.0

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

@@ -0,0 +1,116 @@
+import { describe, it, expect } from "vitest";
+import { MessageStream } from "../message-stream.js";
+/** A fake Slack `chat.update` that records every call in order and lets the
+ *  test control how long each takes — useful for proving the in-flight /
+ *  finish race that bit the original implementation can't happen here. */
+function makeFakeSlack(updateDurationMs = 0) {
+    const calls = [];
+    let started = 0;
+    let finished = 0;
+    const update = async (text) => {
+        started++;
+        if (updateDurationMs > 0) {
+            await new Promise((r) => setTimeout(r, updateDurationMs));
+        }
+        finished++;
+        calls.push({ text, finishedAt: Date.now() });
+    };
+    return {
+        update,
+        calls,
+        get inFlight() {
+            return started - finished;
+        },
+    };
+}
+describe("MessageStream", () => {
+    it("flushes the final buffer on finish() even when end races an in-flight update", async () => {
+        // Reproduces the ALPHA → AL bug: a slow chat.update for "AL" is in
+        // flight when the stream finishes with "ALPHA". The old implementation
+        // could let the slow "AL" update overwrite "ALPHA" because chat.update
+        // calls weren't serialised. With the queue, finish() must observe the
+        // final buffer regardless of in-flight state.
+        const slack = makeFakeSlack(50);
+        const stream = new MessageStream({
+            update: slack.update,
+            minIntervalMs: 0,
+        });
+        stream.append("A");
+        stream.append("AL");
+        // Let the timer fire and the first flush kick off (in-flight)
+        await new Promise((r) => setTimeout(r, 5));
+        expect(slack.inFlight).toBeGreaterThanOrEqual(0); // best effort
+        stream.append("ALP");
+        stream.append("ALPH");
+        stream.append("ALPHA");
+        await stream.finish();
+        expect(slack.calls.length).toBeGreaterThan(0);
+        // The LAST chat.update — i.e. the final state of the Slack message — must be ALPHA
+        expect(slack.calls.at(-1)?.text).toBe("ALPHA");
+        // And no concurrent updates were ever in flight (queue invariant)
+        expect(slack.inFlight).toBe(0);
+    });
+    it("never has more than one update in flight at a time", async () => {
+        const slack = makeFakeSlack(20);
+        let maxInFlight = 0;
+        const sampler = setInterval(() => {
+            if (slack.inFlight > maxInFlight)
+                maxInFlight = slack.inFlight;
+        }, 1);
+        const stream = new MessageStream({
+            update: slack.update,
+            minIntervalMs: 0,
+        });
+        for (let i = 1; i <= 20; i++) {
+            stream.append("x".repeat(i));
+            await new Promise((r) => setTimeout(r, 2));
+        }
+        await stream.finish();
+        clearInterval(sampler);
+        expect(maxInFlight).toBeLessThanOrEqual(1);
+    });
+    it("throttles flushes to roughly minIntervalMs between completions", async () => {
+        const slack = makeFakeSlack(0);
+        const stream = new MessageStream({
+            update: slack.update,
+            minIntervalMs: 50,
+        });
+        const start = Date.now();
+        for (let i = 0; i < 10; i++) {
+            stream.append(`buf${i}`);
+            await new Promise((r) => setTimeout(r, 5));
+        }
+        await stream.finish();
+        // 10 rapid appends should NOT have produced 10 chat.update calls; the
+        // throttle should have coalesced them. Exact count varies by timing but
+        // should be well under 10.
+        expect(slack.calls.length).toBeLessThan(10);
+        // Final state must still match the last append
+        expect(slack.calls.at(-1)?.text).toBe("buf9");
+        // And the test ran for at least one throttle window
+        expect(Date.now() - start).toBeGreaterThanOrEqual(0);
+    });
+    it("collapses duplicate appends into zero updates", async () => {
+        const slack = makeFakeSlack(0);
+        const stream = new MessageStream({
+            update: slack.update,
+            minIntervalMs: 0,
+        });
+        stream.append("hello");
+        stream.append("hello");
+        stream.append("hello");
+        await stream.finish();
+        // One actual update, not three
+        expect(slack.calls).toHaveLength(1);
+        expect(slack.calls[0]?.text).toBe("hello");
+    });
+    it("is a no-op when finish() is called before any append", async () => {
+        const slack = makeFakeSlack(0);
+        const stream = new MessageStream({
+            update: slack.update,
+            minIntervalMs: 0,
+        });
+        await stream.finish();
+        expect(slack.calls).toHaveLength(0);
+    });
+});

package/dist/__tests__/native-renderer.test.d.ts

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

package/dist/__tests__/native-renderer.test.d.ts.map

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

package/dist/__tests__/native-renderer.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi } from "vitest";
+import { createRunRenderer } from "../event-renderer.js";
+/** Fake render transport for the non-native side channels (legacy/error posts). */
+function makeFakeClient() {
+    const posts = [];
+    const updates = [];
+    let counter = 0;
+    const transport = {
+        setStatus: vi.fn(async () => { }),
+        postMessage: vi.fn(async (args) => {
+            counter++;
+            const ts = `${counter}.000`;
+            posts.push({ ...args, ts });
+            return { ts };
+        }),
+        updateMessage: vi.fn(async (args) => {
+            updates.push(args);
+        }),
+    };
+    return { transport, posts, updates };
+}
+/** Fake native streaming transport recording every streamed message's lifecycle. */
+function makeFakeNativeTransport(opts) {
+    const messages = [];
+    let counter = 0;
+    const transport = {
+        startStream: vi.fn(async () => {
+            counter++;
+            const ts = `S${counter}`;
+            messages.push({ ts, events: [], stopped: false });
+            return ts;
+        }),
+        appendText: vi.fn(async (ts, md) => {
+            messages
+                .find((m) => m.ts === ts)
+                ?.events.push({ kind: "text", value: md });
+        }),
+        appendChunks: vi.fn(async (ts, chunks) => {
+            if (opts?.failChunks)
+                throw new Error("chunks unsupported");
+            messages
+                .find((m) => m.ts === ts)
+                ?.events.push({ kind: "chunks", value: chunks });
+        }),
+        stopStream: vi.fn(async (ts, blocks) => {
+            const m = messages.find((x) => x.ts === ts);
+            if (m) {
+                m.stopped = true;
+                m.stopBlocks = blocks;
+            }
+        }),
+    };
+    return { transport, messages };
+}
+const textOf = (events) => events
+    .filter((e) => e.kind === "text")
+    .map((e) => e.value)
+    .join("");
+const chunksOf = (events) => events
+    .filter((e) => e.kind === "chunks")
+    .flatMap((e) => e.value);
+const tick = () => new Promise((r) => setTimeout(r, 0));
+describe("createRunRenderer — native streaming", () => {
+    it("streams multiple AG-UI messages into ONE turn message, separated by a blank line", async () => {
+        const fake = makeFakeClient();
+        const nt = makeFakeNativeTransport();
+        const { subscriber: sub, finish } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: nt.transport },
+        });
+        await sub.onTextMessageStartEvent({ event: { messageId: "m1" } });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "Hello" },
+        });
+        await sub.onTextMessageEndEvent({ event: { messageId: "m1" } });
+        await sub.onTextMessageStartEvent({ event: { messageId: "m2" } });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "m2", delta: "World" },
+        });
+        await sub.onTextMessageEndEvent({ event: { messageId: "m2" } });
+        await finish();
+        expect(nt.transport.startStream).toHaveBeenCalledTimes(1);
+        expect(nt.messages).toHaveLength(1);
+        expect(textOf(nt.messages[0].events)).toBe("Hello\n\nWorld");
+        expect(nt.messages[0].stopped).toBe(true);
+    });
+    it("surfaces tool calls as in-message task_update chunks (no :wrench: rows)", async () => {
+        const fake = makeFakeClient();
+        const nt = makeFakeNativeTransport();
+        const { subscriber: sub, finish } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: nt.transport },
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "thinking…" },
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "t1", toolCallName: "search" },
+        });
+        await sub.onToolCallEndEvent({
+            event: { toolCallId: "t1" },
+            toolCallName: "search",
+            toolCallArgs: {},
+        });
+        await finish();
+        // No legacy :wrench: rows posted to the channel.
+        expect(fake.posts.filter((p) => p.text.includes(":wrench:"))).toHaveLength(0);
+        const chunks = chunksOf(nt.messages[0].events);
+        expect(chunks).toEqual([
+            {
+                type: "task_update",
+                id: "t1",
+                title: "Using `search`",
+                status: "in_progress",
+            },
+            {
+                type: "task_update",
+                id: "t1",
+                title: "Used `search`",
+                status: "complete",
+            },
+        ]);
+    });
+    it("showToolStatus:false suppresses tool progress entirely (no chunks, no rows)", async () => {
+        const fake = makeFakeClient();
+        const nt = makeFakeNativeTransport();
+        const { subscriber: sub, finish } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: nt.transport },
+            showToolStatus: false,
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "answer" },
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "t1", toolCallName: "search" },
+        });
+        await sub.onToolCallEndEvent({
+            event: { toolCallId: "t1" },
+            toolCallName: "search",
+            toolCallArgs: {},
+        });
+        await finish();
+        // No task_update chunks and no :wrench: rows — only the text answer.
+        expect(chunksOf(nt.messages[0].events)).toHaveLength(0);
+        expect(fake.posts.filter((p) => p.text.includes(":wrench:"))).toHaveLength(0);
+        expect(textOf(nt.messages[0].events)).toBe("answer");
+    });
+    it("attaches the feedback row at finish only when text was streamed", async () => {
+        const blocks = [
+            { type: "context_actions", elements: [] },
+        ];
+        // (a) with text → feedback attached.
+        const withText = makeFakeNativeTransport();
+        const r1 = createRunRenderer({
+            transport: makeFakeClient().transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: withText.transport },
+            feedbackBlocks: blocks,
+        });
+        r1.subscriber.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "answer" },
+        });
+        await r1.finish();
+        expect(withText.messages[0].stopBlocks).toBe(blocks);
+        // (b) no text (tool-only run) → no stream, nothing to attach.
+        const noText = makeFakeNativeTransport();
+        const r2 = createRunRenderer({
+            transport: makeFakeClient().transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: noText.transport },
+            feedbackBlocks: blocks,
+        });
+        await r2.finish();
+        expect(noText.messages).toHaveLength(0);
+    });
+    it("degrades to :wrench: rows after a chunk append fails", async () => {
+        const fake = makeFakeClient();
+        const nt = makeFakeNativeTransport({ failChunks: true });
+        const onChunkFailure = vi.fn();
+        const { subscriber: sub, finish } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: nt.transport, onChunkFailure },
+        });
+        // First tool call tries a chunk, which fails and flips the degradation flag.
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "t1", toolCallName: "search" },
+        });
+        await tick(); // let the queued chunk append run and fail
+        expect(onChunkFailure).toHaveBeenCalled();
+        // Second tool call now falls back to a :wrench: status row.
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "t2", toolCallName: "lookup" },
+        });
+        await finish();
+        expect(fake.posts.some((p) => p.text.includes(":wrench:"))).toBe(true);
+    });
+    it("does NOT attach the feedback row to an interrupted partial reply", async () => {
+        const nt = makeFakeNativeTransport();
+        const blocks = [
+            { type: "context_actions", elements: [] },
+        ];
+        const { subscriber: sub, markInterrupted } = createRunRenderer({
+            transport: makeFakeClient().transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: nt.transport },
+            feedbackBlocks: blocks,
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "partial" },
+        });
+        await markInterrupted();
+        expect(nt.messages[0].stopped).toBe(true);
+        expect(nt.messages[0].stopBlocks).toBeUndefined();
+    });
+    it("markInterrupted finalizes the single turn stream with the interrupted marker", async () => {
+        const fake = makeFakeClient();
+        const nt = makeFakeNativeTransport();
+        const { subscriber: sub, markInterrupted } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            nativeStreaming: { transport: nt.transport },
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "Once upon a time" },
+        });
+        await markInterrupted();
+        expect(nt.messages).toHaveLength(1);
+        expect(nt.messages[0].stopped).toBe(true);
+        expect(textOf(nt.messages[0].events)).toContain("_(interrupted)_");
+    });
+});

package/dist/__tests__/native-stream.test.d.ts

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

package/dist/__tests__/native-stream.test.d.ts.map

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

package/dist/__tests__/native-stream.test.js

@@ -0,0 +1,235 @@
+import { describe, it, expect, vi } from "vitest";
+import { NativeMessageStream } from "../native-stream.js";
+/**
+ * A fake `chat.startStream/appendStream/stopStream` transport that records the
+ * lifecycle of every streamed message in order: text appends and chunk appends
+ * interleaved, plus the stop call and any trailing blocks.
+ */
+function makeFakeTransport(opts) {
+    const messages = [];
+    let counter = 0;
+    const transport = {
+        startStream: vi.fn(async () => {
+            if (opts?.failStart)
+                throw new Error("startStream unavailable");
+            counter++;
+            const ts = `S${counter}`;
+            messages.push({ ts, events: [], stopped: false });
+            return ts;
+        }),
+        appendText: vi.fn(async (ts, md) => {
+            messages
+                .find((m) => m.ts === ts)
+                ?.events.push({ kind: "text", value: md });
+        }),
+        appendChunks: vi.fn(async (ts, chunks) => {
+            if (opts?.failChunks)
+                throw new Error("chunks unsupported");
+            messages
+                .find((m) => m.ts === ts)
+                ?.events.push({ kind: "chunks", value: chunks });
+        }),
+        stopStream: vi.fn(async (ts, blocks) => {
+            const m = messages.find((x) => x.ts === ts);
+            if (m) {
+                m.stopped = true;
+                m.stopBlocks = blocks;
+            }
+        }),
+    };
+    return { transport, messages };
+}
+/** A legacy fallback sink that records the accumulated text it sees. */
+function makeFakeFallback() {
+    let buf = "";
+    let finished = false;
+    return {
+        append(fullText) {
+            buf = fullText;
+        },
+        async finish() {
+            finished = true;
+        },
+        last: () => buf,
+        get finished() {
+            return finished;
+        },
+    };
+}
+const textOf = (events) => events
+    .filter((e) => e.kind === "text")
+    .map((e) => e.value)
+    .join("");
+describe("NativeMessageStream", () => {
+    it("starts one stream and appends only the deltas, in order", async () => {
+        const { transport, messages } = makeFakeTransport();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            minIntervalMs: 0,
+        });
+        stream.append("A");
+        stream.append("AL");
+        stream.append("ALPHA");
+        await stream.finish();
+        expect(transport.startStream).toHaveBeenCalledTimes(1);
+        expect(messages).toHaveLength(1);
+        expect(textOf(messages[0].events)).toBe("ALPHA");
+        expect(messages[0].stopped).toBe(true);
+        expect(stream.firstTs).toBe("S1");
+    });
+    it("never starts a stream when nothing is appended", async () => {
+        const { transport, messages } = makeFakeTransport();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            minIntervalMs: 0,
+        });
+        await stream.finish();
+        expect(transport.startStream).not.toHaveBeenCalled();
+        expect(messages).toHaveLength(0);
+    });
+    it("keeps a long reply in ONE message, chunking appends under the 12k per-call cap", async () => {
+        const { transport, messages } = makeFakeTransport();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            minIntervalMs: 0,
+        });
+        const text = "x".repeat(25_000); // > 2× the 12k per-append limit
+        stream.append(text);
+        await stream.finish();
+        // One streamed message (no continuation splitting), finalized.
+        expect(messages).toHaveLength(1);
+        expect(messages[0].stopped).toBe(true);
+        // Reconstructs exactly, and every append is <= 12k chars.
+        const appends = messages[0].events.filter((e) => e.kind === "text");
+        expect(appends.length).toBeGreaterThan(1);
+        for (const a of appends)
+            expect(a.value.length).toBeLessThanOrEqual(12_000);
+        expect(textOf(messages[0].events)).toBe(text);
+    });
+    it("appendChunk flushes pending text FIRST, then sends the chunk", async () => {
+        const { transport, messages } = makeFakeTransport();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            minIntervalMs: 0,
+        });
+        stream.append("hello");
+        const chunk = {
+            type: "task_update",
+            id: "t1",
+            title: "Using `search`",
+            status: "in_progress",
+        };
+        stream.appendChunk(chunk);
+        await stream.finish();
+        const events = messages[0].events;
+        // Text "hello" must land before the chunk.
+        const textIdx = events.findIndex((e) => e.kind === "text");
+        const chunkIdx = events.findIndex((e) => e.kind === "chunks");
+        expect(textIdx).toBeGreaterThanOrEqual(0);
+        expect(chunkIdx).toBeGreaterThan(textIdx);
+        expect(events[chunkIdx].value).toEqual([chunk]);
+    });
+    it("starts the stream when the first thing emitted is a chunk (no text yet)", async () => {
+        const { transport, messages } = makeFakeTransport();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            minIntervalMs: 0,
+        });
+        stream.appendChunk({
+            type: "task_update",
+            id: "t1",
+            title: "Using `search`",
+            status: "in_progress",
+        });
+        await stream.finish();
+        expect(transport.startStream).toHaveBeenCalledTimes(1);
+        expect(messages[0].events[0]?.kind).toBe("chunks");
+    });
+    it("finish(blocks) finalizes the message carrying trailing blocks", async () => {
+        const { transport, messages } = makeFakeTransport();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            minIntervalMs: 0,
+        });
+        stream.append("done");
+        const blocks = [
+            { type: "context_actions", elements: [] },
+        ];
+        await stream.finish(blocks);
+        expect(messages[0].stopped).toBe(true);
+        expect(messages[0].stopBlocks).toBe(blocks);
+    });
+    it("falls back to the legacy transport when the first startStream fails", async () => {
+        const { transport } = makeFakeTransport({ failStart: true });
+        const fallback = makeFakeFallback();
+        const onStartFailure = vi.fn();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: () => fallback,
+            onStartFailure,
+            minIntervalMs: 0,
+        });
+        stream.append("hello");
+        stream.append("hello world");
+        await stream.finish();
+        expect(onStartFailure).toHaveBeenCalledTimes(1);
+        expect(transport.appendText).not.toHaveBeenCalled();
+        expect(fallback.last()).toBe("hello world");
+        expect(fallback.finished).toBe(true);
+    });
+    it("fires onChunkFailure and degrades when a chunk append fails", async () => {
+        const { transport, messages } = makeFakeTransport({ failChunks: true });
+        const onChunkFailure = vi.fn();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            onChunkFailure,
+            minIntervalMs: 0,
+        });
+        stream.append("text");
+        stream.appendChunk({
+            type: "task_update",
+            id: "t1",
+            title: "Using `x`",
+            status: "in_progress",
+        });
+        // A second chunk after the failure must NOT retry (chunks disabled).
+        stream.appendChunk({
+            type: "task_update",
+            id: "t1",
+            title: "Used `x`",
+            status: "complete",
+        });
+        await stream.finish();
+        expect(onChunkFailure).toHaveBeenCalledTimes(1);
+        // Text still streamed and the message finalized — degradation, not failure.
+        expect(textOf(messages[0].events)).toBe("text");
+        expect(messages[0].stopped).toBe(true);
+    });
+    it("appendChunk on an already-failed-over (legacy) stream fires onChunkFailure once, no-op", async () => {
+        const { transport } = makeFakeTransport({ failStart: true });
+        const onChunkFailure = vi.fn();
+        const stream = new NativeMessageStream({
+            transport,
+            fallback: makeFakeFallback,
+            onChunkFailure,
+            minIntervalMs: 0,
+        });
+        stream.append("hi");
+        await stream.finish(); // triggers failover to legacy
+        stream.appendChunk({
+            type: "task_update",
+            id: "t1",
+            title: "x",
+            status: "in_progress",
+        });
+        expect(onChunkFailure).toHaveBeenCalledTimes(1);
+        expect(transport.appendChunks).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/reactions.test.d.ts

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

package/dist/__tests__/reactions.test.d.ts.map

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