@copilotkit/channels-teams 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { teams, TeamsAdapter } from "./adapter.js";
+export type { TeamsAdapterOptions, TeamsReplyTarget, ConversationKey, } from "./types.js";
+export { TeamsConversationStore } from "./conversation-store.js";
+export { createRunRenderer } from "./event-renderer.js";
+export { conversationKeyOf, parseCardAction } from "./interaction.js";
+export { renderTeamsMarkdown } from "./render/markdown.js";
+export { autoCloseOpenMarkdown } from "./render/auto-close.js";
+export { renderAdaptiveCard, isPlainText, collectPlainText, ADAPTIVE_CARD_CONTENT_TYPE, } from "./render/adaptive-card.js";
+export type { AdaptiveCard } from "./render/adaptive-card.js";
+export { TEAMS_LIMITS, truncateText, clampArray } from "./render/budget.js";
+export { TeamsMessageStream } from "./message-stream.js";
+export type { TeamsMessageStreamConfig } from "./message-stream.js";
+export { createTeamsServer } from "./listener.js";
+export type { TeamsServer, TeamsServerConfig } from "./listener.js";
+export { SanitizingHttpAgent } from "./sanitizing-http-agent.js";
+export { buildFileContentParts, decodeFileBytes } from "./download-files.js";
+export type { TeamsAttachmentRef, FileDeliveryConfig, } from "./download-files.js";
+export { buildChannelFileContentParts } from "./graph-files.js";
+export type { GraphCredentials, ChannelMessageRef } from "./graph-files.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EAChB,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC7E,YAAY,EACV,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAChE,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+// Public API for @copilotkit/channels-teams.
+export { teams, TeamsAdapter } from "./adapter.js";
+export { TeamsConversationStore } from "./conversation-store.js";
+export { createRunRenderer } from "./event-renderer.js";
+export { conversationKeyOf, parseCardAction } from "./interaction.js";
+export { renderTeamsMarkdown } from "./render/markdown.js";
+export { autoCloseOpenMarkdown } from "./render/auto-close.js";
+export { renderAdaptiveCard, isPlainText, collectPlainText, ADAPTIVE_CARD_CONTENT_TYPE, } from "./render/adaptive-card.js";
+export { TEAMS_LIMITS, truncateText, clampArray } from "./render/budget.js";
+export { TeamsMessageStream } from "./message-stream.js";
+export { createTeamsServer } from "./listener.js";
+export { SanitizingHttpAgent } from "./sanitizing-http-agent.js";
+export { buildFileContentParts, decodeFileBytes } from "./download-files.js";
+export { buildChannelFileContentParts } from "./graph-files.js";

package/dist/interaction.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Adaptive Card `Action.Submit` decoding for the Teams adapter.
+ *
+ * A button rendered by {@link ../render/adaptive-card.renderButton} carries its
+ * opaque minted action id (`ck:...`) and tiny `value` in the action's `data`.
+ * When clicked, Teams delivers a **Message activity** whose `value` is that
+ * `data` object (merged with any card inputs) and whose `text` is empty. These
+ * helpers recognize and decode that activity so the engine's `awaitChoice`
+ * waiter resolves.
+ */
+/** Minimal shape of the inbound Teams activity we read for interaction decoding. */
+export interface TeamsActivityLike {
+    value?: unknown;
+    conversation?: {
+        id?: string;
+    };
+}
+/**
+ * Stable conversation key shared by ingress (`onTurn`) and interaction decoding
+ * so the engine's `awaitChoice` waiters resolve. Teams gives one stable id per
+ * conversation; **both paths MUST derive the key here**. A mismatch silently
+ * strands the waiter. (The issue mandates a single shared helper.)
+ */
+export declare function conversationKeyOf(activity: TeamsActivityLike): string;
+/**
+ * Recognize and parse an Adaptive Card `Action.Submit`. Returns the opaque
+ * action id + button value when the activity carries our `ckActionId`, else
+ * `undefined` (i.e. it's an ordinary chat message). Carries ONLY the opaque id
+ * and the tiny button value: no resume-data smuggling; durability rides on the
+ * engine's ActionStore keyed by that id.
+ */
+export declare function parseCardAction(activity: TeamsActivityLike): {
+    id: string;
+    value: unknown;
+} | undefined;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../src/interaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,oFAAoF;AACpF,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAChC;AAQD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAErE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,iBAAiB,GAC1B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAU5C"}

package/dist/interaction.js

