@hahnfeld/teams-adapter 1.4.1 → 1.5.0

package/dist/message-composer.js

@@ -1,30 +1,93 @@
 import { log } from "@openacp/plugin-sdk";
 import { CardFactory } from "@microsoft/agents-hosting";
+// ─── Constants ────────────────────────────────────────────────────────────────
 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 ─────────────────────────────────────────────────────────────
+// ─── ID generation ────────────────────────────────────────────────────────────
 let _idCounter = 0;
 function nextId() {
     return `e${++_idCounter}_${Date.now().toString(36)}`;
 }
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+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`;
+}
+export function escapeMd(text) {
+    return text.replace(/\[/g, "\\[").replace(/\*/g, "\\*").replace(/\]/g, "\\]");
+}
+const PLAN_STATUS_ICONS = {
+    completed: "✅",
+    in_progress: "🔄",
+    pending: "⏳",
+};
 // ─── Adaptive Card Builder ────────────────────────────────────────────────────
+/**
+ * Build a 2-column ColumnSet for level-1 headings.
+ * Column 1: emoji (auto), Column 2: text (stretch, wrap).
+ * Ensures long text wraps without breaking back to the left margin.
+ */
+export function buildLevel1(emoji, text) {
+    return {
+        type: "ColumnSet",
+        spacing: "None",
+        columns: [
+            {
+                type: "Column",
+                width: "auto",
+                items: [{ type: "TextBlock", text: emoji, size: "Small", fontType: "Monospace", spacing: "None" }],
+                verticalContentAlignment: "Top",
+            },
+            {
+                type: "Column",
+                width: "stretch",
+                items: [{ type: "TextBlock", text, size: "Small", fontType: "Monospace", wrap: true, spacing: "None" }],
+            },
+        ],
+    };
+}
+/**
+ * Build a 3-column ColumnSet for indented level-2 content.
+ * Column 1: spacer (20px), Column 2: ⎿ (auto), Column 3: content (stretch, wrap).
+ */
+export function buildLevel2(text, elapsed, raw = false) {
+    const escaped = raw ? text : escapeMd(text);
+    const content = elapsed ? `${escaped}  (${elapsed})` : escaped;
+    return {
+        type: "ColumnSet",
+        spacing: "None",
+        columns: [
+            { type: "Column", width: "20px" },
+            {
+                type: "Column",
+                width: "auto",
+                items: [{
+                        type: "TextBlock",
+                        text: "⎿",
+                        size: "Small",
+                        fontType: "Monospace",
+                        spacing: "None",
+                    }],
+                verticalContentAlignment: "Top",
+            },
+            {
+                type: "Column",
+                width: "stretch",
+                items: [{
+                        type: "TextBlock",
+                        text: content,
+                        size: "Small",
+                        fontType: "Monospace",
+                        wrap: true,
+                        spacing: "None",
+                    }],
+            },
+        ],
+    };
+}
 function buildCardBody(entries) {
     const blocks = [];
     const now = Date.now();
@@ -40,45 +103,28 @@ function buildCardBody(entries) {
                     spacing: "None",
                 });
                 break;
-            case "tool": {
+            case "timed": {
                 const elapsed = entry.result
                     ? formatElapsed((entry.endedAt ?? entry.startedAt) - entry.startedAt)
                     : formatElapsed(now - entry.startedAt);
+                const headingText = entry.result
+                    ? escapeMd(entry.label)
+                    : `${escapeMd(entry.label)}…  (${elapsed})`;
+                const items = [buildLevel1(entry.emoji, headingText)];
+                if (entry.result) {
+                    items.push(buildLevel2(entry.result, elapsed));
+                }
+                blocks.push({ type: "Container", items, spacing: "Small" });
+                break;
+            }
+            case "info": {
                 blocks.push({
                     type: "Container",
                     items: [
-                        {
-                            type: "TextBlock",
-                            text: entry.result
-                                ? `🔧 ${escapeMd(entry.toolName)}`
-                                : `🔧 ${escapeMd(entry.toolName)}…  (${elapsed})`,
-                            size: "Small",
-                            fontType: "Monospace",
-                            spacing: "None",
-                        },
-                        // Result: indented with L-shaped bar
-                        ...(entry.result
-                            ? [{
-                                    type: "TextBlock",
-                                    text: `\u00A0\u00A0⎿ ${escapeMd(entry.result)}  (${elapsed})`,
-                                    size: "Small",
-                                    fontType: "Monospace",
-                                    wrap: true,
-                                    spacing: "None",
-                                }]
-                            : []),
-                        // Children: further indented
-                        ...entry.children.map((c) => ({
-                            type: "TextBlock",
-                            text: `\u00A0\u00A0\u00A0\u00A0\u00A0\u00A0${c.text}`,
-                            size: "Small",
-                            fontType: "Monospace",
-                            wrap: true,
-                            spacing: "None",
-                        })),
+                        buildLevel1(entry.emoji, escapeMd(entry.label)),
+                        buildLevel2(entry.detail),
                     ],
-                    padding: "Small",
-                    width: "stretch",
+                    spacing: "Small",
                 });
                 break;
             }
@@ -92,11 +138,22 @@ function buildCardBody(entries) {
                     spacing: "None",
                 });
                 break;
-            case "thought":
+            case "plan": {
+                const lines = entry.entries.map((e, i) => `${PLAN_STATUS_ICONS[e.status] || "⏳"} ${i + 1}. ${escapeMd(e.content)}`);
+                blocks.push({
+                    type: "TextBlock",
+                    text: `📋 Plan\n${lines.join("\n")}`,
+                    size: "Small",
+                    fontType: "Monospace",
+                    wrap: true,
+                    spacing: "Small",
+                });
+                break;
+            }
+            case "resource":
                 blocks.push({
                     type: "TextBlock",
                     text: entry.text,
-                    italic: true,
                     size: "Small",
                     fontType: "Monospace",
                     wrap: true,
@@ -107,7 +164,7 @@ function buildCardBody(entries) {
                 blocks.push({
                     type: "TextBlock",
                     text: `*${escapeMd(entry.text)}*`,
-                    italic: true,
+                    isSubtle: true,
                     size: "Small",
                     fontType: "Monospace",
                     spacing: "None",
@@ -126,17 +183,9 @@ function buildCardBody(entries) {
     }
     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, "\\]");
-}
-// ─── SessionMessage ────────────────────────────────────────────────────────────
+// ─── SessionMessage ───────────────────────────────────────────────────────────
+/** Dot animation frames: Working. → Working.. → Working... → Working.. → repeat */
+const WORKING_FRAMES = ["Working.", "Working..", "Working...", "Working.."];
 export class SessionMessage {
     context;
     conversationId;
@@ -146,19 +195,31 @@ export class SessionMessage {
     entries = [];
     titleId = null;
     usageId = null;
-    /** The active tool whose children accumulate streaming output */
-    toolActive = null;
+    planId = null;
+    thinkingActive = null;
+    thinkingText = "";
+    working = true;
+    workingFrame = 0;
+    destroyed = false;
     ref = null;
     lastSent = "";
     stallTimer;
-    /** Interval handle for periodic elapsed-time updates on running tools */
     tickInterval;
+    emptyCardTimer;
     constructor(context, conversationId, sessionId, rateLimiter, acquireBotToken) {
         this.context = context;
         this.conversationId = conversationId;
         this.sessionId = sessionId;
         this.rateLimiter = rateLimiter;
         this.acquireBotToken = acquireBotToken;
+        // Start the working animation immediately
+        this.usageId = nextId();
+        this.entries.push({ id: this.usageId, kind: "usage", text: WORKING_FRAMES[0] });
+        this.startTickInterval();
+        // If no real content arrives within 30s, delete the empty card
+        this.emptyCardTimer = setTimeout(() => this.deleteIfEmpty(), 30_000);
+        if (this.emptyCardTimer.unref)
+            this.emptyCardTimer.unref();
     }
     updateContext(context) {
         this.context = context;
@@ -176,9 +237,46 @@ export class SessionMessage {
         const usage = this.entries.find((e) => e.kind === "usage");
         return usage ? usage.text : null;
     }
-    // ─── Entry API ───────────────────────────────────────────────────────────
-    /** Set the persistent session title (bold, survives finalize). */
+    // ─── Empty card cleanup ──────────────────────────────────────────────────
+    /** Cancel the empty-card timer (called when real content arrives). */
+    cancelEmptyCardTimer() {
+        if (this.emptyCardTimer) {
+            clearTimeout(this.emptyCardTimer);
+            this.emptyCardTimer = undefined;
+        }
+    }
+    /** If no real content was added, delete the card activity and clean up. */
+    async deleteIfEmpty() {
+        this.emptyCardTimer = undefined;
+        if (this.entries.some((e) => e.kind !== "usage"))
+            return;
+        this.destroyed = true;
+        // Delete the card activity if it was sent
+        if (this.ref) {
+            const token = await this.acquireBotToken();
+            // Re-check after await — content may have arrived while token was fetched
+            if (this.entries.some((e) => e.kind !== "usage")) {
+                this.destroyed = false;
+                return;
+            }
+            if (token) {
+                const url = `${this.ref.serviceUrl}/v3/conversations/${encodeURIComponent(this.ref.conversationId)}/activities/${encodeURIComponent(this.ref.activityId)}`;
+                try {
+                    await fetch(url, { method: "DELETE", headers: { "Authorization": `Bearer ${token}` } });
+                }
+                catch { /* best effort */ }
+            }
+            this.ref = null;
+        }
+        this.stopTickInterval();
+        this.working = false;
+        this.entries = [];
+        log.debug({ sessionId: this.sessionId }, "[SessionMessage] Empty card deleted after timeout");
+    }
+    // ─── Entry API ──────────────────────────────────────────────────────────
+    /** Set the persistent session title (bold, always first entry). */
     setTitle(text) {
+        this.cancelEmptyCardTimer();
         if (this.titleId) {
             const entry = this.findEntry(this.titleId);
             if (entry && entry.kind === "title")
@@ -191,59 +289,94 @@ export class SessionMessage {
         this.requestFlush();
     }
     /**
-     * Add a tool-progress entry (🔄 Running...). Sets toolActive so subsequent
-     * addText() calls route children here. Returns entry id for tracking.
+     * Start a timed entry (tool or thinking). Shows emoji + label with live elapsed timer.
+     * Returns the entry ID for pairing with addTimedResult().
      */
-    addToolStart(toolName, _params) {
+    addTimedStart(emoji, label) {
+        this.cancelEmptyCardTimer();
         const id = nextId();
-        const startedAt = Date.now();
-        this.entries.push({ id, kind: "tool", toolName, startedAt, children: [] });
-        this.toolActive = id;
+        this.entries.push({ id, kind: "timed", emoji, label, startedAt: Date.now() });
         this.resetStallTimer();
         this.startTickInterval();
         this.requestFlush();
         return id;
     }
     /**
-     * Append result to the tool entry (transforms it from running to complete).
-     * Subsequent text goes to the same entry's children.
+     * Close a timed entry by setting its result. Stops the tick interval if no
+     * other timed entries are still running.
      */
-    addToolResult(id, result) {
-        const entry = this.entries.find((e) => e.id === id);
-        if (!entry || entry.kind !== "tool") {
-            // Entry not found — create a standalone tool entry
-            const startedAt = Date.now();
-            this.entries.push({ id: nextId(), kind: "tool", toolName: "", startedAt, result, endedAt: startedAt, children: [] });
-            this.toolActive = null;
+    addTimedResult(id, result) {
+        const entry = this.findEntry(id);
+        if (entry && entry.kind === "timed") {
+            entry.result = result;
+            entry.endedAt = Date.now();
+        }
+        else {
+            // Orphan result — create a standalone completed entry
+            this.entries.push({ id: nextId(), kind: "timed", emoji: "🔧", label: result, startedAt: Date.now(), result, endedAt: Date.now() });
+        }
+        const hasRunning = this.entries.some((e) => e.kind === "timed" && !e.result);
+        if (!hasRunning)
             this.stopTickInterval();
-            this.requestFlush();
-            return;
+        this.requestFlush();
+    }
+    /**
+     * Start or accumulate thinking text. The first call creates a timed entry;
+     * subsequent calls append to the pending result text. Call closeActiveThinking()
+     * to finalize.
+     */
+    addThinking(text) {
+        this.cancelEmptyCardTimer();
+        if (!this.thinkingActive) {
+            const id = this.addTimedStart("☁️", "Thinking");
+            this.thinkingActive = id;
+            this.thinkingText = text;
+        }
+        else {
+            this.thinkingText += ` ${text}`;
         }
-        entry.result = result;
-        entry.endedAt = Date.now();
-        this.toolActive = null; // Subsequent text goes to root level
-        this.stopTickInterval();
         this.requestFlush();
     }
-    /** Add text — goes to toolActive children if a tool is running, else root text entry. */
-    addText(text) {
-        if (!text)
+    /**
+     * Close the active thinking entry (if any). Called by non-thought handlers
+     * so thinking ends when the next event type arrives.
+     */
+    closeActiveThinking() {
+        if (!this.thinkingActive)
             return;
-        if (this.toolActive) {
-            const entry = this.findEntry(this.toolActive);
-            if (entry && entry.kind === "tool") {
-                entry.children.push({ text });
-                this.resetStallTimer();
+        const text = this.thinkingText.trim() || "…";
+        this.addTimedResult(this.thinkingActive, text);
+        this.thinkingActive = null;
+        this.thinkingText = "";
+    }
+    /** Add a one-shot info entry (error, system, mode, config, model). */
+    addInfo(emoji, label, detail) {
+        this.cancelEmptyCardTimer();
+        this.entries.push({ id: nextId(), kind: "info", emoji, label, detail });
+        this.requestFlush();
+    }
+    /** Add or replace the plan entry. */
+    setPlan(entries) {
+        this.cancelEmptyCardTimer();
+        if (this.planId) {
+            const entry = this.findEntry(this.planId);
+            if (entry && entry.kind === "plan") {
+                entry.entries = entries;
                 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
+        this.planId = nextId();
+        this.entries.push({ id: this.planId, kind: "plan", entries });
+        this.requestFlush();
+    }
+    /** Add text — always appended at root level. */
+    addText(text) {
+        if (!text)
+            return;
+        this.cancelEmptyCardTimer();
         const lastText = this.entries.filter((e) => e.kind === "text").at(-1);
-        if (lastText) {
+        if (lastText && lastText.kind === "text") {
             lastText.text += text;
         }
         else {
@@ -251,29 +384,18 @@ export class SessionMessage {
         }
         this.resetStallTimer();
         this.requestFlush();
-        // Check for overflow after root text grows
         if (this.ref)
             this.checkSplit();
     }
-    /**
-     * Append text to the last thought entry, or create a new one if none exists.
-     * If text starts with "Thinking..." and it's a fresh entry, wrap with newlines.
-     * Subsequent chunks are appended as plain text with no bubble prefix.
-     */
-    addThought(text) {
-        const thoughts = this.entries.filter((e) => e.kind === "thought");
-        const last = thoughts[thoughts.length - 1];
-        if (last) {
-            // Add a space between consecutive chunks so they don't run together
-            last.text += ` ${text}`;
-        }
-        else {
-            this.entries.push({ id: nextId(), kind: "thought", text });
-        }
+    /** Add an inline resource line (📎 prefix). */
+    addResource(text) {
+        this.cancelEmptyCardTimer();
+        this.entries.push({ id: nextId(), kind: "resource", text });
         this.requestFlush();
     }
-    /** Set or replace the usage entry (only one at a time). */
+    /** Set or replace the usage footer. Stops the working animation. */
     setUsage(text) {
+        this.working = false;
         if (this.usageId) {
             const entry = this.findEntry(this.usageId);
             if (entry && entry.kind === "usage")
@@ -283,6 +405,9 @@ export class SessionMessage {
             this.usageId = nextId();
             this.entries.push({ id: this.usageId, kind: "usage", text });
         }
+        const hasRunning = this.entries.some((e) => e.kind === "timed" && !e.result);
+        if (!hasRunning)
+            this.stopTickInterval();
         this.requestFlush();
     }
     /** Add a divider entry. */
@@ -290,29 +415,24 @@ export class SessionMessage {
         this.entries.push({ id: nextId(), kind: "divider" });
         this.requestFlush();
     }
-    // ─── Entry helpers ────────────────────────────────────────────────────────
+    // ─── 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);
+        return this.entries.find((e) => e.id === id);
     }
-    // ─── Periodic tick for elapsed time updates ───────────────────────────────
-    /**
-     * 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.
-     */
+    // ─── Periodic tick for elapsed time updates ─────────────────────────────
     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" && !e.result);
-            if (!hasRunningTool) {
+            // Advance working dots animation
+            if (this.working && this.usageId) {
+                this.workingFrame = (this.workingFrame + 1) % WORKING_FRAMES.length;
+                const entry = this.findEntry(this.usageId);
+                if (entry && entry.kind === "usage")
+                    entry.text = WORKING_FRAMES[this.workingFrame];
+            }
+            const hasRunning = this.entries.some((e) => e.kind === "timed" && !e.result);
+            if (!hasRunning && !this.working) {
                 this.stopTickInterval();
                 return;
             }
@@ -327,27 +447,23 @@ export class SessionMessage {
             this.tickInterval = undefined;
         }
     }
-    // ─── Card building ─────────────────────────────────────────────────────────
+    // ─── 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
+            body: body.length > 0 ? body : [{ type: "TextBlock", text: "…" }],
             width: "stretch",
         };
     }
-    // ─── Flush / Rate limiting ─────────────────────────────────────────────────
+    // ─── Flush / Rate limiting ──────────────────────────────────────────────
     flushTimer;
     requestFlush() {
         if (this.flushTimer)
             clearTimeout(this.flushTimer);
         this.flushTimer = setTimeout(() => {
             this.flushTimer = undefined;
-            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");
@@ -355,6 +471,8 @@ export class SessionMessage {
         }, 500);
     }
     async flush() {
+        if (this.destroyed)
+            return;
         const card = this.buildCard();
         const cardStr = JSON.stringify(card);
         if (!cardStr || cardStr === this.lastSent)
@@ -372,9 +490,8 @@ export class SessionMessage {
         }
         else {
             const success = await this.updateCardViaRest(card);
-            if (success) {
+            if (success)
                 this.lastSent = cardStr;
-            }
         }
         // Content arrived while flushing — request another flush
         const current = this.buildCard();
@@ -392,10 +509,7 @@ export class SessionMessage {
         try {
             const response = await fetch(url, {
                 method: "PUT",
-                headers: {
-                    "Content-Type": "application/json",
-                    "Authorization": `Bearer ${token}`,
-                },
+                headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
                 body: JSON.stringify({
                     type: "message",
                     attachments: [CardFactory.adaptiveCard(card)],
@@ -412,13 +526,12 @@ export class SessionMessage {
             return false;
         }
     }
-    // ─── Stall timer ───────────────────────────────────────────────────────────
+    // ─── Stall timer ────────────────────────────────────────────────────────
     resetStallTimer() {
         if (this.stallTimer)
             clearTimeout(this.stallTimer);
         this.stallTimer = setTimeout(() => {
-            const hasContent = this.entries.some((e) => (e.kind === "text" && e.text.length > 0) ||
-                (e.kind === "tool" && e.children.length > 0));
+            const hasContent = this.entries.some((e) => e.kind === "text" && e.text.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");
@@ -434,9 +547,16 @@ export class SessionMessage {
         if (this.stallTimer.unref)
             this.stallTimer.unref();
     }
-    // ─── Finalize ─────────────────────────────────────────────────────────────
+    // ─── Finalize ───────────────────────────────────────────────────────────
     async finalize() {
+        this.cancelEmptyCardTimer();
+        this.closeActiveThinking();
+        this.working = false;
         this.stopTickInterval();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+        }
         if (this.stallTimer) {
             clearTimeout(this.stallTimer);
             this.stallTimer = undefined;
@@ -461,7 +581,7 @@ export class SessionMessage {
         }
         return this.ref;
     }
-    /** Legacy compat — strip pattern from root text entries. */
+    /** Strip a pattern from root text entries. */
     async stripPattern(pattern) {
         for (const entry of this.entries) {
             if (entry.kind === "text") {
@@ -472,10 +592,7 @@ export class SessionMessage {
             }
         }
     }
-    /**
-     * Check if root text exceeds limit and split into a new message.
-     * Called from addText when a message is already sent (this.ref != null).
-     */
+    // ─── Text overflow / split ──────────────────────────────────────────────
     checkSplit() {
         const rootText = this.entries
             .filter((e) => e.kind === "text")
@@ -485,7 +602,6 @@ export class SessionMessage {
             return;
         this.split();
     }
-    /** For split: finalize current message at limit, start fresh. */
     split() {
         const rootText = this.entries
             .filter((e) => e.kind === "text")
@@ -494,73 +610,51 @@ export class SessionMessage {
         if (rootText.length <= MAX_ROOT_TEXT_LENGTH)
             return;
         let accLen = 0;
-        const entriesToKeep = [];
-        const entriesToOverflow = [];
+        const keep = [];
+        const overflow = [];
         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;
+                if (accLen + entry.text.length <= MAX_ROOT_TEXT_LENGTH) {
+                    keep.push(entry);
+                    accLen += entry.text.length;
                 }
                 else {
-                    entriesToOverflow.push(entry);
+                    overflow.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 });
+                keep.push(entry);
             }
         }
+        log.info({ sessionId: this.sessionId, kept: keep.length, overflow: overflow.length }, "[SessionMessage] splitting");
+        const overflowText = overflow
+            .filter((e) => e.kind === "text")
+            .map((e) => e.text)
+            .join("");
+        // Update the old card with only the kept entries (no overflow)
+        this.entries = keep;
         if (this.ref) {
             const card = this.buildCard();
             this.rateLimiter.enqueue(this.conversationId, () => this.updateCardViaRest(card).then(() => { }), `update:${this.ref.activityId}`).catch(() => { });
         }
+        // Start a new card with only the overflow text — reset all entry ID references
+        // so subsequent calls create new entries in the new card
         this.ref = null;
         this.lastSent = "";
+        this.titleId = null;
+        this.usageId = null;
+        this.planId = null;
+        this.entries = overflowText
+            ? [{ id: nextId(), kind: "text", text: overflowText }]
+            : [];
         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) { }
 }
-// ─── SessionMessageManager ─────────────────────────────────────────────────────
+// ─── SessionMessageManager ────────────────────────────────────────────────────
 export class SessionMessageManager {
     rateLimiter;
     acquireBotToken;
     messages = new Map();
-    planRefs = new Map();
     constructor(rateLimiter, acquireBotToken) {
         this.rateLimiter = rateLimiter;
         this.acquireBotToken = acquireBotToken;
@@ -588,25 +682,16 @@ export class SessionMessageManager {
         if (!msg)
             return null;
         this.messages.delete(sessionId);
-        this.planRefs.delete(sessionId);
         return msg.finalize();
     }
-    getPlanRef(sessionId) {
-        return this.planRefs.get(sessionId);
-    }
-    setPlanRef(sessionId, ref) {
-        this.planRefs.set(sessionId, ref);
-    }
     cleanup(sessionId) {
         const msg = this.messages.get(sessionId);
-        if (msg) {
+        if (msg)
             msg.finalize().catch(() => { });
-        }
         this.messages.delete(sessionId);
-        this.planRefs.delete(sessionId);
     }
 }
-// ─── Helpers ───────────────────────────────────────────────────────────────────
+// ─── Helpers ──────────────────────────────────────────────────────────────────
 async function sendCard(context, card) {
     const activity = {
         type: "message",