@copilotkit/channels-slack 0.1.0

package/dist/interaction.test.js

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest";
+import { decodeInteraction, conversationKeyOf } from "./interaction.js";
+import { DM_SCOPE } from "./types.js";
+describe("conversationKeyOf", () => {
+    it("joins channelId + scope with the canonical separator", () => {
+        expect(conversationKeyOf({ channelId: "C1", scope: "100.0" })).toBe("C1::100.0");
+        expect(conversationKeyOf({ channelId: "D9", scope: DM_SCOPE })).toBe("D9::dm");
+    });
+});
+describe("decodeInteraction", () => {
+    it("extracts the opaque action_id + tiny value from a thread block_actions", () => {
+        const evt = decodeInteraction({
+            type: "block_actions",
+            user: { id: "U1", name: "Ana" },
+            channel: { id: "C1" },
+            message: { ts: "111.1", thread_ts: "100.0" },
+            actions: [{ action_id: "ck:abc", value: '{"confirmed":true}' }],
+        });
+        expect(evt).toBeDefined();
+        expect(evt.id).toBe("ck:abc");
+        expect(evt.value).toEqual({ confirmed: true });
+        expect(evt.conversationKey).toBe("C1::100.0");
+        expect(evt.replyTarget).toEqual({ channel: "C1", threadTs: "100.0" });
+        expect(evt.user).toEqual({ id: "U1", name: "Ana" });
+        expect(evt.messageRef).toEqual({ id: "111.1", channel: "C1" });
+    });
+    it("uses DM_SCOPE and a flat replyTarget for DM channels", () => {
+        const evt = decodeInteraction({
+            type: "block_actions",
+            user: { id: "U2", username: "bob" },
+            channel: { id: "D5" },
+            message: { ts: "9.9" },
+            actions: [{ action_id: "ck:dm", value: "yes" }],
+        });
+        expect(evt.conversationKey).toBe("D5::dm");
+        expect(evt.replyTarget).toEqual({ channel: "D5", threadTs: undefined });
+        expect(evt.value).toBe("yes");
+        expect(evt.user).toEqual({ id: "U2", name: "bob" });
+    });
+    it("scopes a THREADED DM (assistant pane) by its thread ts, not DM_SCOPE", () => {
+        // Regression: an assistant-pane DM is threaded, so the ingress path keys
+        // the turn by thread ts. Forcing DM_SCOPE here stranded the HITL waiter and
+        // the run never resumed after a Create/Cancel click.
+        const evt = decodeInteraction({
+            type: "block_actions",
+            user: { id: "U3", name: "Cara" },
+            channel: { id: "D7" },
+            message: { ts: "300.1", thread_ts: "300.0" },
+            actions: [{ action_id: "ck:hitl", value: '{"confirmed":true}' }],
+        });
+        expect(evt.conversationKey).toBe("D7::300.0");
+        // Replies should go back into the assistant thread.
+        expect(evt.replyTarget).toEqual({ channel: "D7", threadTs: "300.0" });
+        expect(evt.value).toEqual({ confirmed: true });
+    });
+    it("falls back to container fields when message/channel are absent", () => {
+        const evt = decodeInteraction({
+            type: "block_actions",
+            container: { channel_id: "C3", thread_ts: "200.0" },
+            actions: [{ action_id: "ck:c", selected_option: { value: "opt-1" } }],
+        });
+        expect(evt.conversationKey).toBe("C3::200.0");
+        expect(evt.value).toBe("opt-1");
+        expect(evt.user).toBeUndefined();
+    });
+    it("decodes a multi_static_select's selected_options into a string[] value", () => {
+        const evt = decodeInteraction({
+            type: "block_actions",
+            container: { channel_id: "C3", thread_ts: "200.0" },
+            actions: [
+                {
+                    action_id: "ck:ms",
+                    selected_options: [{ value: "core" }, { value: "infra" }],
+                },
+            ],
+        });
+        expect(evt.value).toEqual(["core", "infra"]);
+    });
+    it("returns undefined for non-block_actions or missing action_id", () => {
+        expect(decodeInteraction({ type: "view_submission" })).toBeUndefined();
+        expect(decodeInteraction({ type: "block_actions", actions: [] })).toBeUndefined();
+        expect(decodeInteraction({ type: "block_actions", actions: [{ value: "x" }] })).toBeUndefined();
+    });
+    it("returns undefined when no channel can be resolved", () => {
+        expect(decodeInteraction({
+            type: "block_actions",
+            actions: [{ action_id: "ck:x" }],
+        })).toBeUndefined();
+    });
+    it("carries a stable eventId from channel + message ts + action_ts (inbound dedup)", () => {
+        const payload = {
+            type: "block_actions",
+            trigger_id: "trig-123",
+            channel: { id: "C1" },
+            message: { ts: "111.1", thread_ts: "100.0" },
+            actions: [
+                { action_id: "ck:abc", value: "yes", action_ts: "1700000000.5" },
+            ],
+        };
+        const evt = decodeInteraction(payload);
+        expect(evt.eventId).toBe("C1:111.1:1700000000.5");
+        // Stable: decoding the same payload yields the same eventId.
+        expect(decodeInteraction(payload).eventId).toBe(evt.eventId);
+    });
+    it("falls back to trigger_id for eventId when message/action ts are absent", () => {
+        const evt = decodeInteraction({
+            type: "block_actions",
+            trigger_id: "trig-xyz",
+            container: { channel_id: "C3" },
+            actions: [{ action_id: "ck:c", value: "x" }],
+        });
+        expect(evt.eventId).toBe("trig-xyz");
+    });
+    it("does NOT require a resume field (opaque id only)", () => {
+        const evt = decodeInteraction({
+            type: "block_actions",
+            channel: { id: "C2" },
+            message: { ts: "9.9" },
+            actions: [{ action_id: "ck:x" }],
+        });
+        expect(evt.id).toBe("ck:x");
+        // value is undefined when the button carried none — fine; durability rides
+        // on the ActionStore, not the payload.
+        expect(evt.value).toBeUndefined();
+    });
+    it("carries trigger_id from a block_actions payload", () => {
+        const evt = decodeInteraction({
+            type: "block_actions",
+            trigger_id: "T123.456",
+            user: { id: "U1" },
+            channel: { id: "C1" },
+            message: { ts: "1.0" },
+            actions: [{ action_id: "ck:x", value: "v" }],
+        });
+        expect(evt.triggerId).toBe("T123.456");
+    });
+});

