@dbx-tools/teams 0.3.44 → 0.4.1

package/lib/src/conversation.js

@@ -0,0 +1,509 @@
+/**
+ * The Teams conversation turn: run a Mastra agent against an inbound Bot
+ * Framework activity and answer with Adaptive Card attachments.
+ *
+ * This is the piece that makes `POST /api/teams/activity` behave like a Teams
+ * bot rather than a chat API that happens to return JSON. A turn is:
+ *
+ *   1. read the user's text off the inbound `message` activity;
+ *   2. ANSWER it - a normal tool-using agent turn, with no mention of cards, so
+ *      the agent queries Genie / calls its tools exactly as it would on a
+ *      streaming chat endpoint;
+ *   3. FORMAT that answer into a {@link card.CardSpec} in a second pass, via
+ *      Mastra's `structuredOutput` (prompt-injected, see
+ *      {@link JSON_PROMPT_INJECTION});
+ *   4. compile the spec with the same deterministic builder the
+ *      `create_teams_card` tool uses, and attach it to an outbound activity.
+ *
+ * The two passes are the important part. Asking for the answer AND the card
+ * shape in ONE request makes the model treat formatting as the task: it emits a
+ * card straight away and never calls its tools, so a question that should have
+ * queried a data source came back as "I don't have a real system connected -
+ * here is a template card with placeholders". Answering first, then formatting a
+ * REAL answer, makes this endpoint's content identical to the streaming
+ * endpoint's; only the presentation differs.
+ *
+ * Formatting is also why the turn does not simply rely on the agent calling
+ * `create_teams_card`: on this endpoint a card IS the response format, so it
+ * should be a property of the turn rather than a tool the model may forget.
+ * Agents keep the tool for the other direction - answering in prose on a normal
+ * chat endpoint and choosing to attach a card. When the agent DOES call it
+ * during the answering pass, that spec wins and the formatting pass is skipped.
+ *
+ * The conversation id doubles as the agent's memory thread id, so a client that
+ * keeps posting the same `conversation.id` gets a continuous conversation - the
+ * same mapping a real channel relies on.
+ *
+ * @module
+ */
+import { error, hash, json, log, object, string } from "@dbx-tools/shared-core";
+import { activity as activityContract, card } from "@dbx-tools/shared-teams";
+import { buildAdaptiveCard } from "./builder.js";
+const logger = log.logger("teams:conversation");
+/** Tool id whose arguments are already a {@link card.CardSpec}. */
+const CARD_TOOL_NAMES = ["create_teams_card", "createCard"];
+/**
+ * The card spec an agent passed to the card tool, if it called it.
+ *
+ * Mastra nests a tool result under `payload` (`{ payload: { toolName, args } }`)
+ * but has used a flat shape too, so both are read.
+ */
+const toolCardSpec = (result) => {
+    for (const entry of result.toolResults ?? []) {
+        const name = entry.payload?.toolName ?? entry.toolName;
+        if (!name || !CARD_TOOL_NAMES.includes(name))
+            continue;
+        const parsed = card.cardSpecSchema.safeParse(entry.payload?.args ?? entry.args);
+        if (parsed.success)
+            return parsed.data;
+    }
+    return null;
+};
+/**
+ * Ask for the card shape via PROMPT injection rather than the provider's native
+ * response format.
+ *
+ * Databricks Model Serving rejects a request carrying both `response_format` and
+ * `tools` ("Cannot specify both response_format and tools in the same request"),
+ * and the agents this endpoint drives normally do have tools. Native structured
+ * output would therefore fail for exactly the agents worth talking to, so the
+ * schema is injected as instructions instead - which costs nothing here because
+ * the answer is re-validated with `cardSpecSchema` before it is compiled.
+ */
+const JSON_PROMPT_INJECTION = "system";
+/** The bot's identity on outbound activities when the caller names none. */
+export const BOT_ACCOUNT = {
+    id: "dbx-tools-teams-bot",
+    name: "Databricks Agent",
+};
+/**
+ * Instructions for the FORMATTING pass only - turning an answer the agent has
+ * already produced into the card vocabulary.
+ *
+ * Deliberately NOT sent with the user's question. Asking for a card and an
+ * answer in one request makes the model treat formatting as the task: it emits a
+ * card immediately instead of calling its tools, so a question that should have
+ * queried Genie came back as "I don't have a real system connected - here is a
+ * template card". Formatting is a separate, second pass over a real answer.
+ */
+export const CARD_FORMAT_INSTRUCTIONS = [
+    "Reformat the assistant answer below as a Microsoft Teams Adaptive Card.",
+    "Preserve the answer's facts EXACTLY - every number, name, date and id.",
+    "Do not add caveats, placeholders or invented values, and do not describe the",
+    "card; if the answer states a value, that value belongs in the card.",
+    "Put the headline finding in `title` and keep it under ~60 characters.",
+    "Use `text` for the explanation, with '-' bullets for lists.",
+    "Use `facts` for key/value detail (metrics, counts, owners, ids) instead of",
+    "writing it as prose.",
+    "Add `actions` only for URLs present in the answer; never invent a link.",
+    "Drop any `[chart:...]` / `[data:...]` marker: a card cannot render one, so",
+    "write the values it stood for into `facts` or `text` instead.",
+].join(" ");
+/**
+ * Nudge added to the ANSWERING pass.
+ *
+ * The agent answers the question normally here - tools included - so this only
+ * asks for the shape that survives compression into a card well. It must not
+ * mention cards, or the model starts formatting instead of answering.
+ */
+export const CARD_ANSWER_INSTRUCTIONS = [
+    "Answer using your tools and data sources as you normally would.",
+    "Be concise and lead with the finding, and state concrete values",
+    "(numbers, names, dates) plainly so they can be summarized.",
+    // Agents on a chat endpoint are told to defer tables and charts to the host UI
+    // as `[data:<id>]` / `[chart:<id>]` markers. A card has no embed slot to fill,
+    // so a deferred number arrives as a literal `[data:01f1...]` in the card. The
+    // turn asks for the values themselves instead, and strips any that slip
+    // through (see EMBED_MARKER_RE).
+    "This channel cannot display chart or data embeds: do not emit",
+    "`[chart:...]` or `[data:...]` markers - write the actual numbers you",
+    "retrieved into your answer instead.",
+].join(" ");
+/**
+ * A host-embed marker (`[chart:<id>]`, `[data:<id>]`) in an agent's prose.
+ *
+ * Chat hosts swap these for a rendered chart or table. An Adaptive Card has no
+ * such slot, so a marker that survives into card text renders as literal
+ * `[data:01f1895c-...]` noise where a number should be. The answering pass asks
+ * the agent not to emit them; this removes any that still arrive.
+ *
+ * The generic `[type:id]` grammar is spelled here rather than imported so this
+ * package stays a leaf add-on with no dependency on the agent plugin's
+ * contracts - it only ever needs to RECOGNIZE a marker, never resolve one.
+ */
+const EMBED_MARKER_RE = /\[[A-Za-z][A-Za-z0-9_-]*:[^\]\s]+\]/g;
+/**
+ * Drop embed markers from `text`, tidying the whitespace they leave behind so a
+ * marker that sat on its own line does not become a blank one.
+ */
+const stripEmbedMarkers = (text) => text
+    .replace(EMBED_MARKER_RE, "")
+    .replace(/[ \t]+$/gm, "")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+/** True when `value` exposes the `generate` a turn drives. */
+const isCardAgent = (value) => typeof value?.generate === "function";
+/** True when `value` exposes the agent-registry `exports()` a turn reads. */
+const isAgentProvider = (value) => typeof value?.exports === "function";
+/**
+ * Read one agent out of a provider's `exports()`.
+ *
+ * Every member is probed before it is called: the provider is matched
+ * structurally by plugin name, so a DIFFERENT plugin registered under that name
+ * can satisfy `isAgentProvider` (it has an `exports()`) while exposing no agent
+ * registry at all. Calling blindly would throw a `TypeError` out of route
+ * resolution; a miss is just "no agent", which the route reports as 503.
+ */
+const readAgent = (provider, agentId) => {
+    const registry = provider.exports();
+    if (agentId)
+        return typeof registry.get === "function" ? registry.get(agentId) : null;
+    return typeof registry.getDefault === "function" ? registry.getDefault() : null;
+};
+/**
+ * Resolve the agent that answers a turn from the AppKit plugin registry.
+ *
+ * `agentId` picks a specific agent; omitted, the provider's default agent
+ * answers. Returns `null` when the provider is absent or the id is unknown, so
+ * the route can answer 503 / 404 instead of throwing.
+ */
+export const resolveCardAgent = (plugins, providerName, agentId) => {
+    const provider = plugins?.get(providerName);
+    if (!isAgentProvider(provider))
+        return null;
+    const found = readAgent(provider, agentId);
+    return isCardAgent(found) ? found : null;
+};
+/**
+ * The agent plugin's request-context factory, when it exposes one.
+ *
+ * Resolved separately from the agent because it is the piece that gives an
+ * out-of-band turn the same tool reach as a chat turn; a provider without it
+ * still answers, just without user-scoped tools.
+ */
+export const resolveCardContextFactory = (plugins, providerName) => {
+    const provider = plugins?.get(providerName);
+    if (!isAgentProvider(provider))
+        return null;
+    const registry = provider.exports();
+    const factory = registry.createRequestContext;
+    return typeof factory === "function" ? (options) => factory.call(registry, options) : null;
+};
+/**
+ * The text a `message` activity carries, or `null` when it carries none.
+ *
+ * A channel sends plenty of activities with no usable text (a `typing`
+ * indicator, a `conversationUpdate` when someone joins, or a `message` whose
+ * payload is only an attachment). Those are not errors - they simply produce no
+ * reply - so this returns `null` rather than throwing.
+ */
+export const promptOf = (inbound) => inbound.type === "message" ? string.trimToNull(inbound.text ?? "") : null;
+/**
+ * Build an outbound activity carrying `cards`, addressed back to the sender of
+ * `inbound`.
+ *
+ * Exported because a client rendering an optimistic local reply, and a test
+ * asserting the envelope, both need the same construction the turn uses.
+ */
+export const toReplyActivity = (inbound, cards, options = {}) => ({
+    type: "message",
+    id: hash.id(),
+    timestamp: new Date().toISOString(),
+    from: options.bot ?? BOT_ACCOUNT,
+    ...(inbound.from ? { recipient: inbound.from } : {}),
+    ...(inbound.conversation ? { conversation: inbound.conversation } : {}),
+    ...(options.text ? { text: options.text } : {}),
+    attachments: cards.map((document) => activityContract.toCardAttachment(document)),
+});
+/**
+ * Recover a {@link card.CardSpec} from a full Adaptive Card DOCUMENT.
+ *
+ * A capable model asked for "a Microsoft Teams Adaptive Card" often answers with
+ * the finished 1.5 document instead of the small spec - correct Adaptive Card
+ * JSON, wrong schema, so `structuredOutput` rejects it (`title: expected
+ * string`) and a genuinely good answer is thrown away. Reading the document back
+ * into the spec vocabulary keeps it: the heading TextBlocks become
+ * title/subtitle, remaining TextBlocks the body, the FactSet the facts, and any
+ * `Action.OpenUrl` the actions.
+ *
+ * Deliberately tolerant about the container: `type` may be missing and the body
+ * may nest elements inside a `Container` / `ColumnSet`, so blocks are collected
+ * recursively and anything unrecognized is ignored.
+ */
+export const documentCardSpec = (value) => {
+    if (!object.isRecord(value) || !Array.isArray(value.body))
+        return null;
+    const texts = [];
+    const facts = [];
+    const collect = (elements) => {
+        for (const element of elements) {
+            if (!object.isRecord(element))
+                continue;
+            if (element.type === "TextBlock") {
+                const text = string.trimToNull(typeof element.text === "string" ? element.text : "");
+                if (text)
+                    texts.push(text);
+            }
+            else if (element.type === "FactSet" && Array.isArray(element.facts)) {
+                for (const fact of element.facts) {
+                    const parsed = card.cardFactSchema.safeParse(fact);
+                    if (parsed.success)
+                        facts.push(parsed.data);
+                }
+            }
+            // A Container / ColumnSet / Column nests the blocks that matter.
+            for (const key of ["items", "columns"]) {
+                const nested = element[key];
+                if (Array.isArray(nested))
+                    collect(nested);
+            }
+        }
+    };
+    collect(value.body);
+    const actions = [];
+    for (const action of Array.isArray(value.actions) ? value.actions : []) {
+        if (!object.isRecord(action))
+            continue;
+        const parsed = card.cardActionSchema.safeParse({ title: action.title, url: action.url });
+        if (parsed.success)
+            actions.push(parsed.data);
+    }
+    const [title, ...rest] = texts;
+    if (!title)
+        return null;
+    // The second block is a subtitle only when the document styled it as one;
+    // otherwise it is body text and must not be demoted to a subheading.
+    const second = object.isRecord(value.body[1]) ? value.body[1] : undefined;
+    const hasSubtitle = rest.length > 0 && second?.isSubtle === true;
+    const body = (hasSubtitle ? rest.slice(1) : rest).join("\n\n");
+    return {
+        title: toTitle(title),
+        ...(hasSubtitle && rest[0] ? { subtitle: rest[0] } : {}),
+        ...(body ? { text: body } : {}),
+        ...(facts.length > 0 ? { facts } : {}),
+        ...(actions.length > 0 ? { actions } : {}),
+    };
+};
+/**
+ * The card the model produced, wherever it ended up.
+ *
+ * `structuredOutput` rejects anything off-schema by THROWING, and Mastra puts
+ * the offending payload on the error (`details.value`) - so the model's real
+ * answer is recoverable from a failed call. Both the spec shape and a full
+ * Adaptive Card document are accepted, from an object or from JSON text.
+ */
+export const rejectedCardSpec = (err) => {
+    const details = object.isRecord(err) ? err.details : undefined;
+    const value = object.isRecord(details) ? details.value : undefined;
+    const candidates = [];
+    if (typeof value === "string") {
+        candidates.push(json.parse(value, undefined));
+    }
+    else if (value !== undefined) {
+        candidates.push(value);
+    }
+    for (const candidate of candidates) {
+        const spec = card.cardSpecSchema.safeParse(candidate);
+        if (spec.success)
+            return spec.data;
+        const fromDocument = documentCardSpec(candidate);
+        if (fromDocument)
+            return fromDocument;
+    }
+    return null;
+};
+/**
+ * Turn whatever the agent produced into a card spec.
+ *
+ * `structuredOutput` is best-effort in practice, not a guarantee. Because the
+ * schema is prompt-injected (see {@link JSON_PROMPT_INJECTION}) rather than
+ * enforced by the provider, a model can answer with prose, with JSON wrapped in
+ * a ```` ```json ```` fence, or - on Databricks Model Serving - with an empty
+ * parsed object while the text carries the real answer. Observed failure rate on
+ * the demo endpoint was roughly one turn in three, all of which surfaced as a
+ * hard `STRUCTURED_OUTPUT_SCHEMA_VALIDATION_FAILED` and no reply at all.
+ *
+ * A missing card is not worth dropping the answer over, so this recovers in
+ * four stages: the parsed object when it validates; else the arguments the agent
+ * passed to `create_teams_card` (on the prose retry an agent holding that tool
+ * usually calls it, which is a REAL card spec, not a guess); else a JSON object
+ * embedded in the text; else the prose wrapped in a minimal text-only card. The
+ * user always gets the agent's answer; at worst it is less structured.
+ */
+const toCardSpec = (result) => {
+    const parsed = card.cardSpecSchema.safeParse(result.object);
+    if (parsed.success)
+        return parsed.data;
+    // A model that answered with the finished Adaptive Card document rather than
+    // the spec still produced a real card; read it back into the spec vocabulary.
+    const fromDocument = documentCardSpec(result.object);
+    if (fromDocument)
+        return fromDocument;
+    // Prefer a card the agent explicitly composed via the tool over anything
+    // scraped out of its prose.
+    const fromTool = toolCardSpec(result);
+    if (fromTool)
+        return fromTool;
+    const text = string.trimToNull(result.text ?? "");
+    if (text) {
+        // A fenced or inline JSON object in the prose: the model followed the
+        // instructions but the provider did not surface a parsed object.
+        const embedded = text.match(/\{[\s\S]*\}/);
+        if (embedded) {
+            const value = json.parse(embedded[0], undefined);
+            const retry = card.cardSpecSchema.safeParse(value);
+            if (retry.success)
+                return retry.data;
+            const asDocument = documentCardSpec(value);
+            if (asDocument)
+                return asDocument;
+        }
+        // Prose only: keep the answer, drop the structure. The first line becomes
+        // the title (a card with no title renders as an untitled block), the rest
+        // stays as the body.
+        const lines = text
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            // A model introducing its own answer ("Here is the Adaptive Card:") would
+            // otherwise become the card's headline, which reads as a bug. Drop the
+            // preamble so the first REAL line is the title.
+            .filter((line) => !PREAMBLE_RE.test(line.trim()));
+        const [first, ...rest] = lines;
+        const title = string.trimToNull(first ?? "") ?? "Answer";
+        const body = rest.join("\n").trim();
+        return {
+            title: toTitle(title),
+            ...(body ? { text: body } : title.length > 120 ? { text: title } : {}),
+        };
+    }
+    throw new Error("teams: the agent returned neither a card nor any text to fall back on");
+};
+/**
+ * A line that only announces the card rather than saying anything - e.g.
+ * "Here is the Adaptive Card:", "Here's your Teams card:", "Here are the card
+ * details:". Matched so it never becomes the card's title.
+ *
+ * Anchored to a "here is/are/here's ... card ..." opener that ENDS in a colon,
+ * which is what keeps it from eating a real sentence that merely mentions a card
+ * ("Here is the card reader status: offline." has text after the colon).
+ */
+const PREAMBLE_RE = /^(here (is|are)|here's)\b[^.!?]*\bcard\b[^.!?:]*:\s*$/i;
+/**
+ * Trim a line down to something usable as a card title. Adaptive Card titles are
+ * a single bold line, so an overlong one is truncated rather than wrapped; the
+ * markdown emphasis a model often adds is stripped since the title is already
+ * styled bold.
+ */
+const toTitle = (value) => {
+    const plain = value
+        .replace(/^#+\s*/, "")
+        .replace(/\*\*/g, "")
+        .trim();
+    return plain.length > 120 ? `${plain.slice(0, 117)}...` : plain;
+};
+/**
+ * Compile an answer the agent has already produced into a card spec.
+ *
+ * A second, deliberately stateless pass: the formatting request is NOT threaded
+ * onto agent memory, so the conversation the user sees keeps only their question
+ * and the answer, not the reformatting chatter in between.
+ *
+ * Returns `null` when the pass is unusable (Mastra throws when the model returns
+ * no parsed object) so the caller can fall back to the answer text - a less
+ * structured card carrying the real answer beats losing the answer.
+ */
+const formatAsCard = async (agent, prompt, answer, request) => {
+    const body = [
+        CARD_FORMAT_INSTRUCTIONS,
+        "",
+        `Question: ${prompt}`,
+        "",
+        "Assistant answer:",
+        answer,
+    ].join("\n");
+    const options = {
+        structuredOutput: {
+            schema: card.cardSpecSchema,
+            jsonPromptInjection: JSON_PROMPT_INJECTION,
+        },
+        ...request,
+    };
+    // Mastra THROWS when the model returns no parsed object, and because the
+    // schema is prompt-injected rather than provider-enforced that happens
+    // intermittently on the same input. One retry converts most of those misses
+    // into a proper card; the answer is already safe either way.
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            return toCardSpec(await agent.generate(body, options));
+        }
+        catch (err) {
+            // The rejected payload usually IS the card - most often the full Adaptive
+            // Card document rather than the spec - so it is salvaged before retrying.
+            const rejected = rejectedCardSpec(err);
+            if (rejected) {
+                logger.debug("recovered the card from the rejected structured payload");
+                return rejected;
+            }
+            logger.warn("card formatting pass failed", {
+                attempt: attempt + 1,
+                error: error.errorMessage(err),
+            });
+        }
+    }
+    logger.warn("falling back to the answer text for the card");
+    return null;
+};
+/**
+ * Run one conversation turn: drive `agent` with the inbound activity's text and
+ * return the activities to append to the transcript.
+ *
+ * Returns an EMPTY array for an activity that carries no prompt (a typing
+ * indicator, a join event), which is exactly what a bot does with one - the
+ * route answers `{ activities: [] }` and the transcript is unchanged.
+ *
+ * Two agent calls, in this order:
+ *
+ *   1. the ANSWER - no `structuredOutput`, so the agent's tools are available
+ *      and the content matches what the streaming endpoint would say;
+ *   2. the FORMAT - {@link formatAsCard} compiling that answer into a card.
+ *
+ * Every failure mode still yields the answer: a card the agent composed with
+ * `create_teams_card` during pass 1 short-circuits pass 2, and a failed pass 2
+ * falls back to {@link toCardSpec} over the answer text.
+ */
+export const runCardTurn = async (agent, inbound, options = {}) => {
+    const prompt = promptOf(inbound);
+    if (!prompt)
+        return [];
+    const conversationId = inbound.conversation?.id;
+    const userId = inbound.from?.id;
+    const signal = options.signal ? { abortSignal: options.signal } : {};
+    // The AppKit user rides on this, so the agent's tools (Genie, serving, the
+    // model resolver) work exactly as they do on the chat endpoints. Built once
+    // and shared by both passes.
+    const requestContext = options.createRequestContext
+        ? await options.createRequestContext({
+            ...(conversationId ? { threadId: conversationId } : {}),
+            ...(userId ? { resourceId: userId } : {}),
+        })
+        : undefined;
+    const context = requestContext ? { requestContext } : {};
+    // Thread the conversation onto agent memory so the same `conversation.id`
+    // continues one conversation. Only passed when the client supplied both ids -
+    // Mastra requires the pair, and a memory-less agent ignores it.
+    const memory = conversationId && userId ? { memory: { thread: conversationId, resource: userId } } : {};
+    const answered = await agent.generate(`${prompt}\n\n${CARD_ANSWER_INSTRUCTIONS}`, {
+        ...memory,
+        ...context,
+        ...signal,
+    });
+    // An agent that composed a card itself has already said it in the right
+    // vocabulary; reformatting it would only risk paraphrasing the values.
+    const composed = toolCardSpec(answered);
+    const answer = string.trimToNull(stripEmbedMarkers(answered.text ?? ""));
+    const spec = composed ??
+        (answer ? await formatAsCard(agent, prompt, answer, { ...context, ...signal }) : null);
+    const document = buildAdaptiveCard(spec ?? toCardSpec({ ...answered, ...(answer ? { text: answer } : {}) }));
+    return [toReplyActivity(inbound, [document], { ...(options.bot ? { bot: options.bot } : {}) })];
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conversation.js","sourceRoot":"","sources":["../../src/conversation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The Teams conversation turn: run a Mastra agent against an inbound Bot\n * Framework activity and answer with Adaptive Card attachments.\n *\n * This is the piece that makes `POST /api/teams/activity` behave like a Teams\n * bot rather than a chat API that happens to return JSON. A turn is:\n *\n *   1. read the user's text off the inbound `message` activity;\n *   2. ANSWER it - a normal tool-using agent turn, with no mention of cards, so\n *      the agent queries Genie / calls its tools exactly as it would on a\n *      streaming chat endpoint;\n *   3. FORMAT that answer into a {@link card.CardSpec} in a second pass, via\n *      Mastra's `structuredOutput` (prompt-injected, see\n *      {@link JSON_PROMPT_INJECTION});\n *   4. compile the spec with the same deterministic builder the\n *      `create_teams_card` tool uses, and attach it to an outbound activity.\n *\n * The two passes are the important part. Asking for the answer AND the card\n * shape in ONE request makes the model treat formatting as the task: it emits a\n * card straight away and never calls its tools, so a question that should have\n * queried a data source came back as \"I don't have a real system connected -\n * here is a template card with placeholders\". Answering first, then formatting a\n * REAL answer, makes this endpoint's content identical to the streaming\n * endpoint's; only the presentation differs.\n *\n * Formatting is also why the turn does not simply rely on the agent calling\n * `create_teams_card`: on this endpoint a card IS the response format, so it\n * should be a property of the turn rather than a tool the model may forget.\n * Agents keep the tool for the other direction - answering in prose on a normal\n * chat endpoint and choosing to attach a card. When the agent DOES call it\n * during the answering pass, that spec wins and the formatting pass is skipped.\n *\n * The conversation id doubles as the agent's memory thread id, so a client that\n * keeps posting the same `conversation.id` gets a continuous conversation - the\n * same mapping a real channel relies on.\n *\n * @module\n */\n\nimport { error, hash, json, log, object, string } from \"@dbx-tools/shared-core\";\nimport { activity as activityContract, card } from \"@dbx-tools/shared-teams\";\nimport { buildAdaptiveCard } from \"./builder\";\n\nconst logger = log.logger(\"teams:conversation\");\n\n/**\n * Minimal structural shape of the Mastra `Agent` this module drives.\n *\n * Declared structurally rather than importing `@mastra/core`'s `Agent`: this\n * package must not depend on the Mastra plugin (the plugin depends on nothing\n * here either), and a turn only ever needs `generate`. Any object with a\n * compatible `generate` satisfies it, which also makes the turn trivially\n * testable with a stub.\n */\nexport interface CardAgentLike {\n  generate(\n    prompt: string,\n    options: {\n      structuredOutput?: {\n        schema: typeof card.cardSpecSchema;\n        jsonPromptInjection?: boolean | \"system\" | \"inline\";\n      };\n      memory?: { thread: string; resource: string };\n      /**\n       * Mastra's per-turn `RequestContext`. Opaque here - the object comes from\n       * the agent plugin (see {@link AgentProviderLike.exports}) and is only\n       * forwarded - but REQUIRED for parity with the chat endpoints: Mastra's\n       * user-scoped tools read the AppKit user off it, so a turn without one\n       * answers \"the data source is unreachable\" where chat answers with data.\n       */\n      requestContext?: unknown;\n      abortSignal?: AbortSignal;\n    },\n  ): Promise<AgentResult>;\n}\n\n/**\n * The slice of Mastra's `generate` result a turn reads.\n *\n * `toolResults` matters as much as `object` here: when structured output fails\n * and the turn re-asks as prose, an agent holding the `create_teams_card` tool\n * typically CALLS it, so the best available card spec is the tool's arguments -\n * already in the right vocabulary - rather than anything in the prose.\n */\nexport interface AgentResult {\n  object?: unknown;\n  text?: string;\n  toolResults?: {\n    payload?: { toolName?: string; args?: unknown };\n    toolName?: string;\n    args?: unknown;\n  }[];\n}\n\n/** Tool id whose arguments are already a {@link card.CardSpec}. */\nconst CARD_TOOL_NAMES = [\"create_teams_card\", \"createCard\"];\n\n/**\n * The card spec an agent passed to the card tool, if it called it.\n *\n * Mastra nests a tool result under `payload` (`{ payload: { toolName, args } }`)\n * but has used a flat shape too, so both are read.\n */\nconst toolCardSpec = (result: AgentResult): card.CardSpec | null => {\n  for (const entry of result.toolResults ?? []) {\n    const name = entry.payload?.toolName ?? entry.toolName;\n    if (!name || !CARD_TOOL_NAMES.includes(name)) continue;\n    const parsed = card.cardSpecSchema.safeParse(entry.payload?.args ?? entry.args);\n    if (parsed.success) return parsed.data;\n  }\n  return null;\n};\n\n/**\n * Ask for the card shape via PROMPT injection rather than the provider's native\n * response format.\n *\n * Databricks Model Serving rejects a request carrying both `response_format` and\n * `tools` (\"Cannot specify both response_format and tools in the same request\"),\n * and the agents this endpoint drives normally do have tools. Native structured\n * output would therefore fail for exactly the agents worth talking to, so the\n * schema is injected as instructions instead - which costs nothing here because\n * the answer is re-validated with `cardSpecSchema` before it is compiled.\n */\nconst JSON_PROMPT_INJECTION = \"system\" as const;\n\n/** The bot's identity on outbound activities when the caller names none. */\nexport const BOT_ACCOUNT: activityContract.ChannelAccount = {\n  id: \"dbx-tools-teams-bot\",\n  name: \"Databricks Agent\",\n};\n\n/**\n * Instructions for the FORMATTING pass only - turning an answer the agent has\n * already produced into the card vocabulary.\n *\n * Deliberately NOT sent with the user's question. Asking for a card and an\n * answer in one request makes the model treat formatting as the task: it emits a\n * card immediately instead of calling its tools, so a question that should have\n * queried Genie came back as \"I don't have a real system connected - here is a\n * template card\". Formatting is a separate, second pass over a real answer.\n */\nexport const CARD_FORMAT_INSTRUCTIONS = [\n  \"Reformat the assistant answer below as a Microsoft Teams Adaptive Card.\",\n  \"Preserve the answer's facts EXACTLY - every number, name, date and id.\",\n  \"Do not add caveats, placeholders or invented values, and do not describe the\",\n  \"card; if the answer states a value, that value belongs in the card.\",\n  \"Put the headline finding in `title` and keep it under ~60 characters.\",\n  \"Use `text` for the explanation, with '-' bullets for lists.\",\n  \"Use `facts` for key/value detail (metrics, counts, owners, ids) instead of\",\n  \"writing it as prose.\",\n  \"Add `actions` only for URLs present in the answer; never invent a link.\",\n  \"Drop any `[chart:...]` / `[data:...]` marker: a card cannot render one, so\",\n  \"write the values it stood for into `facts` or `text` instead.\",\n].join(\" \");\n\n/**\n * Nudge added to the ANSWERING pass.\n *\n * The agent answers the question normally here - tools included - so this only\n * asks for the shape that survives compression into a card well. It must not\n * mention cards, or the model starts formatting instead of answering.\n */\nexport const CARD_ANSWER_INSTRUCTIONS = [\n  \"Answer using your tools and data sources as you normally would.\",\n  \"Be concise and lead with the finding, and state concrete values\",\n  \"(numbers, names, dates) plainly so they can be summarized.\",\n  // Agents on a chat endpoint are told to defer tables and charts to the host UI\n  // as `[data:<id>]` / `[chart:<id>]` markers. A card has no embed slot to fill,\n  // so a deferred number arrives as a literal `[data:01f1...]` in the card. The\n  // turn asks for the values themselves instead, and strips any that slip\n  // through (see EMBED_MARKER_RE).\n  \"This channel cannot display chart or data embeds: do not emit\",\n  \"`[chart:...]` or `[data:...]` markers - write the actual numbers you\",\n  \"retrieved into your answer instead.\",\n].join(\" \");\n\n/**\n * A host-embed marker (`[chart:<id>]`, `[data:<id>]`) in an agent's prose.\n *\n * Chat hosts swap these for a rendered chart or table. An Adaptive Card has no\n * such slot, so a marker that survives into card text renders as literal\n * `[data:01f1895c-...]` noise where a number should be. The answering pass asks\n * the agent not to emit them; this removes any that still arrive.\n *\n * The generic `[type:id]` grammar is spelled here rather than imported so this\n * package stays a leaf add-on with no dependency on the agent plugin's\n * contracts - it only ever needs to RECOGNIZE a marker, never resolve one.\n */\nconst EMBED_MARKER_RE = /\\[[A-Za-z][A-Za-z0-9_-]*:[^\\]\\s]+\\]/g;\n\n/**\n * Drop embed markers from `text`, tidying the whitespace they leave behind so a\n * marker that sat on its own line does not become a blank one.\n */\nconst stripEmbedMarkers = (text: string): string =>\n  text\n    .replace(EMBED_MARKER_RE, \"\")\n    .replace(/[ \\t]+$/gm, \"\")\n    .replace(/\\n{3,}/g, \"\\n\\n\")\n    .trim();\n\n/**\n * Structural shape of the sibling plugin that owns the agent registry - the\n * slice of `@dbx-tools/appkit-mastra`'s `exports()` a turn needs.\n *\n * Matched structurally, by registered plugin NAME, rather than importing the\n * Mastra plugin: this package stays a leaf add-on (it depends on no other\n * dbx-tools runtime package, like node-email), the dependency direction stays\n * one-way, and any plugin exposing the same `get` / `getDefault` pair can back\n * the endpoint.\n */\nexport interface AgentProviderLike {\n  exports(): {\n    get(id: string): unknown;\n    getDefault(): unknown;\n    /**\n     * Builds the per-turn `RequestContext` the provider's tools expect. Optional\n     * so an older provider (or a differently-shaped one) still resolves an\n     * agent; the turn simply runs without user-scoped tool context then.\n     */\n    createRequestContext?(options: { threadId?: string; resourceId?: string }): Promise<unknown>;\n  };\n}\n\n/** True when `value` exposes the `generate` a turn drives. */\nconst isCardAgent = (value: unknown): value is CardAgentLike =>\n  typeof (value as CardAgentLike | null)?.generate === \"function\";\n\n/** True when `value` exposes the agent-registry `exports()` a turn reads. */\nconst isAgentProvider = (value: unknown): value is AgentProviderLike =>\n  typeof (value as AgentProviderLike | null)?.exports === \"function\";\n\n/**\n * Read one agent out of a provider's `exports()`.\n *\n * Every member is probed before it is called: the provider is matched\n * structurally by plugin name, so a DIFFERENT plugin registered under that name\n * can satisfy `isAgentProvider` (it has an `exports()`) while exposing no agent\n * registry at all. Calling blindly would throw a `TypeError` out of route\n * resolution; a miss is just \"no agent\", which the route reports as 503.\n */\nconst readAgent = (provider: AgentProviderLike, agentId?: string): unknown => {\n  const registry = provider.exports() as Partial<ReturnType<AgentProviderLike[\"exports\"]>>;\n  if (agentId) return typeof registry.get === \"function\" ? registry.get(agentId) : null;\n  return typeof registry.getDefault === \"function\" ? registry.getDefault() : null;\n};\n\n/**\n * Resolve the agent that answers a turn from the AppKit plugin registry.\n *\n * `agentId` picks a specific agent; omitted, the provider's default agent\n * answers. Returns `null` when the provider is absent or the id is unknown, so\n * the route can answer 503 / 404 instead of throwing.\n */\nexport const resolveCardAgent = (\n  plugins: ReadonlyMap<string, unknown> | undefined,\n  providerName: string,\n  agentId?: string,\n): CardAgentLike | null => {\n  const provider = plugins?.get(providerName);\n  if (!isAgentProvider(provider)) return null;\n  const found = readAgent(provider, agentId);\n  return isCardAgent(found) ? found : null;\n};\n\n/** Options for {@link runCardTurn}. */\nexport interface CardTurnOptions {\n  /** Cancels the agent call with the request. */\n  signal?: AbortSignal;\n  /** Overrides the bot identity stamped on the reply. */\n  bot?: activityContract.ChannelAccount;\n  /**\n   * Builds the Mastra `RequestContext` for the turn, from\n   * {@link resolveCardContextFactory}. Omitted, the turn still answers, but\n   * without the AppKit user its user-scoped tools cannot reach Databricks - so\n   * the route should always supply it.\n   */\n  createRequestContext?: CardContextFactory;\n}\n\n/** Builds the per-turn request context the agent's tools read. */\nexport type CardContextFactory = (options: {\n  threadId?: string;\n  resourceId?: string;\n}) => Promise<unknown>;\n\n/**\n * The agent plugin's request-context factory, when it exposes one.\n *\n * Resolved separately from the agent because it is the piece that gives an\n * out-of-band turn the same tool reach as a chat turn; a provider without it\n * still answers, just without user-scoped tools.\n */\nexport const resolveCardContextFactory = (\n  plugins: ReadonlyMap<string, unknown> | undefined,\n  providerName: string,\n): CardContextFactory | null => {\n  const provider = plugins?.get(providerName);\n  if (!isAgentProvider(provider)) return null;\n  const registry = provider.exports() as Partial<ReturnType<AgentProviderLike[\"exports\"]>>;\n  const factory = registry.createRequestContext;\n  return typeof factory === \"function\" ? (options) => factory.call(registry, options) : null;\n};\n\n/**\n * The text a `message` activity carries, or `null` when it carries none.\n *\n * A channel sends plenty of activities with no usable text (a `typing`\n * indicator, a `conversationUpdate` when someone joins, or a `message` whose\n * payload is only an attachment). Those are not errors - they simply produce no\n * reply - so this returns `null` rather than throwing.\n */\nexport const promptOf = (inbound: activityContract.Activity): string | null =>\n  inbound.type === \"message\" ? string.trimToNull(inbound.text ?? \"\") : null;\n\n/**\n * Build an outbound activity carrying `cards`, addressed back to the sender of\n * `inbound`.\n *\n * Exported because a client rendering an optimistic local reply, and a test\n * asserting the envelope, both need the same construction the turn uses.\n */\nexport const toReplyActivity = (\n  inbound: activityContract.Activity,\n  cards: card.AdaptiveCard[],\n  options: { bot?: activityContract.ChannelAccount; text?: string } = {},\n): activityContract.Activity => ({\n  type: \"message\",\n  id: hash.id(),\n  timestamp: new Date().toISOString(),\n  from: options.bot ?? BOT_ACCOUNT,\n  ...(inbound.from ? { recipient: inbound.from } : {}),\n  ...(inbound.conversation ? { conversation: inbound.conversation } : {}),\n  ...(options.text ? { text: options.text } : {}),\n  attachments: cards.map((document) => activityContract.toCardAttachment(document)),\n});\n\n/**\n * Recover a {@link card.CardSpec} from a full Adaptive Card DOCUMENT.\n *\n * A capable model asked for \"a Microsoft Teams Adaptive Card\" often answers with\n * the finished 1.5 document instead of the small spec - correct Adaptive Card\n * JSON, wrong schema, so `structuredOutput` rejects it (`title: expected\n * string`) and a genuinely good answer is thrown away. Reading the document back\n * into the spec vocabulary keeps it: the heading TextBlocks become\n * title/subtitle, remaining TextBlocks the body, the FactSet the facts, and any\n * `Action.OpenUrl` the actions.\n *\n * Deliberately tolerant about the container: `type` may be missing and the body\n * may nest elements inside a `Container` / `ColumnSet`, so blocks are collected\n * recursively and anything unrecognized is ignored.\n */\nexport const documentCardSpec = (value: unknown): card.CardSpec | null => {\n  if (!object.isRecord(value) || !Array.isArray(value.body)) return null;\n\n  const texts: string[] = [];\n  const facts: card.CardFact[] = [];\n  const collect = (elements: unknown[]): void => {\n    for (const element of elements) {\n      if (!object.isRecord(element)) continue;\n      if (element.type === \"TextBlock\") {\n        const text = string.trimToNull(typeof element.text === \"string\" ? element.text : \"\");\n        if (text) texts.push(text);\n      } else if (element.type === \"FactSet\" && Array.isArray(element.facts)) {\n        for (const fact of element.facts) {\n          const parsed = card.cardFactSchema.safeParse(fact);\n          if (parsed.success) facts.push(parsed.data);\n        }\n      }\n      // A Container / ColumnSet / Column nests the blocks that matter.\n      for (const key of [\"items\", \"columns\"]) {\n        const nested = element[key];\n        if (Array.isArray(nested)) collect(nested);\n      }\n    }\n  };\n  collect(value.body);\n\n  const actions: card.CardAction[] = [];\n  for (const action of Array.isArray(value.actions) ? value.actions : []) {\n    if (!object.isRecord(action)) continue;\n    const parsed = card.cardActionSchema.safeParse({ title: action.title, url: action.url });\n    if (parsed.success) actions.push(parsed.data);\n  }\n\n  const [title, ...rest] = texts;\n  if (!title) return null;\n  // The second block is a subtitle only when the document styled it as one;\n  // otherwise it is body text and must not be demoted to a subheading.\n  const second = object.isRecord(value.body[1]) ? value.body[1] : undefined;\n  const hasSubtitle = rest.length > 0 && second?.isSubtle === true;\n  const body = (hasSubtitle ? rest.slice(1) : rest).join(\"\\n\\n\");\n  return {\n    title: toTitle(title),\n    ...(hasSubtitle && rest[0] ? { subtitle: rest[0] } : {}),\n    ...(body ? { text: body } : {}),\n    ...(facts.length > 0 ? { facts } : {}),\n    ...(actions.length > 0 ? { actions } : {}),\n  };\n};\n\n/**\n * The card the model produced, wherever it ended up.\n *\n * `structuredOutput` rejects anything off-schema by THROWING, and Mastra puts\n * the offending payload on the error (`details.value`) - so the model's real\n * answer is recoverable from a failed call. Both the spec shape and a full\n * Adaptive Card document are accepted, from an object or from JSON text.\n */\nexport const rejectedCardSpec = (err: unknown): card.CardSpec | null => {\n  const details = object.isRecord(err) ? err.details : undefined;\n  const value = object.isRecord(details) ? details.value : undefined;\n  const candidates: unknown[] = [];\n  if (typeof value === \"string\") {\n    candidates.push(json.parse(value, undefined));\n  } else if (value !== undefined) {\n    candidates.push(value);\n  }\n  for (const candidate of candidates) {\n    const spec = card.cardSpecSchema.safeParse(candidate);\n    if (spec.success) return spec.data;\n    const fromDocument = documentCardSpec(candidate);\n    if (fromDocument) return fromDocument;\n  }\n  return null;\n};\n\n/**\n * Turn whatever the agent produced into a card spec.\n *\n * `structuredOutput` is best-effort in practice, not a guarantee. Because the\n * schema is prompt-injected (see {@link JSON_PROMPT_INJECTION}) rather than\n * enforced by the provider, a model can answer with prose, with JSON wrapped in\n * a ```` ```json ```` fence, or - on Databricks Model Serving - with an empty\n * parsed object while the text carries the real answer. Observed failure rate on\n * the demo endpoint was roughly one turn in three, all of which surfaced as a\n * hard `STRUCTURED_OUTPUT_SCHEMA_VALIDATION_FAILED` and no reply at all.\n *\n * A missing card is not worth dropping the answer over, so this recovers in\n * four stages: the parsed object when it validates; else the arguments the agent\n * passed to `create_teams_card` (on the prose retry an agent holding that tool\n * usually calls it, which is a REAL card spec, not a guess); else a JSON object\n * embedded in the text; else the prose wrapped in a minimal text-only card. The\n * user always gets the agent's answer; at worst it is less structured.\n */\nconst toCardSpec = (result: AgentResult): card.CardSpec => {\n  const parsed = card.cardSpecSchema.safeParse(result.object);\n  if (parsed.success) return parsed.data;\n\n  // A model that answered with the finished Adaptive Card document rather than\n  // the spec still produced a real card; read it back into the spec vocabulary.\n  const fromDocument = documentCardSpec(result.object);\n  if (fromDocument) return fromDocument;\n\n  // Prefer a card the agent explicitly composed via the tool over anything\n  // scraped out of its prose.\n  const fromTool = toolCardSpec(result);\n  if (fromTool) return fromTool;\n\n  const text = string.trimToNull(result.text ?? \"\");\n  if (text) {\n    // A fenced or inline JSON object in the prose: the model followed the\n    // instructions but the provider did not surface a parsed object.\n    const embedded = text.match(/\\{[\\s\\S]*\\}/);\n    if (embedded) {\n      const value = json.parse(embedded[0], undefined);\n      const retry = card.cardSpecSchema.safeParse(value);\n      if (retry.success) return retry.data;\n      const asDocument = documentCardSpec(value);\n      if (asDocument) return asDocument;\n    }\n    // Prose only: keep the answer, drop the structure. The first line becomes\n    // the title (a card with no title renders as an untitled block), the rest\n    // stays as the body.\n    const lines = text\n      .split(\"\\n\")\n      .filter((line) => line.trim().length > 0)\n      // A model introducing its own answer (\"Here is the Adaptive Card:\") would\n      // otherwise become the card's headline, which reads as a bug. Drop the\n      // preamble so the first REAL line is the title.\n      .filter((line) => !PREAMBLE_RE.test(line.trim()));\n    const [first, ...rest] = lines;\n    const title = string.trimToNull(first ?? \"\") ?? \"Answer\";\n    const body = rest.join(\"\\n\").trim();\n    return {\n      title: toTitle(title),\n      ...(body ? { text: body } : title.length > 120 ? { text: title } : {}),\n    };\n  }\n\n  throw new Error(\"teams: the agent returned neither a card nor any text to fall back on\");\n};\n\n/**\n * A line that only announces the card rather than saying anything - e.g.\n * \"Here is the Adaptive Card:\", \"Here's your Teams card:\", \"Here are the card\n * details:\". Matched so it never becomes the card's title.\n *\n * Anchored to a \"here is/are/here's ... card ...\" opener that ENDS in a colon,\n * which is what keeps it from eating a real sentence that merely mentions a card\n * (\"Here is the card reader status: offline.\" has text after the colon).\n */\nconst PREAMBLE_RE = /^(here (is|are)|here's)\\b[^.!?]*\\bcard\\b[^.!?:]*:\\s*$/i;\n\n/**\n * Trim a line down to something usable as a card title. Adaptive Card titles are\n * a single bold line, so an overlong one is truncated rather than wrapped; the\n * markdown emphasis a model often adds is stripped since the title is already\n * styled bold.\n */\nconst toTitle = (value: string): string => {\n  const plain = value\n    .replace(/^#+\\s*/, \"\")\n    .replace(/\\*\\*/g, \"\")\n    .trim();\n  return plain.length > 120 ? `${plain.slice(0, 117)}...` : plain;\n};\n\n/**\n * Compile an answer the agent has already produced into a card spec.\n *\n * A second, deliberately stateless pass: the formatting request is NOT threaded\n * onto agent memory, so the conversation the user sees keeps only their question\n * and the answer, not the reformatting chatter in between.\n *\n * Returns `null` when the pass is unusable (Mastra throws when the model returns\n * no parsed object) so the caller can fall back to the answer text - a less\n * structured card carrying the real answer beats losing the answer.\n */\nconst formatAsCard = async (\n  agent: CardAgentLike,\n  prompt: string,\n  answer: string,\n  request: { abortSignal?: AbortSignal; requestContext?: unknown },\n): Promise<card.CardSpec | null> => {\n  const body = [\n    CARD_FORMAT_INSTRUCTIONS,\n    \"\",\n    `Question: ${prompt}`,\n    \"\",\n    \"Assistant answer:\",\n    answer,\n  ].join(\"\\n\");\n  const options = {\n    structuredOutput: {\n      schema: card.cardSpecSchema,\n      jsonPromptInjection: JSON_PROMPT_INJECTION,\n    },\n    ...request,\n  };\n  // Mastra THROWS when the model returns no parsed object, and because the\n  // schema is prompt-injected rather than provider-enforced that happens\n  // intermittently on the same input. One retry converts most of those misses\n  // into a proper card; the answer is already safe either way.\n  for (let attempt = 0; attempt < 2; attempt += 1) {\n    try {\n      return toCardSpec(await agent.generate(body, options));\n    } catch (err) {\n      // The rejected payload usually IS the card - most often the full Adaptive\n      // Card document rather than the spec - so it is salvaged before retrying.\n      const rejected = rejectedCardSpec(err);\n      if (rejected) {\n        logger.debug(\"recovered the card from the rejected structured payload\");\n        return rejected;\n      }\n      logger.warn(\"card formatting pass failed\", {\n        attempt: attempt + 1,\n        error: error.errorMessage(err),\n      });\n    }\n  }\n  logger.warn(\"falling back to the answer text for the card\");\n  return null;\n};\n\n/**\n * Run one conversation turn: drive `agent` with the inbound activity's text and\n * return the activities to append to the transcript.\n *\n * Returns an EMPTY array for an activity that carries no prompt (a typing\n * indicator, a join event), which is exactly what a bot does with one - the\n * route answers `{ activities: [] }` and the transcript is unchanged.\n *\n * Two agent calls, in this order:\n *\n *   1. the ANSWER - no `structuredOutput`, so the agent's tools are available\n *      and the content matches what the streaming endpoint would say;\n *   2. the FORMAT - {@link formatAsCard} compiling that answer into a card.\n *\n * Every failure mode still yields the answer: a card the agent composed with\n * `create_teams_card` during pass 1 short-circuits pass 2, and a failed pass 2\n * falls back to {@link toCardSpec} over the answer text.\n */\nexport const runCardTurn = async (\n  agent: CardAgentLike,\n  inbound: activityContract.Activity,\n  options: CardTurnOptions = {},\n): Promise<activityContract.Activity[]> => {\n  const prompt = promptOf(inbound);\n  if (!prompt) return [];\n\n  const conversationId = inbound.conversation?.id;\n  const userId = inbound.from?.id;\n  const signal = options.signal ? { abortSignal: options.signal } : {};\n  // The AppKit user rides on this, so the agent's tools (Genie, serving, the\n  // model resolver) work exactly as they do on the chat endpoints. Built once\n  // and shared by both passes.\n  const requestContext = options.createRequestContext\n    ? await options.createRequestContext({\n        ...(conversationId ? { threadId: conversationId } : {}),\n        ...(userId ? { resourceId: userId } : {}),\n      })\n    : undefined;\n  const context = requestContext ? { requestContext } : {};\n  // Thread the conversation onto agent memory so the same `conversation.id`\n  // continues one conversation. Only passed when the client supplied both ids -\n  // Mastra requires the pair, and a memory-less agent ignores it.\n  const memory =\n    conversationId && userId ? { memory: { thread: conversationId, resource: userId } } : {};\n\n  const answered = await agent.generate(`${prompt}\\n\\n${CARD_ANSWER_INSTRUCTIONS}`, {\n    ...memory,\n    ...context,\n    ...signal,\n  });\n\n  // An agent that composed a card itself has already said it in the right\n  // vocabulary; reformatting it would only risk paraphrasing the values.\n  const composed = toolCardSpec(answered);\n  const answer = string.trimToNull(stripEmbedMarkers(answered.text ?? \"\"));\n  const spec =\n    composed ??\n    (answer ? await formatAsCard(agent, prompt, answer, { ...context, ...signal }) : null);\n\n  const document = buildAdaptiveCard(\n    spec ?? toCardSpec({ ...answered, ...(answer ? { text: answer } : {}) }),\n  );\n  return [toReplyActivity(inbound, [document], { ...(options.bot ? { bot: options.bot } : {}) })];\n};\n"]}