@copilotkit/channels-teams 0.1.0

package/dist/adapter.test.js

@@ -0,0 +1,202 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ActivityTypes } from "@microsoft/agents-activity";
+import { TeamsAdapter } from "./adapter.js";
+/**
+ * Regression coverage for the card-interaction auth fix.
+ *
+ * Adaptive Card `Action.Submit` clicks used to be handled on the inbound turn
+ * context, whose connector client the M365 SDK builds with an anonymous
+ * identity, so editing the card in place (`updateActivity`) was rejected 401
+ * on real Teams. Credentialed interactions must instead run on the same
+ * app-id-authenticated proactive (`continueConversation`) context as ordinary
+ * replies. In the anonymous local Playground (no app id) the inbound context is
+ * the only one available and is used directly.
+ */
+function cardClickContext() {
+    const activity = {
+        type: ActivityTypes.Message,
+        value: { ckActionId: "ck:abc123", value: { confirmed: true } },
+        conversation: { id: "conv-1" },
+        from: { id: "user-1", name: "Tester" },
+        replyToId: "card-activity-1",
+        getConversationReference: () => ({
+            conversation: { id: "conv-1" },
+            serviceUrl: "https://smba.example/",
+        }),
+    };
+    return { activity };
+}
+function mockSink() {
+    return {
+        onTurn: vi.fn().mockResolvedValue(undefined),
+        onCommand: vi.fn().mockResolvedValue(undefined),
+        onInteraction: vi.fn().mockResolvedValue(undefined),
+    };
+}
+const flush = () => new Promise((r) => setTimeout(r, 0));
+describe("TeamsAdapter card interactions", () => {
+    let prevClientId;
+    beforeEach(() => {
+        prevClientId = process.env.clientId;
+        delete process.env.clientId;
+    });
+    afterEach(() => {
+        if (prevClientId !== undefined)
+            process.env.clientId = prevClientId;
+    });
+    it("routes the interaction through the authenticated proactive context when credentialed", async () => {
+        const adapter = new TeamsAdapter({ clientId: "app-123" });
+        const proactiveCtx = { id: "proactive" };
+        const continueConversation = vi.fn(async (_appId, _ref, cb) => {
+            await cb(proactiveCtx);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        adapter.cloud = { continueConversation };
+        const sink = mockSink();
+        const inbound = cardClickContext();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await adapter.handleActivity(inbound, sink);
+        await flush(); // the interaction runs on a detached proactive context
+        expect(continueConversation).toHaveBeenCalledWith("app-123", expect.anything(), expect.any(Function));
+        expect(sink.onInteraction).toHaveBeenCalledTimes(1);
+        const evt = sink.onInteraction.mock.calls[0][0];
+        expect(evt.id).toBe("ck:abc123");
+        expect(evt.value).toEqual({ confirmed: true });
+        // The reply/edit context must be the proactive one, NOT the (anonymous)
+        // inbound click context. That was the 401 bug.
+        expect(evt.replyTarget.context).toBe(proactiveCtx);
+        expect(evt.messageRef.context).toBe(proactiveCtx);
+        expect(evt.messageRef.id).toBe("card-activity-1");
+    });
+    it("uses the inbound context for interactions in anonymous mode (no app id)", async () => {
+        const adapter = new TeamsAdapter({});
+        const continueConversation = vi.fn();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        adapter.cloud = { continueConversation };
+        const sink = mockSink();
+        const inbound = cardClickContext();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await adapter.handleActivity(inbound, sink);
+        await flush();
+        expect(continueConversation).not.toHaveBeenCalled();
+        expect(sink.onInteraction).toHaveBeenCalledTimes(1);
+        const evt = sink.onInteraction.mock.calls[0][0];
+        expect(evt.replyTarget.context).toBe(inbound);
+        expect(evt.messageRef.context).toBe(inbound);
+    });
+});
+/** A plain inbound message activity carrying optional file attachments. */
+function messageContext(text, attachments) {
+    const activity = {
+        type: ActivityTypes.Message,
+        text,
+        attachments,
+        conversation: { id: "conv-1" },
+        from: { id: "user-1", name: "Sam" },
+        removeRecipientMention: () => text,
+        getConversationReference: () => ({
+            conversation: { id: "conv-1" },
+            serviceUrl: "https://smba.example/",
+        }),
+    };
+    return { activity };
+}
+describe("TeamsAdapter inbound files", () => {
+    const prevClientId = process.env.clientId;
+    beforeEach(() => delete process.env.clientId);
+    afterEach(() => {
+        if (prevClientId !== undefined)
+            process.env.clientId = prevClientId;
+    });
+    it("delivers an uploaded CSV to the agent as a content part on the turn", async () => {
+        const adapter = new TeamsAdapter({});
+        const sink = mockSink();
+        const csv = Buffer.from("month,sev1\nJan,3\nFeb,5\n").toString("base64");
+        const ctx = messageContext("chart this", [
+            {
+                contentType: "text/csv",
+                name: "incidents.csv",
+                contentUrl: `data:text/csv;base64,${csv}`,
+            },
+        ]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await adapter.handleActivity(ctx, sink);
+        await flush();
+        expect(sink.onTurn).toHaveBeenCalledTimes(1);
+        const turn = sink.onTurn.mock.calls[0][0];
+        expect(turn.userText).toBe("chart this");
+        expect(turn.contentParts).toBeDefined();
+        // Leads with the user's text, then the decoded CSV as a text part.
+        expect(turn.contentParts[0]).toEqual({ type: "text", text: "chart this" });
+        const csvPart = turn.contentParts[1];
+        expect(csvPart.type).toBe("text");
+        expect(csvPart.text).toContain("month,sev1");
+    });
+    it("leaves contentParts undefined when there are no attachments", async () => {
+        const adapter = new TeamsAdapter({});
+        const sink = mockSink();
+        const ctx = messageContext("hi");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await adapter.handleActivity(ctx, sink);
+        await flush();
+        const turn = sink.onTurn.mock.calls[0][0];
+        expect(turn.contentParts).toBeUndefined();
+    });
+});
+describe("TeamsAdapter.postFile", () => {
+    it("sends a PNG as an inline image attachment via a data: URI", async () => {
+        const adapter = new TeamsAdapter({});
+        const sendActivity = vi.fn().mockResolvedValue({ id: "msg-9" });
+        const target = {
+            conversationKey: "conv-1",
+            reference: {},
+            context: { sendActivity },
+        };
+        const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+        const res = await adapter.postFile(target, {
+            bytes,
+            filename: "chart.png",
+            title: "Chart",
+            altText: "Sev counts",
+        });
+        expect(res).toEqual({ ok: true, fileId: "msg-9" });
+        const sent = sendActivity.mock.calls[0][0];
+        const attachment = sent.attachments[0];
+        expect(attachment.contentType).toBe("image/png");
+        expect(attachment.contentUrl).toBe(`data:image/png;base64,${Buffer.from(bytes).toString("base64")}`);
+        expect(attachment.name).toBe("Sev counts");
+    });
+    it("returns an error result when there is no context to send on", async () => {
+        const adapter = new TeamsAdapter({});
+        const res = await adapter.postFile({ conversationKey: "conv-1", reference: {} }, { bytes: new Uint8Array([1]), filename: "x.png" });
+        expect(res.ok).toBe(false);
+        expect(res.error).toBeDefined();
+    });
+});
+describe("TeamsAdapter typing heartbeat", () => {
+    it("sends typing immediately, repeats on a timer, and stops when cleared", () => {
+        vi.useFakeTimers();
+        try {
+            const adapter = new TeamsAdapter({});
+            const sendActivity = vi.fn().mockResolvedValue({ id: "t" });
+            const target = {
+                conversationKey: "c",
+                reference: {},
+                context: { sendActivity },
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const stop = adapter.startTypingHeartbeat(target);
+            expect(sendActivity).toHaveBeenCalledTimes(1); // immediate
+            vi.advanceTimersByTime(3500 * 2);
+            expect(sendActivity).toHaveBeenCalledTimes(3); // two more ticks
+            stop();
+            vi.advanceTimersByTime(3500 * 3);
+            expect(sendActivity).toHaveBeenCalledTimes(3); // none after stop
+            // It sends a typing activity, not text.
+            expect(sendActivity.mock.calls[0][0].type).toBe("typing");
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});

package/dist/conversation-store.d.ts

@@ -0,0 +1,36 @@
+import type { AbstractAgent } from "@ag-ui/client";
+import type { ConversationStore, AgentSession, ReplyTarget } from "@copilotkit/channels";
+import type { ThreadMessage, AgentContentPart } from "@copilotkit/channels-ui";
+/**
+ * In-memory Teams conversation store.
+ *
+ * Unlike Slack, Teams does not hand the bot a free, queryable history of a
+ * conversation, so the adapter keeps the transcript itself: the listener
+ * records each incoming user message, and the run renderer records the agent's
+ * reply. Each turn builds a fresh AG-UI thread id (the durable history is held
+ * here, not server-side) and seeds the agent with the accumulated transcript.
+ *
+ * The transcript retains a message's multimodal content (an uploaded file's
+ * decoded contents), not just its text, so a follow-up turn can still act on
+ * data the user only sent once. This grows context for long file-bearing
+ * conversations; a production {@link ConversationStore} can cap or summarize it.
+ *
+ * This is the batteries-included default. It is deliberately swappable: a
+ * production deployment that needs the transcript to survive restarts can
+ * implement {@link ConversationStore} against a real datastore and pass it in.
+ */
+export declare class TeamsConversationStore implements ConversationStore {
+    private readonly history;
+    /**
+     * Append a user message to the conversation transcript. Accepts plain text or
+     * multimodal content parts (uploaded files); empty content is ignored.
+     */
+    recordUser(conversationKey: string, content: string | AgentContentPart[]): void;
+    /** Append an assistant message to the conversation transcript. */
+    recordAssistant(conversationKey: string, content: string): void;
+    /** The accumulated transcript as bot-ui `ThreadMessage`s (backs `thread.getMessages()`). */
+    getTranscript(conversationKey: string): ThreadMessage[];
+    private append;
+    getOrCreate(conversationKey: string, _replyTarget: ReplyTarget, makeAgent: (threadId: string) => AbstractAgent): Promise<AgentSession>;
+}
+//# sourceMappingURL=conversation-store.d.ts.map

package/dist/conversation-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-store.d.ts","sourceRoot":"","sources":["../src/conversation-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EACV,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AA2B/E;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,sBAAuB,YAAW,iBAAiB;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAE9D;;;OAGG;IACH,UAAU,CACR,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM,GAAG,gBAAgB,EAAE,GACnC,IAAI;IAKP,kEAAkE;IAClE,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAS/D,4FAA4F;IAC5F,aAAa,CAAC,eAAe,EAAE,MAAM,GAAG,aAAa,EAAE;IAQvD,OAAO,CAAC,MAAM;IAMR,WAAW,CACf,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,WAAW,EACzB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,aAAa,GAC7C,OAAO,CAAC,YAAY,CAAC;CAYzB"}

package/dist/conversation-store.js

@@ -0,0 +1,78 @@
+import { randomUUID } from "node:crypto";
+/** Collapse stored content (text or multimodal parts) to a display string. */
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .map((p) => p.type === "text"
+        ? p.text
+        : `[${p.type} attachment: ${p.source.mimeType}]`)
+        .join("\n");
+}
+/**
+ * In-memory Teams conversation store.
+ *
+ * Unlike Slack, Teams does not hand the bot a free, queryable history of a
+ * conversation, so the adapter keeps the transcript itself: the listener
+ * records each incoming user message, and the run renderer records the agent's
+ * reply. Each turn builds a fresh AG-UI thread id (the durable history is held
+ * here, not server-side) and seeds the agent with the accumulated transcript.
+ *
+ * The transcript retains a message's multimodal content (an uploaded file's
+ * decoded contents), not just its text, so a follow-up turn can still act on
+ * data the user only sent once. This grows context for long file-bearing
+ * conversations; a production {@link ConversationStore} can cap or summarize it.
+ *
+ * This is the batteries-included default. It is deliberately swappable: a
+ * production deployment that needs the transcript to survive restarts can
+ * implement {@link ConversationStore} against a real datastore and pass it in.
+ */
+export class TeamsConversationStore {
+    history = new Map();
+    /**
+     * Append a user message to the conversation transcript. Accepts plain text or
+     * multimodal content parts (uploaded files); empty content is ignored.
+     */
+    recordUser(conversationKey, content) {
+        if (typeof content === "string" ? !content : content.length === 0)
+            return;
+        this.append(conversationKey, { id: randomUUID(), role: "user", content });
+    }
+    /** Append an assistant message to the conversation transcript. */
+    recordAssistant(conversationKey, content) {
+        if (!content)
+            return;
+        this.append(conversationKey, {
+            id: randomUUID(),
+            role: "assistant",
+            content,
+        });
+    }
+    /** The accumulated transcript as bot-ui `ThreadMessage`s (backs `thread.getMessages()`). */
+    getTranscript(conversationKey) {
+        const transcript = this.history.get(conversationKey) ?? [];
+        return transcript.map((m) => ({
+            text: contentToText(m.content),
+            isBot: m.role === "assistant",
+        }));
+    }
+    append(conversationKey, message) {
+        const existing = this.history.get(conversationKey);
+        if (existing)
+            existing.push(message);
+        else
+            this.history.set(conversationKey, [message]);
+    }
+    async getOrCreate(conversationKey, _replyTarget, makeAgent) {
+        // Fresh AG-UI thread per turn. Our `history` map is the durable record, so
+        // the server-side thread only needs to live for this turn (mirrors the
+        // Slack adapter's rationale for not reusing a stable thread id).
+        const threadId = `teams-${conversationKey}-${randomUUID()}`;
+        const agent = makeAgent(threadId);
+        const transcript = this.history.get(conversationKey) ?? [];
+        agent.messages = [
+            ...transcript,
+        ];
+        return { agent };
+    }
+}

package/dist/conversation-store.test.d.ts

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

package/dist/conversation-store.test.d.ts.map

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

package/dist/conversation-store.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest";
+import { TeamsConversationStore } from "./conversation-store.js";
+/** Minimal stand-in: only the `messages` field the store writes is exercised. */
+function makeAgent(threadId) {
+    return { threadId, messages: [] };
+}
+describe("TeamsConversationStore", () => {
+    it("seeds a fresh agent with the accumulated transcript", async () => {
+        const store = new TeamsConversationStore();
+        store.recordUser("conv-1", "hello");
+        store.recordAssistant("conv-1", "hi there");
+        store.recordUser("conv-1", "how are you?");
+        const session = await store.getOrCreate("conv-1", {}, makeAgent);
+        const messages = session.agent
+            .messages;
+        expect(messages).toEqual([
+            expect.objectContaining({ role: "user", content: "hello" }),
+            expect.objectContaining({ role: "assistant", content: "hi there" }),
+            expect.objectContaining({ role: "user", content: "how are you?" }),
+        ]);
+    });
+    it("isolates transcripts by conversation key", async () => {
+        const store = new TeamsConversationStore();
+        store.recordUser("a", "from a");
+        store.recordUser("b", "from b");
+        const a = await store.getOrCreate("a", {}, makeAgent);
+        const aMessages = a.agent.messages;
+        expect(aMessages).toHaveLength(1);
+        expect(aMessages[0]).toMatchObject({ content: "from a" });
+    });
+    it("exposes the transcript as bot-ui ThreadMessages", () => {
+        const store = new TeamsConversationStore();
+        store.recordUser("c", "ping");
+        store.recordAssistant("c", "pong");
+        expect(store.getTranscript("c")).toEqual([
+            { text: "ping", isBot: false },
+            { text: "pong", isBot: true },
+        ]);
+    });
+    it("ignores empty messages", () => {
+        const store = new TeamsConversationStore();
+        store.recordUser("d", "");
+        store.recordUser("d", []); // empty content parts are dropped too
+        store.recordAssistant("d", "   "); // whitespace-only is still stored as-is by callers; empty string is dropped
+        expect(store.getTranscript("d")).toEqual([{ text: "   ", isBot: true }]);
+    });
+    it("persists multimodal content so a later turn still sees uploaded data", async () => {
+        const store = new TeamsConversationStore();
+        // Turn 1: a CSV upload, recorded as multimodal content parts.
+        store.recordUser("conv-1", [
+            { type: "text", text: "make a pie chart" },
+            { type: "text", text: 'Attached file "data.csv" (text/csv):\na,b\n1,2' },
+        ]);
+        store.recordAssistant("conv-1", "Pie chart created.");
+        // Turn 2: a plain follow-up with no new data.
+        store.recordUser("conv-1", "now make it a bar chart");
+        const session = await store.getOrCreate("conv-1", {}, makeAgent);
+        const messages = session.agent
+            .messages;
+        // The CSV content from turn 1 is still seeded into the agent on turn 2.
+        expect(messages).toHaveLength(3);
+        expect(messages[0]).toMatchObject({
+            role: "user",
+            content: [
+                { type: "text", text: "make a pie chart" },
+                expect.objectContaining({ type: "text" }),
+            ],
+        });
+        // The transcript view flattens parts to text (for thread.getMessages()).
+        expect(store.getTranscript("conv-1")[0].text).toContain("a,b\n1,2");
+    });
+});

package/dist/download-files.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Inbound file transport for Teams. A Teams message can carry uploaded files;
+ * this turns them into AG-UI multimodal content the agent's model can read —
+ * images and PDFs as their respective binary parts, and text/CSV/JSON as
+ * decoded `text` parts. This is what makes the "upload a CSV → get a chart"
+ * flow work: the CSV arrives as text the model can parse before it calls a
+ * render tool. Mirrors `@copilotkit/channels-slack`'s `buildFileContentParts`.
+ *
+ * Teams delivers files two ways, and we handle both:
+ *   - Channel/chat file uploads arrive as an attachment of contentType
+ *     `application/vnd.microsoft.teams.file.download.info`, whose `content`
+ *     holds a pre-authenticated `downloadUrl` (no bearer token needed) plus a
+ *     `fileType`. We download from `downloadUrl`.
+ *   - Inline media (and the M365 Agents Playground) arrives as an attachment
+ *     whose `contentType` is the media MIME and `contentUrl` is either a
+ *     `data:` URI (decoded in-process) or an https URL (fetched directly).
+ *
+ * The bridge is transport-only: it delivers the bytes/text to the agent and
+ * lets the app decide what to do with them. Anything it can't represent is
+ * skipped with a short note so the agent knows a file was dropped and why.
+ */
+import type { AgentContentPart } from "@copilotkit/channels-ui";
+/** The subset of a Teams `Attachment` we read (matches @microsoft/agents-activity). */
+export interface TeamsAttachmentRef {
+    contentType: string;
+    contentUrl?: string;
+    /** `file.download.info` attachments carry the real source here. */
+    content?: unknown;
+    name?: string;
+}
+/** Tunables for inbound file handling (all optional; sane defaults). */
+export interface FileDeliveryConfig {
+    /** Skip a single file larger than this many bytes. Default 8 MiB. */
+    maxBytesPerFile?: number;
+    /** Process at most this many files per message. Default 5. */
+    maxFiles?: number;
+    /** Truncate decoded text files to this many bytes. Default 200 KiB. */
+    maxTextBytes?: number;
+}
+/** Best-effort MIME from a filename's extension, or undefined if unknown. */
+export declare function mimeFromName(name: string | undefined): string | undefined;
+/**
+ * Turn downloaded bytes into a single AG-UI content part, or a skip `note` when
+ * the type is unsupported or the file exceeds the byte cap. Shared by the
+ * attachment path (this module) and the Graph channel path (`graph-files.ts`)
+ * so both classify and truncate identically.
+ */
+export declare function decodeFileBytes(label: string, mime: string, bytes: Buffer, config?: FileDeliveryConfig): {
+    part: AgentContentPart;
+} | {
+    note: string;
+};
+/**
+ * Download a message's attachments and turn them into AG-UI content parts.
+ * Returns the parts plus human-readable `notes` for anything skipped (appended
+ * to the message as a text part by the caller).
+ */
+export declare function buildFileContentParts(attachments: readonly TeamsAttachmentRef[], config?: FileDeliveryConfig): Promise<{
+    parts: AgentContentPart[];
+    notes: string[];
+}>;
+//# sourceMappingURL=download-files.d.ts.map

package/dist/download-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download-files.d.ts","sourceRoot":"","sources":["../src/download-files.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,uFAAuF;AACvF,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AASD,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,qEAAqE;IACrE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA8DD,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAGzE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,kBAAuB,GAC9B;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CA2C/C;AAmDD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,SAAS,kBAAkB,EAAE,EAC1C,MAAM,GAAE,kBAAuB,GAC9B,OAAO,CAAC;IAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAuCzD"}

package/dist/download-files.js

@@ -0,0 +1,190 @@
+const DEFAULTS = {
+    maxBytesPerFile: 8 * 1024 * 1024,
+    maxFiles: 5,
+    maxTextBytes: 200 * 1024,
+};
+const TEAMS_FILE_DOWNLOAD_INFO = "application/vnd.microsoft.teams.file.download.info";
+const TEXT_MIME_PREFIXES = ["text/"];
+const TEXT_MIME_EXACT = new Set([
+    "application/json",
+    "application/csv",
+    "application/xml",
+    "application/x-ndjson",
+    "application/yaml",
+]);
+/** Map a filename extension to a MIME when the attachment doesn't give one. */
+const EXT_MIME = {
+    csv: "text/csv",
+    tsv: "text/tab-separated-values",
+    txt: "text/plain",
+    md: "text/markdown",
+    json: "application/json",
+    xml: "application/xml",
+    yaml: "application/yaml",
+    yml: "application/yaml",
+    ndjson: "application/x-ndjson",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    pdf: "application/pdf",
+};
+function isText(mime) {
+    return (TEXT_MIME_PREFIXES.some((p) => mime.startsWith(p)) ||
+        TEXT_MIME_EXACT.has(mime));
+}
+/**
+ * The AG-UI media part type that carries this MIME, or null if it isn't a
+ * binary medium we pass through. Images/audio/video go by their top-level
+ * type; PDFs map to `document`. Everything else is left to the text path or
+ * skipped.
+ */
+function mediaPartType(mime) {
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("audio/"))
+        return "audio";
+    if (mime.startsWith("video/"))
+        return "video";
+    if (mime === "application/pdf")
+        return "document";
+    return null;
+}
+/** Best-effort MIME from a filename's extension, or undefined if unknown. */
+export function mimeFromName(name) {
+    const ext = name?.split(".").pop()?.toLowerCase();
+    return ext ? EXT_MIME[ext] : undefined;
+}
+/**
+ * Turn downloaded bytes into a single AG-UI content part, or a skip `note` when
+ * the type is unsupported or the file exceeds the byte cap. Shared by the
+ * attachment path (this module) and the Graph channel path (`graph-files.ts`)
+ * so both classify and truncate identically.
+ */
+export function decodeFileBytes(label, mime, bytes, config = {}) {
+    const maxBytes = config.maxBytesPerFile ?? DEFAULTS.maxBytesPerFile;
+    const maxText = config.maxTextBytes ?? DEFAULTS.maxTextBytes;
+    const media = mediaPartType(mime);
+    if (!media && !isText(mime)) {
+        return { note: `skipped "${label}" (${mime}): unsupported type` };
+    }
+    if (bytes.byteLength > maxBytes) {
+        return {
+            note: `skipped "${label}": ${bytes.byteLength} bytes exceeds the ${maxBytes}-byte cap`,
+        };
+    }
+    if (media) {
+        // Image/audio/video/PDF → a binary data part the model reads natively
+        // (subject to its modality support). The bridge just delivers it.
+        return {
+            part: {
+                type: media,
+                source: {
+                    type: "data",
+                    value: bytes.toString("base64"),
+                    mimeType: mime,
+                },
+            },
+        };
+    }
+    // Truncate the BYTES then decode — slicing the decoded string by character
+    // index would corrupt multi-byte UTF-8 (and not actually bound the byte
+    // length). toString drops any malformed trailing bytes.
+    let buf = bytes;
+    let truncated = false;
+    if (buf.byteLength > maxText) {
+        buf = buf.subarray(0, maxText);
+        truncated = true;
+    }
+    return {
+        part: {
+            type: "text",
+            text: `Attached file "${label}" (${mime}${truncated ? ", truncated" : ""}):\n` +
+                buf.toString("utf8"),
+        },
+    };
+}
+/**
+ * Resolve a Teams attachment to a single fetchable source (URL + MIME + label),
+ * or null if it carries nothing we can download. `file.download.info` points at
+ * its pre-authenticated `downloadUrl`; everything else uses `contentUrl`.
+ */
+function resolveSource(att) {
+    const label = att.name ?? "file";
+    if (att.contentType === TEAMS_FILE_DOWNLOAD_INFO) {
+        const info = (att.content ?? {});
+        if (!info.downloadUrl)
+            return null;
+        const mime = mimeFromName(att.name) ??
+            (info.fileType ? EXT_MIME[info.fileType.toLowerCase()] : undefined) ??
+            "application/octet-stream";
+        return { url: info.downloadUrl, mime, label };
+    }
+    if (!att.contentUrl)
+        return null;
+    // For media/text attachments the contentType IS the MIME; fall back to the
+    // filename when it's a generic wrapper.
+    const mime = att.contentType && att.contentType.includes("/")
+        ? att.contentType.toLowerCase()
+        : (mimeFromName(att.name) ?? "application/octet-stream");
+    return { url: att.contentUrl, mime, label };
+}
+/** Fetch a source's bytes. Decodes `data:` URIs in-process; fetches http(s). */
+async function fetchBytes(url) {
+    if (url.startsWith("data:")) {
+        const comma = url.indexOf(",");
+        if (comma < 0)
+            throw new Error("malformed data URI");
+        const meta = url.slice(5, comma);
+        const payload = url.slice(comma + 1);
+        return meta.includes(";base64")
+            ? Buffer.from(payload, "base64")
+            : Buffer.from(decodeURIComponent(payload), "utf8");
+    }
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`download failed (HTTP ${res.status})`);
+    return Buffer.from(await res.arrayBuffer());
+}
+/**
+ * Download a message's attachments and turn them into AG-UI content parts.
+ * Returns the parts plus human-readable `notes` for anything skipped (appended
+ * to the message as a text part by the caller).
+ */
+export async function buildFileContentParts(attachments, config = {}) {
+    const maxFiles = config.maxFiles ?? DEFAULTS.maxFiles;
+    const parts = [];
+    const notes = [];
+    const considered = attachments.slice(0, maxFiles);
+    if (attachments.length > maxFiles) {
+        notes.push(`(only the first ${maxFiles} of ${attachments.length} files processed)`);
+    }
+    for (const att of considered) {
+        const source = resolveSource(att);
+        if (!source) {
+            // A file.download.info with no downloadUrl is a real drop we want to
+            // surface; other contentTypes (Adaptive Cards, the text/html mention)
+            // simply aren't files, so skip them quietly.
+            if (att.contentType === TEAMS_FILE_DOWNLOAD_INFO) {
+                notes.push(`skipped "${att.name ?? "file"}": file.download.info had no downloadUrl`);
+            }
+            continue;
+        }
+        const { url, mime, label } = source;
+        let bytes;
+        try {
+            bytes = await fetchBytes(url);
+        }
+        catch (err) {
+            notes.push(`skipped "${label}": ${err.message}`);
+            continue;
+        }
+        const decoded = decodeFileBytes(label, mime, bytes, config);
+        if ("note" in decoded)
+            notes.push(decoded.note);
+        else
+            parts.push(decoded.part);
+    }
+    return { parts, notes };
+}

package/dist/download-files.test.d.ts

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

package/dist/download-files.test.d.ts.map

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