@@ -0,0 +1,35 @@
+/**
+ * Adaptive Card `Action.Submit` decoding for the Teams adapter.
+ *
+ * A button rendered by {@link ../render/adaptive-card.renderButton} carries its
+ * opaque minted action id (`ck:...`) and tiny `value` in the action's `data`.
+ * When clicked, Teams delivers a **Message activity** whose `value` is that
+ * `data` object (merged with any card inputs) and whose `text` is empty. These
+ * helpers recognize and decode that activity so the engine's `awaitChoice`
+ * waiter resolves.
+ */
+/**
+ * Stable conversation key shared by ingress (`onTurn`) and interaction decoding
+ * so the engine's `awaitChoice` waiters resolve. Teams gives one stable id per
+ * conversation; **both paths MUST derive the key here**. A mismatch silently
+ * strands the waiter. (The issue mandates a single shared helper.)
+ */
+export function conversationKeyOf(activity) {
+    return activity.conversation?.id ?? "";
+}
+/**
+ * Recognize and parse an Adaptive Card `Action.Submit`. Returns the opaque
+ * action id + button value when the activity carries our `ckActionId`, else
+ * `undefined` (i.e. it's an ordinary chat message). Carries ONLY the opaque id
+ * and the tiny button value: no resume-data smuggling; durability rides on the
+ * engine's ActionStore keyed by that id.
+ */
+export function parseCardAction(activity) {
+    const data = activity.value;
+    if (!data ||
+        typeof data !== "object" ||
+        typeof data.ckActionId !== "string") {
+        return undefined;
+    }
+    return { id: data.ckActionId, value: data.value };
+}

package/dist/interaction.test.d.ts

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

package/dist/interaction.test.d.ts.map

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

package/dist/interaction.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { conversationKeyOf, parseCardAction } from "./interaction.js";
+describe("conversationKeyOf", () => {
+    it("derives the key from activity.conversation.id", () => {
+        expect(conversationKeyOf({ conversation: { id: "19:abc@thread.tacv2" } })).toBe("19:abc@thread.tacv2");
+    });
+    it("is empty when there is no conversation id (never throws)", () => {
+        expect(conversationKeyOf({})).toBe("");
+        expect(conversationKeyOf({ conversation: {} })).toBe("");
+    });
+    it("matches between an ingress message and its later card-action submit", () => {
+        // Both paths MUST agree or the awaitChoice waiter is stranded.
+        const id = "19:meeting_xyz@thread.v2";
+        const ingress = conversationKeyOf({ conversation: { id } });
+        const submit = conversationKeyOf({
+            conversation: { id },
+            value: { ckActionId: "ck:1", value: { confirmed: true } },
+        });
+        expect(submit).toBe(ingress);
+    });
+});
+describe("parseCardAction", () => {
+    it("decodes an Action.Submit carrying our ckActionId + value", () => {
+        const parsed = parseCardAction({
+            value: { ckActionId: "ck:approve-1", value: { confirmed: true } },
+        });
+        expect(parsed).toEqual({ id: "ck:approve-1", value: { confirmed: true } });
+    });
+    it("returns undefined for an ordinary chat message (no value)", () => {
+        expect(parseCardAction({ conversation: { id: "c1" } })).toBeUndefined();
+    });
+    it("returns undefined when value lacks a ckActionId", () => {
+        expect(parseCardAction({ value: { foo: "bar" } })).toBeUndefined();
+        expect(parseCardAction({ value: "just text" })).toBeUndefined();
+        expect(parseCardAction({ value: { ckActionId: 42 } })).toBeUndefined();
+    });
+    it("passes through a falsy/absent button value", () => {
+        expect(parseCardAction({ value: { ckActionId: "ck:x" } })).toEqual({
+            id: "ck:x",
+            value: undefined,
+        });
+    });
+});

package/dist/listener.d.ts

