@copilotkit/channels-teams 0.1.0

package/dist/render/auto-close.js

@@ -0,0 +1,153 @@
+/**
+ * Streaming-polish layer for Teams' post-then-edit streaming.
+ *
+ * While an agent is mid-stream the buffer is usually an *unfinished* markdown
+ * document: an open code fence, an unclosed `**`, etc. Teams renders message
+ * text as markdown, so editing the message with unbalanced text makes the rest
+ * of the bubble render broken (a stray ``` turns the remainder into a code
+ * block until the closer arrives, a dangling `**` bolds the rest, and so on).
+ *
+ * `autoCloseOpenMarkdown` returns a balanced copy of the buffer by appending the
+ * minimum set of closers needed for well-formed display. When the agent later
+ * emits the real closer the buffer balances on its own and this adds nothing,
+ * so the *committed* (finalized) message has no synthetic closers.
+ *
+ * Handled, in priority order:
+ *   1. Unclosed fenced code blocks ``` (most severe: leaks code styling)
+ *   2. Unclosed inline code
+ *   3. Unclosed bold `**` / `__`, italic `*` / `_`, strike `~~`
+ *
+ * Heuristics:
+ *   - A marker with no content after it (trailing `**`) is NOT closed. The
+ *     agent may just be opening it; closing would flash a transient `****`.
+ *   - Markers inside code/fence regions don't count.
+ *   - Closers are emitted innermost-first so the structure nests correctly.
+ */
+// Private-use codepoints that will never appear in agent markdown, used to
+// stash already-balanced regions while we scan for the dangling opener.
+const SENTINEL_FENCE = "\uE000";
+const SENTINEL_INLINE = "\uE001";
+export function autoCloseOpenMarkdown(text) {
+    if (!text)
+        return text;
+    // ── 1. Fenced code blocks ──────────────────────────────────────────
+    const fences = [];
+    let work = text.replace(/```[\s\S]*?```/g, (m) => {
+        fences.push(m);
+        return `${SENTINEL_FENCE}${fences.length - 1}${SENTINEL_FENCE}`;
+    });
+    const openFenceIdx = work.indexOf("```");
+    let openFenceTail = "";
+    if (openFenceIdx >= 0) {
+        openFenceTail = work.slice(openFenceIdx);
+        work = work.slice(0, openFenceIdx);
+    }
+    // ── 2. Inline code regions ─────────────────────────────────────────
+    const inlines = [];
+    work = work.replace(/`[^`\n]+`/g, (m) => {
+        inlines.push(m);
+        return `${SENTINEL_INLINE}${inlines.length - 1}${SENTINEL_INLINE}`;
+    });
+    const openBacktickIdx = work.indexOf("`");
+    let openBacktickTail = "";
+    if (openBacktickIdx >= 0) {
+        openBacktickTail = work.slice(openBacktickIdx);
+        work = work.slice(0, openBacktickIdx);
+    }
+    // ── 3. Bold / italic / strike via stack scan ──────────────────────
+    const stack = scanBracketStack(work);
+    const closers = stack.slice().toReversed().join("");
+    // ── 4. Reassemble ─────────────────────────────────────────────────
+    // Insert closers BEFORE trailing whitespace so "**bold " → "**bold**".
+    let output = work;
+    if (closers) {
+        const trail = output.match(/\s*$/)?.[0] ?? "";
+        output = output.slice(0, output.length - trail.length) + closers + trail;
+    }
+    if (openBacktickTail) {
+        output += openBacktickTail;
+        if (hasContentAfterMarker(openBacktickTail, "`"))
+            output += "`";
+    }
+    output = output.replace(new RegExp(`${SENTINEL_INLINE}(\\d+)${SENTINEL_INLINE}`, "g"), (_, idx) => inlines[Number(idx)] ?? "");
+    if (openFenceTail) {
+        output += openFenceTail;
+        if (hasFenceCodeContent(openFenceTail)) {
+            output += openFenceTail.endsWith("\n") ? "```" : "\n```";
+        }
+    }
+    output = output.replace(new RegExp(`${SENTINEL_FENCE}(\\d+)${SENTINEL_FENCE}`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+    return output;
+}
+/**
+ * Walk `text` and return the unbalanced bracket stack. Recognises (longest
+ * first) `**`, `__`, `~~`, then `*`, `_`, so `**` is one bold marker, not two
+ * italics. A trailing marker with no content after it is dropped (closing it
+ * would flash a transient `****`).
+ */
+function scanBracketStack(text) {
+    const stack = [];
+    const tryToggle = (m) => {
+        if (stack[stack.length - 1] === m)
+            stack.pop();
+        else
+            stack.push(m);
+    };
+    let i = 0;
+    while (i < text.length) {
+        if (text.startsWith("**", i)) {
+            tryToggle("**");
+            i += 2;
+        }
+        else if (text.startsWith("__", i)) {
+            tryToggle("__");
+            i += 2;
+        }
+        else if (text.startsWith("~~", i)) {
+            tryToggle("~~");
+            i += 2;
+        }
+        else if (text[i] === "*") {
+            tryToggle("*");
+            i += 1;
+        }
+        else if (text[i] === "_") {
+            tryToggle("_");
+            i += 1;
+        }
+        else {
+            i += 1;
+        }
+    }
+    while (stack.length > 0) {
+        const last = stack[stack.length - 1];
+        const lastIdx = text.lastIndexOf(last);
+        if (lastIdx < 0)
+            break;
+        const after = text.slice(lastIdx + last.length);
+        if (/^\s*$/.test(after))
+            stack.pop();
+        else
+            break;
+    }
+    return stack;
+}
+function hasContentAfterMarker(tail, marker) {
+    if (!tail.startsWith(marker))
+        return false;
+    return /\S/.test(tail.slice(marker.length));
+}
+/**
+ * True if a ```` ```<lang>?\n<content> ```` buffer has actual code past the
+ * optional language line (the first newline separates the language tag from the
+ * code body). A buffer still on the language line has nothing to close yet.
+ */
+function hasFenceCodeContent(tail) {
+    if (!tail.startsWith("```"))
+        return false;
+    const after = tail.slice(3);
+    const nl = after.indexOf("\n");
+    if (nl < 0)
+        return false;
+    return /\S/.test(after.slice(nl + 1));
+}

package/dist/render/auto-close.test.d.ts

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

package/dist/render/auto-close.test.d.ts.map

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

package/dist/render/auto-close.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { autoCloseOpenMarkdown as ac } from "./auto-close.js";
+describe("autoCloseOpenMarkdown", () => {
+    it("leaves empty and already-balanced text untouched (no synthetic closers)", () => {
+        expect(ac("")).toBe("");
+        expect(ac("plain text")).toBe("plain text");
+        expect(ac("**bold** and _italic_")).toBe("**bold** and _italic_");
+        expect(ac("```js\nconst x = 1;\n```")).toBe("```js\nconst x = 1;\n```");
+    });
+    it("closes an unclosed bold/italic/strike that has content", () => {
+        expect(ac("**bold")).toBe("**bold**");
+        expect(ac("_italic")).toBe("_italic_");
+        expect(ac("~~strike")).toBe("~~strike~~");
+    });
+    it("closes nested markers innermost-first", () => {
+        expect(ac("**bold _italic")).toBe("**bold _italic_**");
+    });
+    it("inserts closers before trailing whitespace", () => {
+        expect(ac("**bold ")).toBe("**bold** ");
+    });
+    it("does NOT close a marker with no content after it (avoids transient ****)", () => {
+        expect(ac("hello **")).toBe("hello **");
+        expect(ac("text _")).toBe("text _");
+    });
+    it("closes an open inline code span with content, but not a bare opener", () => {
+        expect(ac("run `npm test")).toBe("run `npm test`");
+        expect(ac("a paired `span` then more")).toBe("a paired `span` then more");
+    });
+    it("closes an open fence only once there's code past the language line", () => {
+        expect(ac("```js")).toBe("```js"); // still on the language line
+        expect(ac("```js\n")).toBe("```js\n"); // language line, no code yet
+        expect(ac("```js\nconst x = 1;")).toBe("```js\nconst x = 1;\n```");
+        expect(ac("```\nplain code")).toBe("```\nplain code\n```");
+    });
+    it("does not corrupt digits adjacent to balanced regions (sentinel safety)", () => {
+        // Regression guard: the placeholder sentinels must be real PUA codepoints,
+        // not empty strings, otherwise the restore regex would eat bare digits.
+        expect(ac("```\ncode\n```\n12345 items")).toBe("```\ncode\n```\n12345 items");
+        expect(ac("see `x` then 2024 and 99")).toBe("see `x` then 2024 and 99");
+    });
+    it("is idempotent once the real closer arrives", () => {
+        // mid-stream we'd have closed it; the finalized balanced text adds nothing.
+        expect(ac("**done**")).toBe("**done**");
+        expect(ac(ac("**partial"))).toBe(ac("**partial"));
+    });
+});

package/dist/render/budget.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Adaptive Card payload limits for Teams.
+ *
+ * Teams caps an Adaptive Card attachment at ~28 KB of JSON and renders only a
+ * handful of top-level actions comfortably. These ceilings keep a rendered card
+ * inside those bounds; the renderer clamps collections and truncates text to
+ * them rather than emitting an oversized card Teams would reject.
+ */
+export declare const TEAMS_LIMITS: {
+    /** Top-level body elements (TextBlocks, FactSets, Tables, etc.) per card. */
+    readonly bodyElements: 100;
+    /** Top-level `Action.Submit`s. Teams shows ~6 before overflowing. */
+    readonly actions: 6;
+    /** Characters of text in a single TextBlock. */
+    readonly textBlock: 12000;
+    readonly factTitle: 200;
+    readonly factValue: 2000;
+    readonly factsPerSet: 50;
+    readonly buttonText: 256;
+    readonly tableColumns: 12;
+    readonly tableRows: 100;
+    readonly cellText: 2000;
+    readonly choices: 100;
+    readonly choiceLabel: 256;
+    /** Data points (categories / slices) in a single chart. */
+    readonly chartDataPoints: 50;
+    /** Characters of a chart title or a data point's label. */
+    readonly chartTitle: 200;
+    readonly chartLabel: 200;
+};
+/** Truncate to `max` chars, appending an ellipsis if the input was longer. Never returns >max. */
+export declare function truncateText(text: string, max: number): string;
+/** Clamp an array to `max` items; return the kept items plus how many overflowed. */
+export declare function clampArray<T>(items: readonly T[], max: number): {
+    items: T[];
+    overflow: number;
+};
+//# sourceMappingURL=budget.d.ts.map

package/dist/render/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/render/budget.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;IACvB,6EAA6E;;IAE7E,qEAAqE;;IAErE,gDAAgD;;;;;;;;;;;IAWhD,2DAA2D;;IAE3D,2DAA2D;;;CAGnD,CAAC;AAEX,kGAAkG;AAClG,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAI9D;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,GAAG,EAAE,MAAM,GACV;IAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAGlC"}

package/dist/render/budget.js

@@ -0,0 +1,44 @@
+/**
+ * Adaptive Card payload limits for Teams.
+ *
+ * Teams caps an Adaptive Card attachment at ~28 KB of JSON and renders only a
+ * handful of top-level actions comfortably. These ceilings keep a rendered card
+ * inside those bounds; the renderer clamps collections and truncates text to
+ * them rather than emitting an oversized card Teams would reject.
+ */
+export const TEAMS_LIMITS = {
+    /** Top-level body elements (TextBlocks, FactSets, Tables, etc.) per card. */
+    bodyElements: 100,
+    /** Top-level `Action.Submit`s. Teams shows ~6 before overflowing. */
+    actions: 6,
+    /** Characters of text in a single TextBlock. */
+    textBlock: 12000,
+    factTitle: 200,
+    factValue: 2000,
+    factsPerSet: 50,
+    buttonText: 256,
+    tableColumns: 12,
+    tableRows: 100,
+    cellText: 2000,
+    choices: 100,
+    choiceLabel: 256,
+    /** Data points (categories / slices) in a single chart. */
+    chartDataPoints: 50,
+    /** Characters of a chart title or a data point's label. */
+    chartTitle: 200,
+    chartLabel: 200,
+};
+/** Truncate to `max` chars, appending an ellipsis if the input was longer. Never returns >max. */
+export function truncateText(text, max) {
+    if (text.length <= max)
+        return text;
+    if (max <= 1)
+        return text.slice(0, max);
+    return text.slice(0, max - 1) + "…";
+}
+/** Clamp an array to `max` items; return the kept items plus how many overflowed. */
+export function clampArray(items, max) {
+    if (items.length <= max)
+        return { items: [...items], overflow: 0 };
+    return { items: items.slice(0, max), overflow: items.length - max };
+}

package/dist/render/budget.test.d.ts

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

package/dist/render/budget.test.d.ts.map

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

package/dist/render/budget.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { truncateText, clampArray, TEAMS_LIMITS } from "./budget.js";
+describe("truncateText", () => {
+    it("leaves short text unchanged", () => {
+        expect(truncateText("hi", 10)).toBe("hi");
+    });
+    it("truncates with an ellipsis and never exceeds max", () => {
+        const out = truncateText("abcdef", 4);
+        expect(out).toBe("abc…");
+        expect(out.length).toBe(4);
+    });
+});
+describe("clampArray", () => {
+    it("keeps everything under the cap", () => {
+        expect(clampArray([1, 2], 5)).toEqual({ items: [1, 2], overflow: 0 });
+    });
+    it("clamps and reports overflow", () => {
+        expect(clampArray([1, 2, 3, 4], 2)).toEqual({ items: [1, 2], overflow: 2 });
+    });
+});
+describe("TEAMS_LIMITS", () => {
+    it("caps top-level actions to a Teams-friendly count", () => {
+        expect(TEAMS_LIMITS.actions).toBe(6);
+    });
+});

package/dist/render/markdown.d.ts

@@ -0,0 +1,13 @@
+import type { BotNode } from "@copilotkit/channels-ui";
+/**
+ * Render the bot-ui IR tree to a Teams message string.
+ *
+ * Teams message activities render Markdown, so the structural vocabulary maps
+ * cleanly onto it: a `<Header>` becomes a bold line, `<Section>`/`<Markdown>`
+ * pass their text through, `<Divider>` becomes a rule, and so on. This is the
+ * thin, text-first renderer that covers plain replies and the common card
+ * shapes; richer interactive surfaces (buttons, inputs) will render to
+ * Adaptive Cards in a follow-up (see the package README).
+ */
+export declare function renderTeamsMarkdown(ir: BotNode[]): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/render/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/render/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,MAAM,CAMzD"}

package/dist/render/markdown.js

@@ -0,0 +1,121 @@
+/**
+ * Render the bot-ui IR tree to a Teams message string.
+ *
+ * Teams message activities render Markdown, so the structural vocabulary maps
+ * cleanly onto it: a `<Header>` becomes a bold line, `<Section>`/`<Markdown>`
+ * pass their text through, `<Divider>` becomes a rule, and so on. This is the
+ * thin, text-first renderer that covers plain replies and the common card
+ * shapes; richer interactive surfaces (buttons, inputs) will render to
+ * Adaptive Cards in a follow-up (see the package README).
+ */
+export function renderTeamsMarkdown(ir) {
+    return ir
+        .map((node) => renderNode(node))
+        .filter((s) => s.length > 0)
+        .join("\n\n")
+        .trim();
+}
+function renderNode(node) {
+    if (typeof node.type !== "string") {
+        // Components are expanded to intrinsic nodes before render(); a stray
+        // function/symbol node carries no renderable text.
+        return collectText(node);
+    }
+    switch (node.type) {
+        case "text":
+            return String(node.props.value ?? "");
+        case "header":
+            return `**${collectText(node)}**`;
+        case "divider":
+            return "---";
+        case "context":
+            // Supplementary, lower-emphasis text.
+            return collectText(node)
+                .split("\n")
+                .map((line) => (line ? `_${line}_` : line))
+                .join("\n");
+        case "field":
+            return collectText(node);
+        case "fields":
+            return childNodes(node)
+                .map((c) => renderNode(c))
+                .filter(Boolean)
+                .join("\n");
+        case "button":
+            // No interactive surface yet, so render the label so the intent is visible.
+            return `\`${collectText(node)}\``;
+        case "table":
+            return renderTable(node);
+        case "message":
+        case "section":
+        case "markdown":
+        case "actions":
+        default:
+            // Containers and unknown nodes: render children, falling back to any
+            // direct text.
+            return renderChildren(node) || collectText(node);
+    }
+}
+/**
+ * Markdown-table fallback for `<Table>` (the Adaptive Card renderer emits a
+ * native Table; this is the text-surface fallback). Teams renders GFM pipe
+ * tables in message text.
+ */
+function renderTable(node) {
+    const columns = node.props?.columns;
+    const rowNodes = childNodes(node).filter((c) => c.type === "row");
+    const dataRows = rowNodes.map((r) => childNodes(r)
+        .filter((c) => c.type === "cell")
+        .map((c) => collectText(c).replace(/\|/g, "\\|")));
+    const width = columns?.length ?? dataRows.reduce((m, r) => Math.max(m, r.length), 0);
+    if (width === 0)
+        return "";
+    const headers = columns
+        ? columns.map((c) => c.header)
+        : Array.from({ length: width }, () => " ");
+    const sep = (columns ?? Array.from({ length: width })).map((c) => {
+        const align = c?.align;
+        if (align === "center")
+            return ":---:";
+        if (align === "right")
+            return "---:";
+        return "---";
+    });
+    const line = (cells) => `| ${Array.from({ length: width }, (_, i) => cells[i] ?? "").join(" | ")} |`;
+    return [line(headers), `| ${sep.join(" | ")} |`, ...dataRows.map(line)].join("\n");
+}
+function renderChildren(node) {
+    const kids = childNodes(node);
+    if (kids.length === 0)
+        return "";
+    return kids
+        .map((c) => renderNode(c))
+        .filter((s) => s.length > 0)
+        .join("\n\n");
+}
+/** Normalize a node's `children` prop to an array of child nodes. */
+function childNodes(node) {
+    const children = node.props?.children;
+    if (Array.isArray(children))
+        return children;
+    if (children && typeof children === "object" && "type" in children) {
+        return [children];
+    }
+    return [];
+}
+/** Depth-first collection of a node's descendant text. */
+function collectText(node) {
+    const out = [];
+    const visit = (n) => {
+        if (typeof n.type === "string" && n.type === "text") {
+            const value = n.props?.value;
+            if (value != null)
+                out.push(String(value));
+            return;
+        }
+        for (const child of childNodes(n))
+            visit(child);
+    };
+    visit(node);
+    return out.join(" ").replace(/\s+/g, " ").trim();
+}

package/dist/render/markdown.test.d.ts

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

package/dist/render/markdown.test.d.ts.map

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

package/dist/render/markdown.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { renderTeamsMarkdown } from "./markdown.js";
+const text = (value) => ({ type: "text", props: { value } });
+describe("renderTeamsMarkdown", () => {
+    it("renders a bare text node", () => {
+        expect(renderTeamsMarkdown([text("Echo: hi")])).toBe("Echo: hi");
+    });
+    it("renders a header as bold", () => {
+        const ir = [
+            { type: "header", props: { children: [text("Title")] } },
+        ];
+        expect(renderTeamsMarkdown(ir)).toBe("**Title**");
+    });
+    it("renders a divider as a rule", () => {
+        expect(renderTeamsMarkdown([{ type: "divider", props: {} }])).toBe("---");
+    });
+    it("joins a message container's children with blank lines", () => {
+        const ir = [
+            {
+                type: "message",
+                props: {
+                    children: [
+                        { type: "header", props: { children: [text("Status")] } },
+                        { type: "section", props: { children: [text("All good.")] } },
+                    ],
+                },
+            },
+        ];
+        expect(renderTeamsMarkdown(ir)).toBe("**Status**\n\nAll good.");
+    });
+    it("renders context children as emphasized lines", () => {
+        const ir = [
+            { type: "context", props: { children: [text("fyi")] } },
+        ];
+        expect(renderTeamsMarkdown(ir)).toBe("_fyi_");
+    });
+    it("returns an empty string for an empty tree", () => {
+        expect(renderTeamsMarkdown([])).toBe("");
+    });
+    it("renders a <Table> as a GFM pipe-table fallback", () => {
+        const cell = (v) => ({
+            type: "cell",
+            props: { children: [text(v)] },
+        });
+        const ir = [
+            {
+                type: "table",
+                props: {
+                    columns: [{ header: "Name" }, { header: "Count", align: "right" }],
+                    children: [
+                        { type: "row", props: { children: [cell("Bugs"), cell("3")] } },
+                    ],
+                },
+            },
+        ];
+        expect(renderTeamsMarkdown(ir)).toBe("| Name | Count |\n| --- | ---: |\n| Bugs | 3 |");
+    });
+});

package/dist/sanitizing-http-agent.d.ts

@@ -0,0 +1,35 @@
+import { HttpAgent } from "@ag-ui/client";
+import type { BaseEvent, RunAgentInput } from "@ag-ui/core";
+import type { Observable } from "rxjs";
+/**
+ * An `HttpAgent` that tolerates the AG-UI event streams real agents emit.
+ *
+ * `@ag-ui/client`'s stock transform re-validates every streamed event against a
+ * strict Zod schema. Some events that `@ag-ui/langgraph` legitimately emits fail
+ * it (notably a `TOOL_CALL_START` whose `parentMessageId` is `null`: "Expected
+ * string, received null"), and a single rejected event aborts the entire run.
+ * That breaks LangGraph interrupts / human-in-the-loop on Teams, where the tool
+ * call that triggers the interrupt carries exactly that shape.
+ *
+ * The bridge talks to a trusted runtime, so rather than re-validate its output
+ * we use the same SSE parse the stock path wraps (`parseSSEStream`) and coerce
+ * the known nullable-string fields. This deliberately drops the stock
+ * transform's *entire* strict Zod re-validation step (not just the offending
+ * field). This is acceptable only because the runtime is trusted and `runHttpRequest`
+ * still throws on transport/HTTP errors. The first coercion logs a one-time
+ * breadcrumb so the workaround is visible in production. Revert to the stock
+ * transform (`transformHttpEventStream`) once upstream makes the fields
+ * nullable.
+ *
+ * Use it in place of `HttpAgent` when pointing the Teams bot at a LangGraph
+ * (or other AG-UI) agent:
+ *
+ * ```ts
+ * import { SanitizingHttpAgent } from "@copilotkit/channels-teams";
+ * const agent = new SanitizingHttpAgent({ url: process.env.AGENT_URL! });
+ * ```
+ */
+export declare class SanitizingHttpAgent extends HttpAgent {
+    run(input: RunAgentInput): Observable<BaseEvent>;
+}
+//# sourceMappingURL=sanitizing-http-agent.d.ts.map

package/dist/sanitizing-http-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizing-http-agent.d.ts","sourceRoot":"","sources":["../src/sanitizing-http-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkC,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IAChD,GAAG,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC;CAMjD"}

package/dist/sanitizing-http-agent.js

@@ -0,0 +1,58 @@
+import { HttpAgent, parseSSEStream, runHttpRequest } from "@ag-ui/client";
+import { map } from "rxjs";
+/**
+ * An `HttpAgent` that tolerates the AG-UI event streams real agents emit.
+ *
+ * `@ag-ui/client`'s stock transform re-validates every streamed event against a
+ * strict Zod schema. Some events that `@ag-ui/langgraph` legitimately emits fail
+ * it (notably a `TOOL_CALL_START` whose `parentMessageId` is `null`: "Expected
+ * string, received null"), and a single rejected event aborts the entire run.
+ * That breaks LangGraph interrupts / human-in-the-loop on Teams, where the tool
+ * call that triggers the interrupt carries exactly that shape.
+ *
+ * The bridge talks to a trusted runtime, so rather than re-validate its output
+ * we use the same SSE parse the stock path wraps (`parseSSEStream`) and coerce
+ * the known nullable-string fields. This deliberately drops the stock
+ * transform's *entire* strict Zod re-validation step (not just the offending
+ * field). This is acceptable only because the runtime is trusted and `runHttpRequest`
+ * still throws on transport/HTTP errors. The first coercion logs a one-time
+ * breadcrumb so the workaround is visible in production. Revert to the stock
+ * transform (`transformHttpEventStream`) once upstream makes the fields
+ * nullable.
+ *
+ * Use it in place of `HttpAgent` when pointing the Teams bot at a LangGraph
+ * (or other AG-UI) agent:
+ *
+ * ```ts
+ * import { SanitizingHttpAgent } from "@copilotkit/channels-teams";
+ * const agent = new SanitizingHttpAgent({ url: process.env.AGENT_URL! });
+ * ```
+ */
+export class SanitizingHttpAgent extends HttpAgent {
+    run(input) {
+        return parseSSEStream(runHttpRequest(() => this.fetch(this.url, this.requestInit(input))), this.debugLogger).pipe(map((event) => coerceNullStrings(event)));
+    }
+}
+/** One-time breadcrumb so the workaround's use is visible in production. */
+let coercionWarned = false;
+/**
+ * Coerce known nullable-string event fields to `""`. Targeted on purpose: we
+ * only touch fields where a `null` is known to come through from
+ * `@ag-ui/langgraph` and would otherwise trip a downstream string check.
+ */
+function coerceNullStrings(event) {
+    if (!event || typeof event !== "object")
+        return event;
+    const e = event;
+    if (e["parentMessageId"] === null) {
+        e["parentMessageId"] = "";
+        if (!coercionWarned) {
+            coercionWarned = true;
+            console.warn('[SanitizingHttpAgent] coerced a null `parentMessageId` to "" and ' +
+                "bypassed @ag-ui/client strict event re-validation for this stream " +
+                "(known @ag-ui/langgraph quirk). Remove this agent once upstream " +
+                "makes the field nullable.");
+        }
+    }
+    return e;
+}