@hahnfeld/teams-adapter 1.2.0 → 1.3.0

package/dist/adapter.js

@@ -1,27 +1,27 @@
 import { App } from "@microsoft/teams.apps";
 import { BotBuilderPlugin } from "@microsoft/teams.botbuilder";
-import { CardFactory, MemoryStorage } from "@microsoft/agents-hosting";
+import { MemoryStorage } from "@microsoft/agents-hosting";
 import { CloudAdapter, ConfigurationBotFrameworkAuthentication, } from "botbuilder";
 import { PasswordServiceClientCredentialFactory } from "botframework-connector";
-import { log, MessagingAdapter, SendQueue } from "@openacp/plugin-sdk";
-import { TeamsRenderer } from "./renderer.js";
+import { log, MessagingAdapter, BaseRenderer } from "@openacp/plugin-sdk";
 import { DEFAULT_BOT_PORT } from "./types.js";
-import { TeamsDraftManager } from "./draft-manager.js";
+import { SessionMessageManager } from "./message-composer.js";
+import { ConversationRateLimiter } from "./rate-limiter.js";
 import { PermissionHandler } from "./permissions.js";
 import { handleCommand, setupCardActionCallbacks } from "./commands/index.js";
 import { spawnAssistant } from "./assistant.js";
-import { downloadTeamsFile, isAttachmentTooLarge, buildFileAttachmentCard, uploadFileViaGraph } from "./media.js";
+import { downloadTeamsFile, isAttachmentTooLarge, uploadFileViaGraph } from "./media.js";
 import { GraphFileClient } from "./graph.js";
 import { ConversationStore } from "./conversation-store.js";
 import { sendText, sendCard, sendActivity } from "./send-utils.js";