@@ -0,0 +1,26 @@
+import type { Server } from "node:http";
+import type { CloudAdapter, TurnContext } from "@microsoft/agents-hosting";
+export interface TeamsServerConfig {
+    adapter: CloudAdapter;
+    port: number;
+    /**
+     * Invoked for every inbound activity, inside the adapter's turn (so
+     * `context.sendActivity` replies on the originating request). Throwing here
+     * is surfaced through the adapter's `onTurnError`.
+     */
+    onTurnContext: (context: TurnContext) => Promise<void>;
+}
+export interface TeamsServer {
+    start(): Promise<Server>;
+    stop(): Promise<void>;
+}
+/**
+ * Stand up the bot's `POST /api/messages` endpoint.
+ *
+ * The M365 Agents Playground (and Azure Bot Service) deliver activities here as
+ * JSON; `CloudAdapter.process` authenticates the request (anonymous in local
+ * Playground mode), builds the `TurnContext`, runs the middleware pipeline, and
+ * writes the HTTP response once `onTurnContext` resolves.
+ */
+export declare function createTeamsServer(config: TeamsServerConfig): TeamsServer;
+//# sourceMappingURL=listener.d.ts.map

package/dist/listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../src/listener.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EAEZ,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,YAAY,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,aAAa,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,WAAW,CAmDxE"}

package/dist/listener.js

@@ -0,0 +1,55 @@
+import express from "express";
+/**
+ * Stand up the bot's `POST /api/messages` endpoint.
+ *
+ * The M365 Agents Playground (and Azure Bot Service) deliver activities here as
+ * JSON; `CloudAdapter.process` authenticates the request (anonymous in local
+ * Playground mode), builds the `TurnContext`, runs the middleware pipeline, and
+ * writes the HTTP response once `onTurnContext` resolves.
+ */
+export function createTeamsServer(config) {
+    const app = express();
+    app.use(express.json());
+    app.post("/api/messages", (req, res) => {
+        config.adapter
+            .process(
+        // Cast across HTTP-layer types: the M365 SDK types `process` against its
+        // own `express` types, which can differ in major (and `Response` generic
+        // arity) from the one resolved here. Express's req/res satisfy the SDK's
+        // structural Request/Response at runtime regardless.
+        req, res, async (context) => {
+            await config.onTurnContext(context);
+        })
+            // A failed turn (e.g. an auth error talking to the Bot Connector) must
+            // not become an unhandled rejection, which crashes the whole Node
+            // process and takes every other conversation down with it. Contain it:
+            // log, and make sure the inbound request still gets a response so the
+            // channel doesn't hang.
+            .catch((err) => {
+            console.error("[bot-teams] POST /api/messages failed:", err);
+            if (!res.headersSent)
+                res.status(500).end();
+        });
+    });
+    // A trivial liveness probe, handy when running behind a tunnel.
+    app.get("/healthz", (_req, res) => {
+        res.status(200).send("ok");
+    });
+    let server;
+    return {
+        start() {
+            return new Promise((resolve) => {
+                server = app.listen(config.port, () => resolve(server));
+            });
+        },
+        stop() {
+            return new Promise((resolve, reject) => {
+                if (!server) {
+                    resolve();
+                    return;
+                }
+                server.close((err) => (err ? reject(err) : resolve()));
+            });
+        },
+    };
+}

package/dist/listener.test.d.ts

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

package/dist/listener.test.d.ts.map

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

package/dist/listener.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from "vitest";
+import { createTeamsServer } from "./listener.js";
+/**
+ * Regression coverage for the crash-resilience fix: a failed turn (e.g. a Bot
+ * Connector 401) must be contained, not become an unhandled rejection that
+ * crashes the whole process. The handler `.catch`es and 500s instead.
+ */
+describe("createTeamsServer", () => {
+    async function listen(adapter) {
+        const server = createTeamsServer({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            adapter: adapter,
+            port: 0,
+            onTurnContext: async () => { },
+        });
+        const httpServer = await server.start();
+        const { port } = httpServer.address();
+        return { server, port };
+    }
+    it("contains a rejecting adapter.process and responds 500 (no crash)", async () => {
+        const process = vi
+            .fn()
+            .mockRejectedValue(new Error("Unknown error type: 401 denied"));
+        const { server, port } = await listen({ process });
+        const res = await fetch(`http://127.0.0.1:${port}/api/messages`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ type: "message", text: "hi" }),
+        });
+        // Pre-fix this request hung forever (the rejection was `void`ed and `res`
+        // was never written); now it is caught and answered.
+        expect(res.status).toBe(500);
+        expect(process).toHaveBeenCalledTimes(1);
+        await server.stop();
+    });
+    it("serves the /healthz liveness probe", async () => {
+        const { server, port } = await listen({ process: vi.fn() });
+        const res = await fetch(`http://127.0.0.1:${port}/healthz`);
+        expect(res.status).toBe(200);
+        expect(await res.text()).toBe("ok");
+        await server.stop();
+    });
+});

