@hahnfeld/teams-adapter 1.3.4 → 1.4.0

package/dist/message-composer.js

@@ -1,34 +1,176 @@
 import { log } from "@openacp/plugin-sdk";
-import { sendText } from "./send-utils.js";
-const MAX_BODY_LENGTH = 25_000;
-const STALL_TIMEOUT = 30_000;
-/** Escape asterisks to prevent breaking markdown italic/bold spans. */
-function escapeEmphasis(text) {
-    return text.replace(/\*/g, "\\*");
+import { CardFactory } from "@microsoft/agents-hosting";
+const MAX_ROOT_TEXT_LENGTH = 25_000;
+/** How long to wait with no activity before warning about truncation. */
+const STALL_TIMEOUT = 120_000;
+// ─── Brand Colors ────────────────────────────────────────────────────────────
+// Primary blue #01426a | Dark blue #00274a | Purple #463c8f
+// Cyan #5de3f7 | Green #a3cd6a | Magenta #ce0c88
+// Text default #2a2a2a | Muted #676767 | White #ffffff
+const BRAND = {
+    blue: "#01426a",
+    blueDark: "#00274a",
+    purple: "#463c8f",
+    cyan: "#5de3f7",
+    green: "#a3cd6a",
+    magenta: "#ce0c88",
+    textDefault: "#2a2a2a",
+    textMuted: "#676767",
+    white: "#ffffff",
+    surfaceMuted: "#f7f7f7",
+};
+// ─── ID generation ─────────────────────────────────────────────────────────────
+let _idCounter = 0;
+function nextId() {
+    return `e${++_idCounter}_${Date.now().toString(36)}`;
 }
-/**
- * Normalize newlines for Teams rendering.
- * Teams collapses single \n in markdown — use \n\n for line breaks.
- */
-function teamsNewlines(text) {
-    return text.replace(/(?<!\n)\n(?!\n)/g, "\n\n");
+// ─── Adaptive Card Builder ────────────────────────────────────────────────────
+function buildCardBody(entries) {
+    const blocks = [];
+    const now = Date.now();
+    for (const entry of entries) {
+        switch (entry.kind) {
+            case "title":
+                blocks.push({
+                    type: "TextBlock",
+                    text: `**${escapeMd(entry.text)}**`,
+                    weight: "Bolder",
+                    size: "Medium",
+                    fontType: "Monospace",
+                    spacing: "None",
+                });
+                break;
+            case "tool-start": {
+                const elapsed = formatElapsed(now - entry.startedAt);
+                blocks.push({
+                    type: "Container",
+                    items: [
+                        {
+                            type: "TextBlock",
+                            text: `🔄 ${escapeMd(entry.toolName)}…  (${elapsed})`,
+                            hexColor: BRAND.blue,
+                            weight: "Bolder",
+                            size: "Small",
+                            fontType: "Monospace",
+                            spacing: "None",
+                        },
+                        ...entry.children.map((c) => ({
+                            type: "TextBlock",
+                            text: `    ${c.text}`,
+                            size: "Small",
+                            hexColor: BRAND.cyan,
+                            fontType: "Monospace",
+                            spacing: "None",
+                        })),
+                    ],
+                    style: "emphasis",
+                    padding: "Small",
+                });
+                break;
+            }
+            case "tool-result": {
+                const elapsed = formatElapsed(entry.endedAt - entry.startedAt);
+                blocks.push({
+                    type: "Container",
+                    items: [
+                        {
+                            type: "TextBlock",
+                            text: `📄 ${escapeMd(entry.result)}  (${elapsed})`,
+                            hexColor: BRAND.purple,
+                            weight: "Bolder",
+                            size: "Small",
+                            fontType: "Monospace",
+                            spacing: "None",
+                        },
+                        ...entry.children.map((c) => ({
+                            type: "TextBlock",
+                            text: `    ${c.text}`,
+                            size: "Small",
+                            hexColor: BRAND.textDefault,
+                            fontType: "Monospace",
+                            wrap: true,
+                            spacing: "None",
+                        })),
+                    ],
+                    style: "good",
+                    padding: "Small",
+                });
+                break;
+            }
+            case "text":
+                blocks.push({
+                    type: "TextBlock",
+                    text: entry.text,
+                    size: "Small",
+                    hexColor: BRAND.textDefault,
+                    fontType: "Monospace",
+                    wrap: true,
+                    spacing: "None",
+                });
+                break;
+            case "thought":
+                blocks.push({
+                    type: "TextBlock",
+                    text: `💭 ${entry.text}`,
+                    italic: true,
+                    size: "Small",
+                    hexColor: BRAND.textMuted,
+                    fontType: "Monospace",
+                    spacing: "None",
+                });
+                break;
+            case "usage":
+                blocks.push({
+                    type: "TextBlock",
+                    text: `*${escapeMd(entry.text)}*`,
+                    italic: true,
+                    size: "Small",
+                    hexColor: BRAND.blue,
+                    fontType: "Monospace",
+                    spacing: "None",
+                });
+                break;
+            case "divider":
+                blocks.push({
+                    type: "TextBlock",
+                    text: "─".repeat(30),
+                    size: "Small",
+                    hexColor: BRAND.textMuted,
+                    fontType: "Monospace",
+                    spacing: "None",
+                });
+                break;
+        }
+    }
+    return blocks;
+}
+function formatElapsed(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60_000)}m ${Math.floor((ms % 60_000) / 1000)}s`;
+}
+function escapeMd(text) {
+    return text.replace(/\[/g, "\\[").replace(/\*/g, "\\*").replace(/\]/g, "\\]");
 }
-/**
- * A single main message with title/header/body/footer zones.
- */
+// ─── SessionMessage ────────────────────────────────────────────────────────────
 export class SessionMessage {
     context;
     conversationId;
     sessionId;
     rateLimiter;
     acquireBotToken;
-    title = null;
-    header = null;
-    body = "";
-    footer = null;
+    entries = [];
+    titleId = null;
+    usageId = null;
+    /** The active tool whose children accumulate streaming output */
+    toolActive = null;
     ref = null;
     lastSent = "";
     stallTimer;
+    /** Interval handle for periodic elapsed-time updates on running tools */
+    tickInterval;
     constructor(context, conversationId, sessionId, rateLimiter, acquireBotToken) {
         this.context = context;
         this.conversationId = conversationId;
@@ -43,111 +185,190 @@ export class SessionMessage {
         return this.ref;
     }
     getBody() {
-        return this.body;
+        return this.entries
+            .filter((e) => e.kind === "text")
+            .map((e) => e.text)
+            .join("");
     }
     getFooter() {
-        return this.footer;
+        const usage = this.entries.find((e) => e.kind === "usage");
+        return usage ? usage.text : null;
     }
+    // ─── Entry API ───────────────────────────────────────────────────────────
     /** Set the persistent session title (bold, survives finalize). */
     setTitle(text) {
-        this.title = text;
+        if (this.titleId) {
+            const entry = this.findEntry(this.titleId);
+            if (entry && entry.kind === "title")
+                entry.text = text;
+        }
+        else {
+            this.titleId = nextId();
+            this.entries.unshift({ id: this.titleId, kind: "title", text });
+        }
         this.requestFlush();
     }
-    /** Max header length — keeps the message compact; tool diffs can be huge. */
-    static MAX_HEADER_LENGTH = 120;
-    /** Replace the ephemeral header (tool_call, thought, etc.). */
-    setHeader(text) {
-        // Truncate to first line, then cap length — headers are status indicators, not content
-        const firstLine = text.split("\n")[0];
-        this.header = firstLine.length > SessionMessage.MAX_HEADER_LENGTH
-            ? firstLine.slice(0, SessionMessage.MAX_HEADER_LENGTH) + "..."
-            : firstLine;
+    /**
+     * Add a tool-progress entry (🔄 Running...). Sets toolActive so subsequent
+     * addText() calls route children here. Returns entry id for tracking.
+     */
+    addToolStart(toolName, _params) {
+        const id = nextId();
+        const startedAt = Date.now();
+        this.entries.push({ id, kind: "tool-start", toolName, startedAt, children: [] });
+        this.toolActive = id;
+        this.resetStallTimer();
+        this.startTickInterval();
         this.requestFlush();
+        return id;
     }
-    /** Clear the ephemeral header and flush the update. */
-    clearHeader() {
-        if (this.header === null)
+    /**
+     * Add a tool-result entry (📄 Result...). Creates a NEW entry — does NOT
+     * replace the tool-progress entry. Both coexist as historical record.
+     * Clears toolActive so subsequent addText() goes to root body.
+     */
+    addToolResult(id, result) {
+        const progressEntry = this.entries.find((e) => e.id === id);
+        if (!progressEntry || progressEntry.kind !== "tool-start") {
+            // Progress entry not found — create a standalone result
+            const startedAt = Date.now();
+            this.entries.push({ id: nextId(), kind: "tool-result", toolName: "", result, startedAt, endedAt: startedAt, children: [] });
+            this.toolActive = null;
+            this.stopTickInterval();
+            this.requestFlush();
             return;
-        this.header = null;
+        }
+        const startedAt = progressEntry.startedAt;
+        const endedAt = Date.now();
+        const children = [...progressEntry.children];
+        // Keep the tool-start as historical record; add tool-result after it
+        this.entries.push({ id: nextId(), kind: "tool-result", toolName: progressEntry.toolName, result, startedAt, endedAt, children });
+        if (this.toolActive === id)
+            this.toolActive = null;
+        this.stopTickInterval();
         this.requestFlush();
     }
-    /** Append text to the body (streaming text chunks). */
-    appendBody(text) {
+    /** Add text — goes to toolActive children if a tool is running, else root text entry. */
+    addText(text) {
         if (!text)
             return;
-        this.body += text;
-        this.resetStallTimer();
-        // Check if body needs splitting
-        if (this.body.length > MAX_BODY_LENGTH && this.ref) {
-            this.split();
-            return;
+        if (this.toolActive) {
+            const entry = this.findEntry(this.toolActive);
+            if (entry && (entry.kind === "tool-start" || entry.kind === "tool-result")) {
+                entry.children.push({ text });
+                this.resetStallTimer();
+                this.requestFlush();
+                // Check for overflow (root text limit)
+                if (this.ref)
+                    this.checkSplit();
+                return;
+            }
+        }
+        // Root-level text — append to last root text entry or create new
+        const lastText = this.entries.filter((e) => e.kind === "text").at(-1);
+        if (lastText) {
+            lastText.text += text;
         }
+        else {
+            this.entries.push({ id: nextId(), kind: "text", text });
+        }
+        this.resetStallTimer();
         this.requestFlush();
+        // Check for overflow after root text grows
+        if (this.ref)
+            this.checkSplit();
     }
-    /** Set the persistent footer (usage, completion). */
-    setFooter(text) {
-        this.footer = text;
+    /**
+     * Always append a new thought entry (thoughts persist, never replaced).
+     * Multiple thinking blocks can coexist — each is a historical record.
+     */
+    addThought(text) {
+        this.entries.push({ id: nextId(), kind: "thought", text });
         this.requestFlush();
     }
-    /** Append to the existing footer (e.g., adding "Task completed" after usage). */
-    appendFooter(text) {
-        this.footer = this.footer ? `${this.footer} · ${text}` : text;
+    /** Set or replace the usage entry (only one at a time). */
+    setUsage(text) {
+        if (this.usageId) {
+            const entry = this.findEntry(this.usageId);
+            if (entry && entry.kind === "usage")
+                entry.text = text;
+        }
+        else {
+            this.usageId = nextId();
+            this.entries.push({ id: this.usageId, kind: "usage", text });
+        }
         this.requestFlush();
     }
+    /** Add a divider entry. */
+    appendDivider() {
+        this.entries.push({ id: nextId(), kind: "divider" });
+        this.requestFlush();
+    }
+    // ─── Entry helpers ────────────────────────────────────────────────────────
+    findEntry(id) {
+        for (const entry of this.entries) {
+            if (entry.id === id)
+                return entry;
+        }
+        return undefined;
+    }
+    removeEntry(id) {
+        this.entries = this.entries.filter((e) => e.id !== id);
+    }
+    // ─── Periodic tick for elapsed time updates ───────────────────────────────
     /**
-     * Close any unclosed code fences in the body.
-     * If the body has an odd number of ``` markers, the footer would
-     * be swallowed into the code block — append a closing fence.
+     * Start a 1-second interval that updates elapsed time on running tool-progress
+     * entries. Called when a tool starts, stopped when tool completes or finalize.
      */
-    static closeCodeFences(text) {
-        const fenceCount = (text.match(/^```/gm) || []).length;
-        if (fenceCount % 2 !== 0) {
-            return text + "\n```";
-        }
-        return text;
+    startTickInterval() {
+        if (this.tickInterval)
+            return;
+        this.tickInterval = setInterval(() => {
+            // Only tick if there's an active tool-progress entry
+            const hasRunningTool = this.entries.some((e) => e.kind === "tool-start");
+            if (!hasRunningTool) {
+                this.stopTickInterval();
+                return;
+            }
+            this.requestFlush();
+        }, 1_000);
+        if (this.tickInterval.unref)
+            this.tickInterval.unref();
     }
-    /** Compose the four zones into a single markdown string. */
-    compose() {
-        const parts = [];
-        if (this.title) {
-            parts.push(`**${escapeEmphasis(this.title)}**`);
-        }
-        if (this.header) {
-            parts.push(`*${escapeEmphasis(this.header)}*`);
-        }
-        if (this.title || this.header) {
-            parts.push("---");
+    stopTickInterval() {
+        if (this.tickInterval) {
+            clearInterval(this.tickInterval);
+            this.tickInterval = undefined;
         }
-        if (this.body) {
-            parts.push(SessionMessage.closeCodeFences(this.body));
-        }
-        if (this.footer) {
-            if (this.body)
-                parts.push("---");
-            parts.push(`*${escapeEmphasis(this.footer)}*`);
-        }
-        return parts.join("\n\n");
     }
-    /** Request a flush through the rate limiter. */
+    // ─── Card building ─────────────────────────────────────────────────────────
+    buildCard() {
+        const body = buildCardBody(this.entries);
+        return {
+            type: "AdaptiveCard",
+            version: "1.4",
+            body: [
+                ...(body.length > 0 ? body : [{ type: "TextBlock", text: "…" }]),
+            ],
+            // Use full available width
+            width: "stretch",
+        };
+    }
+    // ─── Flush / Rate limiting ─────────────────────────────────────────────────
     requestFlush() {
-        const composed = this.compose();
-        if (!composed)
-            return;
-        if (composed === this.lastSent)
-            return;
-        // Coalescing key: activityId for updates, session for new sends
+        const card = this.buildCard();
         const key = this.ref ? `update:${this.ref.activityId}` : `new:${this.sessionId}`;
         this.rateLimiter.enqueue(this.conversationId, () => this.flush(), key).catch((err) => {
             log.warn({ err, sessionId: this.sessionId }, "[SessionMessage] flush failed");
         });
     }
     async flush() {
-        const composed = this.compose();
-        if (!composed || composed === this.lastSent)
+        const card = this.buildCard();
+        const cardStr = JSON.stringify(card);
+        if (!cardStr || cardStr === this.lastSent)
             return;
         if (!this.ref) {
-            // First send — create the message
-            const result = await sendText(this.context, composed);
+            const result = await sendCard(this.context, card);
             if (result?.id) {
                 this.ref = {
                     activityId: result.id,
@@ -155,22 +376,21 @@ export class SessionMessage {
                     serviceUrl: this.context.activity.serviceUrl,
                 };
             }
-            this.lastSent = composed;
+            this.lastSent = cardStr;
         }
         else {
-            // Update existing message via REST
-            const success = await this.updateViaRest(composed);
+            const success = await this.updateCardViaRest(card);
             if (success) {
-                this.lastSent = composed;
+                this.lastSent = cardStr;
             }
         }
-        // Check if state changed during the flush (new chunks arrived while we were awaiting)
-        const current = this.compose();
-        if (current && current !== this.lastSent) {
+        // Content arrived while flushing — request another flush
+        const current = this.buildCard();
+        if (JSON.stringify(current) !== this.lastSent) {
             this.requestFlush();
         }
     }
-    async updateViaRest(text) {
+    async updateCardViaRest(card) {
         if (!this.ref)
             return false;
         const token = await this.acquireBotToken();
@@ -186,69 +406,54 @@ export class SessionMessage {
                 },
                 body: JSON.stringify({
                     type: "message",
-                    text: teamsNewlines(text),
-                    textFormat: "markdown",
+                    attachments: [CardFactory.adaptiveCard(card)],
                 }),
             });
             if (!response.ok) {
-                log.warn({ status: response.status, sessionId: this.sessionId }, "[SessionMessage] REST update failed");
+                log.warn({ status: response.status, sessionId: this.sessionId }, "[SessionMessage] REST card update failed");
                 return false;
             }
             return true;
         }
         catch (err) {
-            log.warn({ err, sessionId: this.sessionId }, "[SessionMessage] REST update error");
+            log.warn({ err, sessionId: this.sessionId }, "[SessionMessage] REST card update error");
             return false;
         }
     }
-    /** Split: finalize current message at body limit, start fresh. */
-    split() {
-        const finalBody = this.body.slice(0, MAX_BODY_LENGTH);
-        const overflow = this.body.slice(MAX_BODY_LENGTH);
-        log.info({ sessionId: this.sessionId, finalLen: finalBody.length, overflowLen: overflow.length }, "[SessionMessage] splitting");
-        // Clear ephemeral header on the finalized message; footer stays per spec
-        this.header = null;
-        this.body = finalBody;
-        // Final flush of the current message (with footer preserved)
-        const composed = this.compose();
-        if (this.ref && composed !== this.lastSent) {
-            this.rateLimiter.enqueue(this.conversationId, () => this.updateViaRest(composed).then(() => { }), `update:${this.ref.activityId}`).catch(() => { });
-        }
-        // Reset for a new message — footer carries over to new message
-        this.ref = null;
-        this.lastSent = "";
-        this.body = overflow;
-        if (overflow) {
-            this.requestFlush();
-        }
-    }
+    // ─── Stall timer ───────────────────────────────────────────────────────────
     resetStallTimer() {
         if (this.stallTimer)
             clearTimeout(this.stallTimer);
         this.stallTimer = setTimeout(() => {
-            if (this.body && !this.footer) {
+            const hasContent = this.entries.some((e) => (e.kind === "text" && e.text.length > 0) ||
+                (e.kind === "tool-start" && e.children.length > 0));
+            const hasUsage = this.entries.some((e) => e.kind === "usage");
+            if (hasContent && !hasUsage) {
                 log.warn({ sessionId: this.sessionId }, "[SessionMessage] Stream stalled — adding cutoff notice");
-                this.header = null;
-                // Use appendBody so split check is applied
-                this.appendBody("\n\n---\n_Response was cut short — the model likely reached its output token limit. Send a follow-up message to continue._");
+                this.entries.push({ id: nextId(), kind: "divider" });
+                this.entries.push({
+                    id: nextId(),
+                    kind: "text",
+                    text: "\n\n---\n_Response was cut short — the model likely reached its output token limit. Send a follow-up message to continue._",
+                });
+                this.requestFlush();
             }
         }, STALL_TIMEOUT);
         if (this.stallTimer.unref)
             this.stallTimer.unref();
     }
-    /** Finalize: clear stall timer, clear ephemeral header, do a last flush. */
+    // ─── Finalize ─────────────────────────────────────────────────────────────
     async finalize() {
+        this.stopTickInterval();
         if (this.stallTimer) {
             clearTimeout(this.stallTimer);
             this.stallTimer = undefined;
         }
-        // Clear ephemeral header on finalize; title and footer persist
-        this.header = null;
-        // Final flush
-        const composed = this.compose();
-        if (composed && composed !== this.lastSent) {
+        const card = this.buildCard();
+        const cardStr = JSON.stringify(card);
+        if (cardStr && cardStr !== this.lastSent) {
             if (!this.ref) {
-                const result = await sendText(this.context, composed);
+                const result = await sendCard(this.context, card);
                 if (result?.id) {
                     this.ref = {
                         activityId: result.id,
@@ -258,24 +463,107 @@ export class SessionMessage {
                 }
             }
             else {
-                await this.updateViaRest(composed);
+                await this.updateCardViaRest(card);
             }
-            this.lastSent = composed;
+            this.lastSent = cardStr;
         }
         return this.ref;
     }
+    /** Legacy compat — strip pattern from root text entries. */
     async stripPattern(pattern) {
-        if (!this.body)
+        for (const entry of this.entries) {
+            if (entry.kind === "text") {
+                try {
+                    entry.text = entry.text.replace(pattern, "").trim();
+                }
+                catch { /* leave unchanged */ }
+            }
+        }
+    }
+    /**
+     * Check if root text exceeds limit and split into a new message.
+     * Called from addText when a message is already sent (this.ref != null).
+     */
+    checkSplit() {
+        const rootText = this.entries
+            .filter((e) => e.kind === "text")
+            .map((e) => e.text)
+            .join("");
+        if (rootText.length <= MAX_ROOT_TEXT_LENGTH)
             return;
-        try {
-            this.body = this.body.replace(pattern, "").trim();
+        this.split();
+    }
+    /** For split: finalize current message at limit, start fresh. */
+    split() {
+        const rootText = this.entries
+            .filter((e) => e.kind === "text")
+            .map((e) => e.text)
+            .join("");
+        if (rootText.length <= MAX_ROOT_TEXT_LENGTH)
+            return;
+        let accLen = 0;
+        const entriesToKeep = [];
+        const entriesToOverflow = [];
+        for (const entry of this.entries) {
+            if (entry.kind === "text") {
+                const text = entry.text;
+                if (accLen + text.length <= MAX_ROOT_TEXT_LENGTH) {
+                    entriesToKeep.push(entry);
+                    accLen += text.length;
+                }
+                else {
+                    entriesToOverflow.push(entry);
+                }
+            }
+            else {
+                entriesToKeep.push(entry);
+            }
+        }
+        log.info({ sessionId: this.sessionId, kept: entriesToKeep.length, overflow: entriesToOverflow.length }, "[SessionMessage] splitting");
+        this.entries = entriesToKeep;
+        if (entriesToOverflow.length > 0) {
+            const overflowText = entriesToOverflow
+                .filter((e) => e.kind === "text")
+                .map((e) => e.text)
+                .join("");
+            if (overflowText) {
+                this.entries.push({ id: nextId(), kind: "text", text: overflowText });
+            }
         }
-        catch { /* leave unchanged */ }
+        if (this.ref) {
+            const card = this.buildCard();
+            this.rateLimiter.enqueue(this.conversationId, () => this.updateCardViaRest(card).then(() => { }), `update:${this.ref.activityId}`).catch(() => { });
+        }
+        this.ref = null;
+        this.lastSent = "";
+        this.requestFlush();
+    }
+    // ─── Legacy API (no-ops for compat) ────────────────────────────────────────
+    /** @deprecated — use addThought instead */
+    setHeader(_text) { }
+    /** @deprecated — use addToolResult instead */
+    setHeaderResult(_text) { }
+    /** @deprecated — use addText instead */
+    appendBody(text) {
+        this.addText(text);
+    }
+    /** @deprecated — use setUsage instead */
+    setFooter(text) {
+        this.setUsage(text);
+    }
+    /** @deprecated — use setUsage instead */
+    appendFooter(text) {
+        const current = this.getFooter();
+        this.setUsage(current ? `${current} · ${text}` : text);
     }
+    /** @deprecated — header zone is gone */
+    clearHeader() { }
+    /** @deprecated — thoughts persist, use addThought */
+    removeThought() { }
+    /** @deprecated — use addToolStart + addToolResult */
+    updateToolResult(_id, _result) { }
 }
-/**
- * Manages SessionMessage instances and plan refs across sessions.
- */
+// ─── SessionMessageManager ─────────────────────────────────────────────────────
 export class SessionMessageManager {
     rateLimiter;
     acquireBotToken;
@@ -303,7 +591,6 @@ export class SessionMessageManager {
     has(sessionId) {
         return this.messages.has(sessionId);
     }
-    /** Finalize and remove a session's message and plan ref. */
     async finalize(sessionId) {
         const msg = this.messages.get(sessionId);
         if (!msg)
@@ -312,7 +599,6 @@ export class SessionMessageManager {
         this.planRefs.delete(sessionId);
         return msg.finalize();
     }
-    /** Get or set the plan message ref for a session. */
     getPlanRef(sessionId) {
         return this.planRefs.get(sessionId);
     }
@@ -328,4 +614,15 @@ export class SessionMessageManager {
         this.planRefs.delete(sessionId);
     }
 }
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+async function sendCard(context, card) {
+    const activity = {
+        type: "message",
+        attachments: [CardFactory.adaptiveCard(card)],
+    };
+    if (typeof context.send === "function") {
+        return context.send(activity);
+    }
+    return context.sendActivity(activity);
+}
 //# sourceMappingURL=message-composer.js.map