package/dist/markdown-to-mrkdwn.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Translate the agent's standard Markdown into Slack's `mrkdwn` flavour.
+ *
+ *   Markdown         →  mrkdwn
+ *   **bold**         →  *bold*
+ *   __bold__         →  *bold*
+ *   *italic*         →  _italic_
+ *   _italic_         →  _italic_
+ *   ~~strike~~       →  ~strike~
+ *   - bullet         →  •  bullet
+ *   # heading        →  *heading*
+ *   [text](url)      →  <url|text>
+ *
+ * Fenced code (``` … ```) and inline `code` pass through unchanged — they
+ * render identically in both flavours.
+ *
+ * Tables (D15): mrkdwn has no table primitive; we wrap GFM tables in a
+ * code fence so they render in monospace and stay readable.
+ */
+export declare function markdownToMrkdwn(input: string): string;
+//# sourceMappingURL=markdown-to-mrkdwn.d.ts.map

package/dist/markdown-to-mrkdwn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-to-mrkdwn.d.ts","sourceRoot":"","sources":["../src/markdown-to-mrkdwn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA6DtD"}

package/dist/markdown-to-mrkdwn.js

@@ -0,0 +1,99 @@
+/**
+ * Translate the agent's standard Markdown into Slack's `mrkdwn` flavour.
+ *
+ *   Markdown         →  mrkdwn
+ *   **bold**         →  *bold*
+ *   __bold__         →  *bold*
+ *   *italic*         →  _italic_
+ *   _italic_         →  _italic_
+ *   ~~strike~~       →  ~strike~
+ *   - bullet         →  •  bullet
+ *   # heading        →  *heading*
+ *   [text](url)      →  <url|text>
+ *
+ * Fenced code (``` … ```) and inline `code` pass through unchanged — they
+ * render identically in both flavours.
+ *
+ * Tables (D15): mrkdwn has no table primitive; we wrap GFM tables in a
+ * code fence so they render in monospace and stay readable.
+ */
+export function markdownToMrkdwn(input) {
+    if (!input)
+        return input;
+    // ── 1. Pull code regions and tables out so we don't touch them. ──
+    const codeRegions = [];
+    const codePlaceholder = (i) => `CODE${i}`;
+    let body = input.replace(/```[\s\S]*?```/g, (match) => {
+        codeRegions.push(match);
+        return codePlaceholder(codeRegions.length - 1);
+    });
+    body = body.replace(/`[^`\n]*`/g, (match) => {
+        codeRegions.push(match);
+        return codePlaceholder(codeRegions.length - 1);
+    });
+    // GFM-style tables: wrap in a fence with column-aligned cells so they
+    // render as a readable monospace table rather than a pile of pipes.
+    body = body.replace(/(^\|[^\n]+\|\s*\n\|[\s:|-]+\|\s*\n(?:\|[^\n]+\|\s*\n?)+)/gm, (table) => {
+        const fenced = "```\n" + alignTable(table.trimEnd()) + "\n```";
+        codeRegions.push(fenced);
+        return codePlaceholder(codeRegions.length - 1);
+    });
+    // ── 2. Bold first, into a sentinel; then italic won't eat its output. ──
+    const BOLD_OPEN = "";
+    const BOLD_CLOSE = "";
+    body = body.replace(/\*\*([^\n*]+?)\*\*/g, `${BOLD_OPEN}$1${BOLD_CLOSE}`);
+    body = body.replace(/__([^\n_]+?)__/g, `${BOLD_OPEN}$1${BOLD_CLOSE}`);
+    // Headings (#…) → bold (also sentinel-marked).
+    body = body.replace(/^\s{0,3}#{1,6}\s+(.*)$/gm, (_m, text) => `${BOLD_OPEN}${text.trim()}${BOLD_CLOSE}`);
+    // Strikethrough ~~text~~ → ~text~
+    body = body.replace(/~~([^\n~]+?)~~/g, "~$1~");
+    // Italic *text* → _text_ (skip already-converted bold sentinels).
+    body = body.replace(/(^|[^*\w])\*(\S(?:[^*\n]*\S)?)\*(?!\w)/g, "$1_$2_");
+    // Italic _text_ stays _text_ (no-op transform, but ensures the form is canonical).
+    // Markdown links [text](url) → <url|text>
+    body = body.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, "<$2|$1>");
+    // Bullet list markers: `- ` / `* ` / `+ ` at the start of a line → "•  "
+    body = body.replace(/^(\s*)[-*+]\s+/gm, "$1•  ");
+    // ── 3. Restore sentinels and code regions. ──
+    body = body.replace(new RegExp(BOLD_OPEN, "g"), "*");
+    body = body.replace(new RegExp(BOLD_CLOSE, "g"), "*");
+    body = body.replace(/CODE(\d+)/g, (_m, idx) => codeRegions[Number(idx)] ?? "");
+    return body;
+}
+/**
+ * Re-render a GFM table with cells padded to consistent column widths so a
+ * monospace render in Slack reads like a real table instead of pipe-soup.
+ * Drops the separator row (no visual value in monospace).
+ */
+function alignTable(table) {
+    const lines = table.split("\n").filter((l) => l.trim().length > 0);
+    const rows = lines.map((line) => {
+        const cells = line.split("|").map((c) => c.trim());
+        if (cells.length > 0 && cells[0] === "")
+            cells.shift();
+        if (cells.length > 0 && cells[cells.length - 1] === "")
+            cells.pop();
+        return cells;
+    });
+    const isSeparator = (row) => row.length > 0 && row.every((c) => /^[-:\s]+$/.test(c));
+    const dataRows = rows.filter((r) => !isSeparator(r));
+    if (dataRows.length === 0)
+        return table;
+    const colCount = Math.max(...dataRows.map((r) => r.length));
+    const widths = [];
+    for (let c = 0; c < colCount; c++) {
+        let max = 0;
+        for (const row of dataRows) {
+            const cell = row[c] ?? "";
+            if (cell.length > max)
+                max = cell.length;
+        }
+        widths.push(max);
+    }
+    return dataRows
+        .map((row) => {
+        const padded = widths.map((w, c) => (row[c] ?? "").padEnd(w));
+        return "| " + padded.join(" | ") + " |";
+    })
+        .join("\n");
+}

package/dist/message-stream.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Per-Slack-message streaming text state machine.
+ *
+ * Wraps a single posted Slack message and lets callers feed it the growing
+ * text buffer of a streaming reply. Edits are throttled (Slack's chat.update
+ * rate limit is ~1/sec per message) and *serialised* through a per-message
+ * promise queue so concurrent updates can't race — a hazard the previous
+ * implementation hit, where End-triggered flush of "ALPHA" could be
+ * overtaken by an in-flight flush of "AL" and the final state read "AL".
+ *
+ * Nothing in this file knows about AG-UI events or @slack/bolt — it's a
+ * pure Slack-side primitive: "give me text, I'll keep one Slack message
+ * in sync with it."
+ */
+export interface MessageStreamConfig {
+    /** Function that actually writes `text` to Slack (e.g. chat.update). */
+    update: (text: string) => Promise<void>;
+    /** Minimum gap between consecutive flushes, in ms (defaults to 800). */
+    minIntervalMs?: number;
+}
+export declare class MessageStream {
+    private buffer;
+    private posted;
+    private queue;
+    private lastFlushedAt;
+    private flushTimer;
+    private readonly minIntervalMs;
+    private readonly update;
+    constructor(config: MessageStreamConfig);
+    /** Replace the in-flight buffer (callers pass the accumulated text). */
+    append(text: string): void;
+    /**
+     * Mark the stream done. Cancels any pending throttled flush, enqueues a
+     * final flush, and resolves once the entire queue (including the final
+     * flush and anything previously in flight) has drained.
+     *
+     * After this resolves, the Slack message reflects the final buffer state.
+     */
+    finish(): Promise<void>;
+    private scheduleFlush;
+    private enqueueFlush;
+    private flushNow;
+}
+//# sourceMappingURL=message-stream.d.ts.map

package/dist/message-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-stream.d.ts","sourceRoot":"","sources":["../src/message-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,mBAAmB;IAClC,wEAAwE;IACxE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,wEAAwE;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;gBAE7C,MAAM,EAAE,mBAAmB;IAKvC,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM1B;;;;;;OAMG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAS7B,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,YAAY;YAIN,QAAQ;CAkBvB"}

package/dist/message-stream.js

@@ -0,0 +1,70 @@
+const DEFAULT_MIN_INTERVAL_MS = 800;
+export class MessageStream {
+    buffer = "";
+    posted = "";
+    queue = Promise.resolve();
+    lastFlushedAt = 0;
+    flushTimer;
+    minIntervalMs;
+    update;
+    constructor(config) {
+        this.update = config.update;
+        this.minIntervalMs = config.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+    }
+    /** Replace the in-flight buffer (callers pass the accumulated text). */
+    append(text) {
+        if (text === this.buffer)
+            return;
+        this.buffer = text;
+        this.scheduleFlush();
+    }
+    /**
+     * Mark the stream done. Cancels any pending throttled flush, enqueues a
+     * final flush, and resolves once the entire queue (including the final
+     * flush and anything previously in flight) has drained.
+     *
+     * After this resolves, the Slack message reflects the final buffer state.
+     */
+    async finish() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        this.enqueueFlush();
+        await this.queue;
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        const elapsed = Date.now() - this.lastFlushedAt;
+        const delay = Math.max(0, this.minIntervalMs - elapsed);
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            this.enqueueFlush();
+        }, delay);
+    }
+    enqueueFlush() {
+        this.queue = this.queue.then(() => this.flushNow());
+    }
+    async flushNow() {
+        if (this.buffer === this.posted)
+            return;
+        const text = this.buffer;
+        this.posted = text;
+        try {
+            await this.update(text);
+        }
+        catch (err) {
+            // Rate-limit (429) edits are already retried by the Slack WebClient
+            // (honoring Retry-After). If we still land here the edit genuinely
+            // failed — swallow it: a single failed edit shouldn't sink the
+            // stream, and future appends retry with the latest buffer.
+            console.error("[message-stream] update failed:", err);
+        }
+        finally {
+            // Set lastFlushedAt *after* the update returns so the throttle
+            // measures wall-clock time between completions, not starts.
+            this.lastFlushedAt = Date.now();
+        }
+    }
+}

package/dist/native-stream.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Native Slack streaming transport (`chat.startStream` / `appendStream` /
+ * `stopStream`, GA Oct 2025) behind the SAME `append(fullText)/finish()`
+ * contract as the shipped {@link MessageStream} — callers (the event-renderer's
+ * reply stream, `adapter.stream()`) can't tell which transport ran.
+ *
+ * Differences from the legacy `chat.update` streamer:
+ *
+ *   - Slack renders a true streaming UI, and the payload is **raw markdown**
+ *     (`markdown_text`), so real tables / fenced code render natively — there
+ *     is NO mrkdwn translation and NO bracket auto-closing (Slack's streaming
+ *     renderer tolerates a mid-stream-unbalanced buffer).
+ *   - `appendStream` takes the *delta* since the last flush, not the full
+ *     accumulated text, so this class tracks how much it has already sent.
+ *   - A single streamed message holds the whole reply: Slack documents no
+ *     cumulative per-message cap, only a **12k char limit per `markdown_text`
+ *     call**, so long replies are sent as successive ≤12k appends to the SAME
+ *     message (no multi-message splitting — that was a `chat.update`-era
+ *     workaround).
+ *   - Beyond text, the stream can carry structured {@link AnyChunk}s
+ *     (`task_update` / `plan_update` / `blocks`) via {@link appendChunk}, which
+ *     flushes any pending text first so ordering is preserved, and a finalized
+ *     message can carry trailing Block Kit (e.g. a feedback row) via the
+ *     `finalBlocks` passed to {@link finish}.
+ *
+ * Failure handling — "opting in can never break a bot": if the very first
+ * `startStream` throws (e.g. a workspace where the streaming API is
+ * unavailable), the stream transparently rebuilds itself on the supplied
+ * legacy `fallback()` transport and replays the buffer there. `onStartFailure`
+ * lets the adapter mark the workspace legacy so subsequent streams skip the
+ * native path entirely. Per-`appendStream` failures mid-stream are swallowed
+ * (logged) like the legacy streamer's failed edits; a failing structured-chunk
+ * append additionally fires `onChunkFailure` so the caller can degrade
+ * tool-progress to its legacy surface.
+ *
+ * Nothing here imports `@slack/web-api` — the Slack calls are injected as a
+ * {@link NativeStreamTransport}, keeping the cadence logic unit-testable with
+ * fake timers and a fake transport.
+ */
+import type { AnyChunk, KnownBlock } from "@slack/types";
+/** A minimal `{ append(fullText), finish() }` streaming sink. */
+export interface TextStream {
+    /** Replace the in-flight buffer with the accumulated text. */
+    append(fullText: string): void;
+    /** Flush the final state and close the stream. */
+    finish(): Promise<void>;
+}
+/** The Slack streaming calls, injected so this file stays SDK-free. */
+export interface NativeStreamTransport {
+    /** `chat.startStream` → resolves with the new streamed message's `ts`. Throws on failure. */
+    startStream(): Promise<string>;
+    /** `chat.appendStream` — append a raw `markdown_text` delta to the message at `ts`. */
+    appendText(ts: string, markdownText: string): Promise<void>;
+    /** `chat.appendStream` — append structured {@link AnyChunk}s to the message at `ts`. */
+    appendChunks(ts: string, chunks: AnyChunk[]): Promise<void>;
+    /** `chat.stopStream` — finalize the streamed message at `ts`, optionally with trailing blocks. */
+    stopStream(ts: string, finalBlocks?: KnownBlock[]): Promise<void>;
+}
+export interface NativeMessageStreamConfig {
+    transport: NativeStreamTransport;
+    /**
+     * Builds the legacy `chat.update` transport, used only if the first
+     * `startStream` throws. The accumulated buffer is replayed into it so no
+     * text is lost.
+     */
+    fallback: () => TextStream;
+    /** Called once when the first `startStream` fails (adapter marks the workspace legacy). */
+    onStartFailure?: (err: unknown) => void;
+    /**
+     * Called when a structured-chunk append fails or is impossible (the stream
+     * has already fallen back to the legacy `chat.update` transport, which has no
+     * chunk equivalent). Lets the caller degrade tool-progress to its legacy
+     * surface (`:wrench:` rows). Text streaming is unaffected.
+     */
+    onChunkFailure?: (err: unknown) => void;
+    /** Minimum gap between text flushes, in ms (defaults to 600). */
+    minIntervalMs?: number;
+}
+export declare class NativeMessageStream implements TextStream {
+    private buffer;
+    private queue;
+    private lastFlushedAt;
+    private flushTimer;
+    private finished;
+    /** Current streamed message ts (undefined until the first `startStream`). */
+    private curTs;
+    /** Buffer chars already appended as text to the current message. */
+    private curPosted;
+    /** ts of the first streamed message (for the returned MessageRef). */
+    private firstTsValue;
+    /** Set once `startStream` has failed and we've fallen back to the legacy transport. */
+    private legacy;
+    /** Set once a chunk append has failed/been refused, so we stop trying. */
+    private chunksDisabled;
+    private readonly transport;
+    private readonly makeFallback;
+    private readonly onStartFailure;
+    private readonly onChunkFailure;
+    private readonly minIntervalMs;
+    constructor(config: NativeMessageStreamConfig);
+    /** The first streamed message's ts (or the fallback's), available after finish(). */
+    get firstTs(): string | undefined;
+    append(fullText: string): void;
+    /**
+     * Append a structured chunk (`task_update` / `plan_update` / `blocks`) to the
+     * streamed message. Flushes any pending text first so the chunk lands AFTER
+     * the text emitted so far. No-op (firing `onChunkFailure` once) when the
+     * stream has fallen back to legacy or chunks were already refused.
+     */
+    appendChunk(chunk: AnyChunk): void;
+    finish(finalBlocks?: KnownBlock[]): Promise<void>;
+    private scheduleFlush;
+    private enqueueFlush;
+    /** Ensure the stream is started; on failure, fall back to legacy and replay. Returns false if failed over. */
+    private ensureStarted;
+    /** Append all un-posted buffer text to the current message, chunked under the 12k per-call cap. */
+    private flushText;
+    /** Flush pending text, then append one structured chunk. */
+    private flushChunk;
+    /** Append pending text to the current (already-started) message; swallow failures. */
+    private flushTextInline;
+    private disableChunks;
+    /**
+     * Switch to the legacy `chat.update` transport and replay the full buffer so
+     * no text is lost ("opting in can never break a bot"). The full buffer is
+     * replayed because `append()` forwards the accumulated full text once
+     * `this.legacy` is set, so the legacy stream owns the whole response.
+     */
+    private failOverToLegacy;
+}
+//# sourceMappingURL=native-stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native-stream.d.ts","sourceRoot":"","sources":["../src/native-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAEzD,iEAAiE;AACjE,MAAM,WAAW,UAAU;IACzB,8DAA8D;IAC9D,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,kDAAkD;IAClD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,uEAAuE;AACvE,MAAM,WAAW,qBAAqB;IACpC,6FAA6F;IAC7F,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,uFAAuF;IACvF,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,wFAAwF;IACxF,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,kGAAkG;IAClG,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,qBAAqB,CAAC;IACjC;;;;OAIG;IACH,QAAQ,EAAE,MAAM,UAAU,CAAC;IAC3B,2FAA2F;IAC3F,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAYD,qBAAa,mBAAoB,YAAW,UAAU;IACpD,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAA4C;IAC9D,OAAO,CAAC,QAAQ,CAAS;IAEzB,6EAA6E;IAC7E,OAAO,CAAC,KAAK,CAAqB;IAClC,oEAAoE;IACpE,OAAO,CAAC,SAAS,CAAK;IACtB,sEAAsE;IACtE,OAAO,CAAC,YAAY,CAAqB;IAEzC,uFAAuF;IACvF,OAAO,CAAC,MAAM,CAAyB;IACvC,0EAA0E;IAC1E,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuC;IACtE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuC;IACtE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,MAAM,EAAE,yBAAyB;IAQ7C,qFAAqF;IACrF,IAAI,OAAO,IAAI,MAAM,GAAG,SAAS,CAEhC;IAED,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAU9B;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAiB5B,MAAM,CAAC,WAAW,CAAC,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBvD,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,YAAY;IAIpB,8GAA8G;YAChG,aAAa;IAY3B,mGAAmG;YACrF,SAAS;IA2BvB,4DAA4D;YAC9C,UAAU;IAuBxB,sFAAsF;YACxE,eAAe;IAqB7B,OAAO,CAAC,aAAa;IAMrB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;CAUzB"}