package/dist/message-stream.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Per-Teams-message streamed-by-edit state machine.
+ *
+ * Teams' baseline streaming model (the one the M365 Agents Playground and the
+ * Bot Framework connector support without native token streaming) is
+ * **post-then-edit**: send one message activity, then `updateActivity` it as the
+ * text grows. This wraps a single such message and lets a caller feed it the
+ * growing buffer of a streaming reply.
+ *
+ * Edits are throttled (Teams rate-limits activity updates) and *serialised*
+ * through a per-message promise queue so an in-flight edit of "AL" can't be
+ * overtaken by a later edit of "ALPHA" and leave the message reading "AL".
+ *
+ * Nothing here knows about AG-UI or the M365 SDK. It's a pure primitive:
+ * "give me text, I'll keep one Teams message in sync with it." The caller
+ * supplies `post` (first send, returns the activity id), `update` (subsequent
+ * edits), and an optional `typing` hook fired once before the first post.
+ */
+export interface TeamsMessageStreamConfig {
+    /** First send. Returns the posted activity id (used for later edits). */
+    post: (text: string) => Promise<string>;
+    /** Edit the posted activity to `text`. */
+    update: (id: string, text: string) => Promise<void>;
+    /** Optional: fire a typing indicator once, before the first post. */
+    typing?: () => Promise<void>;
+    /** Minimum gap between consecutive flushes, in ms (defaults to 700). */
+    minIntervalMs?: number;
+}
+export declare class TeamsMessageStream {
+    private buffer;
+    private posted;
+    private id;
+    private queue;
+    private lastFlushedAt;
+    private flushTimer;
+    private readonly minIntervalMs;
+    private readonly config;
+    constructor(config: TeamsMessageStreamConfig);
+    /** Replace the in-flight buffer (callers pass the accumulated text). */
+    append(text: string): void;
+    /**
+     * Mark the stream done: cancel any pending throttled flush, enqueue a final
+     * flush, and resolve once the whole queue has drained. The posted activity
+     * then reflects the final buffer. Returns the activity id (or `undefined` if
+     * nothing was ever posted, e.g. an empty stream).
+     */
+    finish(): Promise<string | undefined>;
+    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;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,wBAAwB;IACvC,yEAAyE;IACzE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,0CAA0C;IAC1C,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,wEAAwE;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,EAAE,CAAqB;IAC/B,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAA4C;IAC9D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;gBAEtC,MAAM,EAAE,wBAAwB;IAK5C,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM1B;;;;;OAKG;IACG,MAAM,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAU3C,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,YAAY;YAIN,QAAQ;CAsBvB"}

package/dist/message-stream.js

@@ -0,0 +1,78 @@
+const DEFAULT_MIN_INTERVAL_MS = 700;
+export class TeamsMessageStream {
+    buffer = "";
+    posted = "";
+    id;
+    queue = Promise.resolve();
+    lastFlushedAt = 0;
+    flushTimer;
+    minIntervalMs;
+    config;
+    constructor(config) {
+        this.config = config;
+        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: cancel any pending throttled flush, enqueue a final
+     * flush, and resolve once the whole queue has drained. The posted activity
+     * then reflects the final buffer. Returns the activity id (or `undefined` if
+     * nothing was ever posted, e.g. an empty stream).
+     */
+    async finish() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        this.enqueueFlush();
+        await this.queue;
+        return this.id;
+    }
+    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() {
+        const text = this.buffer;
+        if (text === this.posted)
+            return;
+        // Don't post an empty first message; wait for real content.
+        if (this.id === undefined && text.trim().length === 0)
+            return;
+        this.posted = text;
+        try {
+            if (this.id === undefined) {
+                if (this.config.typing)
+                    await this.config.typing();
+                this.id = await this.config.post(text);
+            }
+            else {
+                await this.config.update(this.id, text);
+            }
+        }
+        catch (err) {
+            // A single failed edit shouldn't sink the stream; reset `posted` so the
+            // next flush retries with the latest buffer.
+            this.posted = "";
+            console.error("[teams-message-stream] flush failed:", err);
+        }
+        finally {
+            this.lastFlushedAt = Date.now();
+        }
+    }
+}

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

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

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

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

package/dist/message-stream.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi } from "vitest";
+import { TeamsMessageStream } from "./message-stream.js";
+describe("TeamsMessageStream", () => {
+    it("posts once with the final text for a single synchronous burst", async () => {
+        const post = vi.fn(async () => "act-1");
+        const update = vi.fn(async () => { });
+        const typing = vi.fn(async () => { });
+        const s = new TeamsMessageStream({ post, update, typing });
+        s.append("Hello");
+        s.append("Hello world");
+        const id = await s.finish();
+        expect(id).toBe("act-1");
+        expect(post).toHaveBeenCalledTimes(1);
+        expect(post).toHaveBeenCalledWith("Hello world");
+        expect(update).not.toHaveBeenCalled();
+        expect(typing).toHaveBeenCalledTimes(1);
+    });
+    it("never posts for an empty stream", async () => {
+        const post = vi.fn(async () => "x");
+        const update = vi.fn(async () => { });
+        const s = new TeamsMessageStream({ post, update });
+        const id = await s.finish();
+        expect(id).toBeUndefined();
+        expect(post).not.toHaveBeenCalled();
+    });
+    it("posts first, then edits the same message as the buffer grows", async () => {
+        vi.useFakeTimers();
+        try {
+            const post = vi.fn(async () => "act-1");
+            const update = vi.fn(async () => { });
+            const s = new TeamsMessageStream({ post, update, minIntervalMs: 100 });
+            s.append("A");
+            await vi.advanceTimersByTimeAsync(150); // let the throttled flush fire
+            expect(post).toHaveBeenCalledWith("A");
+            s.append("AB");
+            const id = await s.finish();
+            expect(id).toBe("act-1");
+            expect(update).toHaveBeenCalledWith("act-1", "AB");
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});

package/dist/render/adaptive-card.d.ts

@@ -0,0 +1,43 @@
+import type { BotNode } from "@copilotkit/channels-ui";
+/** Teams attachment content type for an Adaptive Card. */
+export declare const ADAPTIVE_CARD_CONTENT_TYPE = "application/vnd.microsoft.card.adaptive";
+/** A minimally-typed Adaptive Card (1.5). Elements/actions are open bags: the
+ *  schema is large and we only emit a curated subset. */
+export interface AdaptiveCard {
+    type: "AdaptiveCard";
+    $schema: string;
+    version: string;
+    body: CardElement[];
+    actions?: CardAction[];
+}
+type CardElement = Record<string, unknown>;
+type CardAction = Record<string, unknown>;
+/**
+ * Render a cross-platform component IR tree (already expanded by `renderToIR`
+ * and pre-bound by the action registry, so event props are `{ id }`) into a
+ * Teams **Adaptive Card** (1.5).
+ *
+ * Structural nodes map to body elements (`<Header>`→bold `TextBlock`,
+ * `<Section>`/`<Markdown>`→wrapped `TextBlock`, `<Fields>`→`FactSet`,
+ * `<Table>`→native `Table`, `<Image>`→`Image`). Interactive nodes split by
+ * Adaptive Card shape: `<Button>`→a top-level `Action.Submit` (per the V1
+ * decision to use `Action.Submit`), while `<Input>`/`<Select>` become
+ * `Input.Text`/`Input.ChoiceSet` in the body. Each action/input carries the
+ * registry-stamped opaque id in its `data`/`id` so a later interaction can be
+ * decoded back into the engine (round-trip is a follow-up; rendering is here).
+ *
+ * The renderer is total: unknown intrinsics are skipped. Collections clamp and
+ * text truncates to {@link TEAMS_LIMITS} so the card stays within Teams' payload
+ * ceiling.
+ */
+export declare function renderAdaptiveCard(ir: BotNode[]): AdaptiveCard;
+/**
+ * Does this IR collapse to plain text (no structural or interactive elements)?
+ * Such replies are sent as a normal Teams text activity rather than wrapped in
+ * an Adaptive Card. A bare `Echo: hi` shouldn't render as a card.
+ */
+export declare function isPlainText(ir: BotNode[]): boolean;
+/** Plain-text projection of an IR tree (depth-first text, blocks joined). */
+export declare function collectPlainText(ir: BotNode[]): string;
+export {};
+//# sourceMappingURL=adaptive-card.d.ts.map

package/dist/render/adaptive-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-card.d.ts","sourceRoot":"","sources":["../../src/render/adaptive-card.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAGvD,0DAA0D;AAC1D,eAAO,MAAM,0BAA0B,4CACI,CAAC;AAE5C;yDACyD;AACzD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB;AACD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAC3C,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAK1C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,YAAY,CAc9D;AAsVD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,OAAO,CAsBlD;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,MAAM,CAMtD"}