-import { renderToolCallCard, renderPlanCard, buildCitationEntities, formatTokens } from "./formatting.js";
+import { formatTokens, formatToolSummary, formatPlan } from "./formatting.js";
 /** Max retry attempts for transient Teams API failures */
 const MAX_RETRIES = 3;
 /** Base delay (ms) for exponential backoff */
 const BASE_RETRY_DELAY = 1000;
 export class TeamsAdapter extends MessagingAdapter {
     name = "teams";
-    renderer = new TeamsRenderer();
+    renderer = new BaseRenderer();
     capabilities = {
         streaming: true,
         richFormatting: true,
@@ -33,8 +33,8 @@ export class TeamsAdapter extends MessagingAdapter {
     core;
     app;
     teamsConfig;
-    sendQueue;
-    draftManager;
+    rateLimiter;
+    composer;
     permissionHandler;
     notificationChannelId;
     assistantSession = null;
@@ -48,16 +48,6 @@ export class TeamsAdapter extends MessagingAdapter {
      */
     _sessionContexts = new Map();
     _sessionOutputModes = new Map();
-    /**
-     * Per-session serial dispatch queues — matches Telegram's _dispatchQueues pattern.
-     * SessionBridge fires sendMessage() as fire-and-forget, so multiple events can arrive
-     * concurrently. Without serialization, fast handlers overtake slow ones, causing
-     * out-of-order delivery. This queue ensures events are processed in arrival order.
-     *
-     * Entries are replaced with Promise.resolve() once their chain settles, preventing
-     * unbounded closure growth for long-lived sessions.
-     */
-    _dispatchQueues = new Map();
     /** Track processed activity IDs to handle Teams 15-second retry deduplication */
     _processedActivities = new Map();
     _processedCleanupTimer;
@@ -74,8 +64,8 @@ export class TeamsAdapter extends MessagingAdapter {
         { ...config, maxMessageLength: 25000, enabled: config.enabled ?? true });
         this.core = core;
         this.teamsConfig = config;
-        this.sendQueue = new SendQueue({ minInterval: 1000 });
-        this.draftManager = new TeamsDraftManager(this.sendQueue, () => this.acquireBotToken());
+        this.rateLimiter = new ConversationRateLimiter();
+        this.composer = new SessionMessageManager(this.rateLimiter, () => this.acquireBotToken());
         this.fileService = core.fileService;
         // Persistent conversation reference store for proactive messaging
         const storageDir = core.configManager.instanceRoot ?? process.cwd();
@@ -169,9 +159,8 @@ export class TeamsAdapter extends MessagingAdapter {
         }
         this._sessionContexts.clear();
         this._sessionOutputModes.clear();
-        this._dispatchQueues.clear();
         this._processedActivities.clear();
-        this.sendQueue.clear();
+        this.rateLimiter.destroy();
         this.conversationStore.destroy();
         this.permissionHandler.dispose();
         await this.app.stop();
@@ -348,16 +337,7 @@ export class TeamsAdapter extends MessagingAdapter {
                     return;
                 }
                 if (sessionId !== "unknown") {
-                    // Drain pending dispatches with a timeout — don't block forever if a
-                    // previous prompt hung (e.g., output token exhaustion).
-                    const pendingDispatch = this._dispatchQueues.get(sessionId);
-                    if (pendingDispatch) {
-                        await Promise.race([
-                            pendingDispatch,
-                            new Promise(resolve => setTimeout(resolve, 5000)),
-                        ]);
-                    }
-                    this.draftManager.cleanup(sessionId);
+                    this.composer.cleanup(sessionId);
                 }
                 // Show typing indicator while the agent processes the message
                 this.sendTyping(context);
@@ -967,13 +947,8 @@ export class TeamsAdapter extends MessagingAdapter {
     /**
      * Primary outbound dispatch — routes agent messages to Teams.
      *
-     * Wraps the base class `sendMessage` in a per-session promise chain (_dispatchQueues)
-     * so concurrent events fired from SessionBridge are serialized and delivered in order,
-     * preventing fast handlers from overtaking slower ones (matches Telegram pattern).
-     *
-     * Context is NOT deleted after dispatch — it persists from the inbound message handler
-     * and is available for the entire session lifetime, avoiding the race condition where
-     * async handlers lose their context mid-execution.
+     * Routes agent messages to Teams. The rate limiter handles per-conversation
+     * serialization and throttling.
      */
     async sendMessage(sessionId, content) {
         // Buffer messages during assistant initialization instead of dropping them
@@ -1030,184 +1005,134 @@ export class TeamsAdapter extends MessagingAdapter {
             }
             return;
         }
-        // Serialize dispatch per session to preserve event ordering.
-        // Read + write the queue entry atomically (synchronous) so concurrent callers
-        // always chain on the latest promise, preventing parallel execution.
-        const prev = this._dispatchQueues.get(sessionId) ?? Promise.resolve();
-        const next = prev.then(async () => {
-            try {
-                await super.sendMessage(sessionId, content);
-            }
-            catch (err) {
-                log.warn({ err, sessionId, type: content.type }, "[TeamsAdapter] Dispatch error");
-            }
-        });
-        // Set immediately — before any await — so the next concurrent caller sees this entry
-        this._dispatchQueues.set(sessionId, next);
-        await next;
-        // Replace settled chain with a fresh resolved promise to prevent unbounded
-        // closure growth for long-lived sessions. Only replace if no new work was
-        // chained while we were awaiting (i.e., the entry still points to `next`).
-        if (this._dispatchQueues.get(sessionId) === next) {
-            this._dispatchQueues.set(sessionId, Promise.resolve());
+        try {
+            await super.sendMessage(sessionId, content);
+        }
+        catch (err) {
+            log.warn({ err, sessionId, type: content.type }, "[TeamsAdapter] Dispatch error");
         }
     }
     // ─── Handler overrides ───────────────────────────────────────────────────
-    async handleThought(_sessionId, _content, _verbosity) {
-        // Thoughts are not sent as messages in Teams
+    async handleThought(sessionId, content, _verbosity) {
+        const ctx = this._sessionContexts.get(sessionId);
+        if (!ctx)
+            return;
+        const msg = this.composer.getOrCreate(sessionId, ctx.context);
+        this.ensureSessionTitle(sessionId, msg);
+        const summary = content.text?.split("\n")[0]?.slice(0, 100) || "Thinking...";
+        msg.setHeader(`💭 ${summary}`);
     }
     async handleText(sessionId, content) {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context } = ctx;
-        // Send typing indicator on first text chunk (before draft exists)
-        if (!this.draftManager.hasDraft(sessionId)) {
-            this.sendTyping(context);
-        }
-        const draft = this.draftManager.getOrCreate(sessionId, context);
+        if (!this.composer.has(sessionId))
+            this.sendTyping(ctx.context);
+        const msg = this.composer.getOrCreate(sessionId, ctx.context);
+        this.ensureSessionTitle(sessionId, msg);
         if (content.text)
-            draft.append(content.text);
+            msg.appendBody(content.text);
     }
-    async handleToolCall(sessionId, content, verbosity) {
+    async handleToolCall(sessionId, content, _verbosity) {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context, isAssistant } = ctx;
-        this.sendTyping(context);
-        await this.draftManager.finalize(sessionId, context, isAssistant);
-        try {
-            const meta = (content.metadata ?? {});
-            const cardData = renderToolCallCard({
-                id: meta.id ?? "",
-                name: meta.name ?? content.text ?? "Tool",
-                kind: meta.kind,
-                status: meta.status,
-                rawInput: meta.rawInput,
-                content: meta.content,
-                displaySummary: meta.displaySummary,
-                displayTitle: meta.displayTitle,
-                displayKind: meta.displayKind,
-                viewerLinks: meta.viewerLinks,
-                viewerFilePath: meta.viewerFilePath,
-            }, verbosity);
-            const card = { type: "AdaptiveCard", version: "1.2", ...cardData };
-            // Build citation entities for file references (hover popup with source info)
-            const citationSources = [];
-            const filePath = meta.viewerFilePath;
-            const links = meta.viewerLinks;
-            if (filePath && links?.file) {
-                citationSources.push({ name: filePath.split("/").pop() || filePath, url: links.file, abstract: `Source: ${filePath}` });
-            }
-            if (filePath && links?.diff) {
-                citationSources.push({ name: `${filePath.split("/").pop() || filePath} (diff)`, url: links.diff, abstract: `Changes to ${filePath}` });
-            }
-            const citationEntities = buildCitationEntities(citationSources);
-            // Citations require [N] markers in the text field — Teams ignores citation entities
-            // on card-only activities with no text anchor. Add a text field with markers.
-            const citationText = citationSources.length > 0
-                ? citationSources.map((s, i) => `[${i + 1}]`).join(" ")
-                : undefined;
-            await this.sendActivityWithRetry(context, {
-                ...(citationText ? { text: citationText } : {}),
-                attachments: [CardFactory.adaptiveCard(card)],
-                ...(citationEntities.length > 0 ? { entities: citationEntities } : {}),
-            });
-        }
-        catch (err) {
-            log.error({ err, sessionId }, "[TeamsAdapter] handleToolCall: sendActivity failed");
-        }
+        const msg = this.composer.getOrCreate(sessionId, ctx.context);
+        this.ensureSessionTitle(sessionId, msg);
+        const meta = (content.metadata ?? {});
+        const toolName = meta.name || content.text || "Tool";
+        const summary = formatToolSummary(toolName, meta.rawInput, meta.displaySummary);
+        msg.setHeader(`🔧 ${summary}`);
     }
-    async handleToolUpdate(sessionId, content, verbosity) {
-        // Only render tool updates in high verbosity mode (matches Telegram's tracker behavior)
-        if (verbosity !== "high")
-            return;
+    async handleToolUpdate(sessionId, content, _verbosity) {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context } = ctx;
-        try {
-            const rendered = this.renderer.renderToolUpdate(content, verbosity);
-            await this.sendActivityWithRetry(context, { text: rendered.body });
-        }
-        catch (err) {
-            log.warn({ err, sessionId }, "[TeamsAdapter] handleToolUpdate: sendActivity failed");
-        }
+        const msg = this.composer.getOrCreate(sessionId, ctx.context);
+        const meta = (content.metadata ?? {});
+        const toolName = meta.name || content.text || "";
+        // Only update header if we have meaningful content — don't overwrite with empty
+        if (!toolName && !meta.displaySummary)
+            return;
+        const summary = formatToolSummary(toolName || "Tool", meta.rawInput, meta.displaySummary);
+        msg.setHeader(`🔧 ${summary}`);
+    }
+    /** Set the session title on the composer if not already set. */
+    ensureSessionTitle(sessionId, msg) {
+        const session = this.core.sessionManager.getSession(sessionId);
+        const name = session?.name;
+        if (name)
+            msg.setTitle(name);
     }
+    /** Per-session plan send mutex to prevent TOCTOU race on first plan message. */
+    _planSending = new Set();
     async handlePlan(sessionId, content, _verbosity) {
         const ctx = this._sessionContexts.get(sessionId);
+        const planEntries = content.metadata?.entries ?? [];
         if (!ctx)
             return;
         const { context } = ctx;
-        const entries = content.metadata?.entries ?? [];
-        const mode = this.resolveMode(sessionId);
-        const cardData = renderPlanCard(entries, mode);
-        const card = { type: "AdaptiveCard", version: "1.2", ...cardData };
-        try {
-            await this.sendActivityWithRetry(context, { attachments: [CardFactory.adaptiveCard(card)] });
+        const conversationId = context.activity.conversation?.id;
+        const entries = planEntries;
+        const text = formatPlan(entries, "high");
+        const planRef = this.composer.getPlanRef(sessionId);
+        if (planRef) {
+            // Update existing plan message via rate limiter
+            await this.rateLimiter.enqueue(conversationId, async () => {
+                const token = await this.acquireBotToken();
+                if (!token)
+                    return;
+                const url = `${planRef.serviceUrl}/v3/conversations/${encodeURIComponent(planRef.conversationId)}/activities/${encodeURIComponent(planRef.activityId)}`;
+                await fetch(url, {
+                    method: "PUT",
+                    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+                    body: JSON.stringify({ type: "message", text: text.replace(/(?<!\n)\n(?!\n)/g, "\n\n"), textFormat: "markdown" }),
+                });
+            }, `plan:${sessionId}`);
         }
-        catch (err) {
-            log.error({ err, sessionId }, "[TeamsAdapter] handlePlan: sendActivity failed");
+        else {
+            // Prevent TOCTOU: if another plan event is already sending the first message, skip
+            if (this._planSending.has(sessionId))
+                return;
+            this._planSending.add(sessionId);
+            try {
+                const result = await this.rateLimiter.enqueue(conversationId, async () => {
+                    return sendText(context, text);
+                }, `plan:${sessionId}`);
+                if (result?.id) {
+                    this.composer.setPlanRef(sessionId, {
+                        activityId: result.id,
+                        conversationId,
+                        serviceUrl: context.activity.serviceUrl,
+                    });
+                }
+            }
+            catch (err) {
+                log.warn({ err, sessionId }, "[TeamsAdapter] handlePlan: send failed");
+            }
+            finally {
+                this._planSending.delete(sessionId);
+            }
         }
     }
     async handleUsage(sessionId, content, _verbosity) {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context, isAssistant } = ctx;
-        // Append usage as a subtle footer on the draft before finalizing
         const meta = content.metadata;
         if (meta?.tokensUsed != null) {
-            const draft = this.draftManager.getDraft(sessionId);
-            if (draft) {
-                const parts = [];
-                parts.push(`${formatTokens(meta.tokensUsed)} tokens`);
-                if (meta.duration != null)
-                    parts.push(`${(meta.duration / 1000).toFixed(1)}s`);
-                if (meta.cost != null)
-                    parts.push(`$${meta.cost.toFixed(4)}`);
-                draft.append(`\n\n---\n*${parts.join(" · ")}*`);
-            }
-        }
-        // Grab the draft ref before finalize (finalize deletes the draft from the map)
-        const draft = this.draftManager.getDraft(sessionId);
-        await this.draftManager.finalize(sessionId, context, isAssistant);
-        const finalRef = draft?.getFinalRef();
-        // In DMs, edit the last message to append "Task completed" to the usage footer.
-        // In channels, send a separate notification to the notification channel.
-        const convType = context.activity?.conversation?.conversationType;
-        if (convType === "personal" && finalRef) {
-            // Edit the last message's usage footer in-place
-            void (async () => {
-                try {
-                    const botToken = await this.acquireBotToken();
-                    if (!botToken)
-                        return;
-                    const updatedText = finalRef.text.replace(/(\n---\n\*.+)\*\s*$/, `$1 · Task completed*`);
-                    if (updatedText === finalRef.text)
-                        return;
-                    const url = `${finalRef.serviceUrl}/v3/conversations/${encodeURIComponent(finalRef.conversationId)}/activities/${encodeURIComponent(finalRef.activityId)}`;
-                    await fetch(url, {
-                        method: "PUT",
-                        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${botToken}` },
-                        body: JSON.stringify({ type: "message", text: updatedText.replace(/(?<!\n)\n(?!\n)/g, "\n\n"), textFormat: "markdown" }),
-                    });
-                    // Best effort — result not checked
-                }
-                catch {
-                    // Best effort — user already sees the usage footer
-                }
-            })();
-        }
-        else if (this.notificationChannelId && sessionId !== this.assistantSession?.id) {
-            const sess = this.core.sessionManager.getSession(sessionId);
-            const name = sess?.name || "Session";
-            void this.sendNotification({
-                sessionId,
-                sessionName: name,
-                type: "completed",
-                summary: "Task completed",
-            });
+            const msg = this.composer.getOrCreate(sessionId, ctx.context);
+            const parts = [];
+            parts.push(`${formatTokens(meta.tokensUsed)} tokens`);
+            if (meta.duration != null)
+                parts.push(`${(meta.duration / 1000).toFixed(1)}s`);
+            if (meta.cost != null)
+                parts.push(`$${meta.cost.toFixed(4)}`);
+            parts.push("Task completed");
+            const footerText = parts.join(" · ");
+            msg.setFooter(footerText);
+            // Usage signals end of a turn — clear ephemeral header
+            msg.clearHeader();
         }
     }
     /** Suggested quick-reply actions (Teams restricts these to 1:1 personal chat only) */
@@ -1230,20 +1155,14 @@ export class TeamsAdapter extends MessagingAdapter {
         return {};
     }
     /**
-     * Clean up all per-session state (contexts, drafts, dispatch queues, output modes).
-     * Removes both sessionId and threadId entries from _sessionContexts to prevent leaks.
+     * Clean up all per-session state (contexts, composer, output modes).
      */
     cleanupSessionState(sessionId) {
-        // Find and remove the threadId entry that may also reference this session's context.
-        // First try the stored threadId on the context entry itself (reliable even if the
-        // session has already been removed from the session manager).
         const entry = this._sessionContexts.get(sessionId);
         const storedThreadId = entry?.threadId;
         if (storedThreadId && storedThreadId !== sessionId) {
             this._sessionContexts.delete(storedThreadId);
         }
-        // Fallback: also check session manager and session record in case the context entry
-        // was already removed or the threadId wasn't stored.
         const session = this.core.sessionManager.getSession(sessionId);
         const threadId = session?.threadId;
         if (threadId && threadId !== sessionId && threadId !== storedThreadId) {
@@ -1256,28 +1175,30 @@ export class TeamsAdapter extends MessagingAdapter {
         }
         this._sessionContexts.delete(sessionId);
         this._sessionOutputModes.delete(sessionId);
-        this._dispatchQueues.delete(sessionId);
-        this.draftManager.cleanup(sessionId);
+        this._planSending.delete(sessionId);
+        this.composer.cleanup(sessionId);
     }
     async handleSessionEnd(sessionId, _content) {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context, isAssistant } = ctx;
-        await this.draftManager.finalize(sessionId, context, isAssistant);
+        const msg = this.composer.get(sessionId);
+        if (msg) {
+            msg.appendFooter("Task completed");
+        }
+        const ref = await this.composer.finalize(sessionId);
         this.cleanupSessionState(sessionId);
     }
     async handleError(sessionId, content) {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context, isAssistant } = ctx;
-        await this.draftManager.finalize(sessionId, context, isAssistant);
+        await this.composer.finalize(sessionId);
         this.cleanupSessionState(sessionId);
         try {
-            await this.sendActivityWithRetry(context, {
+            await this.sendActivityWithRetry(ctx.context, {
                 text: `❌ **Error:** ${content.text}`,
-                ...this.getQuickActions(context),
+                ...this.getQuickActions(ctx.context),
             });
         }
         catch { /* best effort */ }
@@ -1289,33 +1210,29 @@ export class TeamsAdapter extends MessagingAdapter {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context, isAssistant } = ctx;
-        // Strip TTS markers from the draft BEFORE finalizing — finalize() deletes
-        // the draft from the map, so getDraft() would return undefined after it.
+        // Strip TTS markers from body before sending attachment
         if (attachment.type === "audio") {
-            const draft = this.draftManager.getDraft(sessionId);
-            if (draft) {
-                await draft.stripPattern(/\[TTS\][\s\S]*?\[\/TTS\]/g).catch((err) => {
-                    log.warn({ err, sessionId }, "[TeamsAdapter] handleAttachment: stripPattern failed");
-                });
+            const msg = this.composer.get(sessionId);
+            if (msg) {
+                await msg.stripPattern(/\[TTS\][\s\S]*?\[\/TTS\]/g).catch(() => { });
             }
         }
-        await this.draftManager.finalize(sessionId, context, isAssistant);
         if (isAttachmentTooLarge(attachment.size)) {
             log.warn({ sessionId, fileName: attachment.fileName, size: attachment.size }, "[TeamsAdapter] File too large");
-            try {
-                await this.sendActivityWithRetry(context, {
-                    text: `⚠️ File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${attachment.fileName}`,
-                });
-            }
-            catch { /* best effort */ }
+            const msg = this.composer.getOrCreate(sessionId, ctx.context);
+            msg.appendBody(`\n\n⚠️ File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${attachment.fileName}`);
             return;
         }
         try {
-            // Upload to OneDrive via Graph API if available, get a sharing URL
             const shareUrl = await uploadFileViaGraph(this.graphClient, sessionId, attachment.filePath, attachment.fileName, attachment.mimeType);
-            const card = buildFileAttachmentCard(attachment.fileName, attachment.size, attachment.mimeType, shareUrl ?? undefined);
-            await this.sendActivityWithRetry(context, { attachments: [CardFactory.adaptiveCard(card)] });
+            // Append file info inline in the body
+            const msg = this.composer.getOrCreate(sessionId, ctx.context);
+            if (shareUrl) {
+                msg.appendBody(`\n\n📎 [${attachment.fileName}](${shareUrl})`);
+            }
+            else {
+                msg.appendBody(`\n\n📎 ${attachment.fileName} (${Math.round(attachment.size / 1024)}KB)`);
+            }
         }
         catch (err) {
             log.error({ err, sessionId, fileName: attachment.fileName }, "[TeamsAdapter] Failed to send attachment");
@@ -1327,20 +1244,22 @@ export class TeamsAdapter extends MessagingAdapter {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const { context } = ctx;
         try {
-            await this.sendActivityWithRetry(context, { text: content.text });
+            await this.sendActivityWithRetry(ctx.context, { text: `⚙️ ${content.text}` });
         }
         catch { /* best effort */ }
     }
+    /** Sanitize metadata strings for safe markdown interpolation. */
+    static sanitizeMd(text) {
+        return text.replace(/[*_~`[\]()\\]/g, "").slice(0, 200);
+    }
     async handleModeChange(sessionId, content) {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const renderer = this.renderer;
-        const rendered = renderer.renderModeChange(content);
+        const modeId = TeamsAdapter.sanitizeMd(String(content.metadata?.modeId ?? ""));
         try {
-            await this.sendActivityWithRetry(ctx.context, { text: rendered.body });
+            await this.sendActivityWithRetry(ctx.context, { text: `⚙️ **Mode:** ${modeId}` });
         }
         catch { /* best effort */ }
     }
@@ -1348,10 +1267,10 @@ export class TeamsAdapter extends MessagingAdapter {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const renderer = this.renderer;
-        const rendered = renderer.renderConfigUpdate(content);
+        const key = content.metadata?.key;
+        const detail = key ? ` \`${TeamsAdapter.sanitizeMd(String(key))}\`` : "";
         try {
-            await this.sendActivityWithRetry(ctx.context, { text: rendered.body });
+            await this.sendActivityWithRetry(ctx.context, { text: `⚙️ **Config updated**${detail}` });
         }
         catch { /* best effort */ }
     }
@@ -1359,10 +1278,9 @@ export class TeamsAdapter extends MessagingAdapter {
         const ctx = this._sessionContexts.get(sessionId);
         if (!ctx)
             return;
-        const renderer = this.renderer;
-        const rendered = renderer.renderModelUpdate(content);
+        const modelId = TeamsAdapter.sanitizeMd(String(content.metadata?.modelId ?? ""));
         try {
-            await this.sendActivityWithRetry(ctx.context, { text: rendered.body });
+            await this.sendActivityWithRetry(ctx.context, { text: `⚙️ **Model:** ${modelId}` });
         }
         catch { /* best effort */ }
     }
@@ -1394,9 +1312,7 @@ export class TeamsAdapter extends MessagingAdapter {
             return;
         const rawUrl = content.metadata?.url;
         const rawName = content.metadata?.name;
-        // Only allow http/https URLs to prevent javascript: or data: scheme injection
         const url = rawUrl && /^https?:\/\//i.test(rawUrl) ? rawUrl : undefined;
-        // Sanitize name to prevent markdown injection — strip characters that break link syntax
         const name = rawName?.replace(/[\[\]\(\)]/g, "") || undefined;
         const text = url ? `📎 [${name || url}](${url})` : content.text;
         try {
@@ -1569,7 +1485,12 @@ export class TeamsAdapter extends MessagingAdapter {
             });
         }
         catch { /* best effort */ }
-        log.debug({ sessionId, newName }, "[TeamsAdapter] renameSessionThread — name stored locally (Teams API does not support conversation rename)");
+        // Update the main message title if the session has an active composer
+        const msg = this.composer.get(sessionId);
+        if (msg && newName) {
+            msg.setTitle(newName);
+        }
+        log.debug({ sessionId, newName }, "[TeamsAdapter] renameSessionThread — title updated");
     }
     async deleteSessionThread(sessionId) {
         const record = this.core.sessionManager.getSessionRecord(sessionId);