@dbx-tools/appkit-mastra 0.9.141 → 0.9.144

package/lib/src/follow-up-suggestions.js

@@ -0,0 +1,343 @@
+/**
+ * ChatFast post-turn follow-up suggestion generation.
+ *
+ * @module
+ */
+import { asyncUtils, errorUtils, log, object, stringUtils } from "@dbx-tools/shared-core";
+import { FOLLOW_UP_SUGGESTIONS_PART_TYPE, FollowUpSuggestionsPartDataSchema, } from "@dbx-tools/shared-mastra/wire";
+import { model } from "@dbx-tools/shared-model";
+import { Agent } from "@mastra/core/agent";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { buildModel } from "./model.js";
+import { TYPOGRAPHY_RULE } from "./style.js";
+const logger = log.logger("mastra/follow-up-suggestions");
+const FOLLOW_UP_MODEL_CLASS = model.ModelClass.ChatFast;
+const DEFAULT_QUESTION_LIMIT = 3;
+const MAX_QUESTION_LIMIT = 10;
+const DEFAULT_TIMEOUT_MS = 10_000;
+const MAX_TURN_CONTEXT_CHARS = 16_000;
+const GENERIC_QUESTIONS = new Set([
+    "anything else",
+    "can you tell me more",
+    "tell me more",
+    "what else",
+    "what would you like to know",
+]);
+const ASSISTANT_DIRECTED_QUESTIONS = [
+    /^(?:would|do) you (?:like|want|prefer)\b/,
+    /^(?:should|shall|can|may) (?:i|we)\b/,
+    /^are you interested\b/,
+    /^should (?:the |this )?(?:chart|graph|table|visualization|response|output|results?|data)\b/,
+];
+/** Trusted request-context key carrying the current user message. */
+export const FOLLOW_UP_USER_TEXT_KEY = "mastra__follow_up_user_text";
+/** Trusted request-context key carrying native Genie follow-up questions. */
+export const FOLLOW_UP_NATIVE_QUESTIONS_KEY = "mastra__follow_up_native_questions";
+/** Trusted request-context key coordinating one post-turn stream with its processor. */
+export const FOLLOW_UP_RUN_ID_KEY = "mastra__follow_up_run_id";
+const FollowUpOutputSchema = z
+    .object({
+    questions: z
+        .array(z.string().trim().min(1))
+        .max(MAX_QUESTION_LIMIT)
+        .describe("Specific next questions grounded in the completed turn."),
+})
+    .strict();
+const FollowUpToolInputSchema = z
+    .object({
+    userText: z.string().trim().min(1).describe("User message that started the completed turn."),
+    answer: z.string().trim().min(1).describe("Assistant answer from the completed turn."),
+    turnContext: z
+        .string()
+        .trim()
+        .max(MAX_TURN_CONTEXT_CHARS)
+        .optional()
+        .describe("Relevant tool inputs and outputs from the completed turn."),
+    nativeQuestions: z
+        .array(z.string().trim().min(1))
+        .optional()
+        .describe("Existing follow-up questions to avoid repeating."),
+})
+    .strict();
+const FOLLOW_UP_INSTRUCTIONS = [
+    "Generate concise questions that a user can send to dig further into a completed assistant turn.",
+    "Write every item in the user's voice as a message for the assistant to answer when clicked.",
+    "Never address the user or ask what they would like, want, prefer, or how the response should be customized.",
+    "Every question must be answerable from the same tools and data domain as the completed turn.",
+    "Ground questions in the answer and turn tool data, including displayed chart or table values.",
+    "Prefer concrete analyses, comparisons, rankings, calculations, filters, or explanations of the result.",
+    "For a chart or table, ask about the values and patterns before suggesting presentation changes.",
+    "Good examples include 'Which category has the highest value?', 'How large is the gap between the highest and lowest categories?', and 'What pattern stands out in these values?'.",
+    "Do not repeat the user's question, the answer, or an existing suggestion.",
+    "Do not ask generic filler such as 'Anything else?' or request unsupported data.",
+    "Return zero questions when no useful grounded follow-up exists.",
+    TYPOGRAPHY_RULE,
+].join(" ");
+const suggestionAgents = new WeakMap();
+const generatedRunParts = new Map();
+const GENERATED_RUN_PART_TTL_MS = 5 * 60_000;
+/** Resolve disabled, shorthand, and configured suggestion policy forms. */
+export function resolveFollowUpSuggestionsConfig(value) {
+    if (!value)
+        return undefined;
+    const configured = typeof value === "object" ? value : { mode: value };
+    return {
+        mode: configured.mode === true ? "auto" : configured.mode,
+        limit: Math.min(MAX_QUESTION_LIMIT, Math.max(1, configured.limit ?? DEFAULT_QUESTION_LIMIT)),
+        timeoutMs: Math.min(30_000, Math.max(1_000, configured.timeoutMs ?? DEFAULT_TIMEOUT_MS)),
+        exposeTool: configured.exposeTool ?? false,
+    };
+}
+function followUpModel(config) {
+    return ({ requestContext }) => buildModel(config, requestContext, { modelClass: FOLLOW_UP_MODEL_CLASS });
+}
+function suggestionAgent(config) {
+    let agent = suggestionAgents.get(config);
+    if (!agent) {
+        agent = new Agent({
+            id: "follow-up-suggestions",
+            name: "Follow-up suggestions",
+            description: "Generates grounded next questions using the fast chat model.",
+            instructions: FOLLOW_UP_INSTRUCTIONS,
+            model: followUpModel(config),
+        });
+        suggestionAgents.set(config, agent);
+    }
+    return agent;
+}
+function normalizedQuestion(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s]/gu, " ")
+        .replace(/\s+/g, " ");
+}
+function acceptedQuestions(questions, options, maxQuestions) {
+    const excluded = new Set([
+        normalizedQuestion(options.userText),
+        ...(options.nativeQuestions ?? []).map(normalizedQuestion),
+    ]);
+    const accepted = [];
+    for (const question of questions) {
+        const trimmed = question.trim();
+        const normalized = normalizedQuestion(trimmed);
+        if (!normalized ||
+            normalized.length < 8 ||
+            excluded.has(normalized) ||
+            GENERIC_QUESTIONS.has(normalized) ||
+            ASSISTANT_DIRECTED_QUESTIONS.some((pattern) => pattern.test(normalized))) {
+            continue;
+        }
+        excluded.add(normalized);
+        accepted.push(trimmed);
+        if (accepted.length >= maxQuestions)
+            break;
+    }
+    return accepted;
+}
+function toolActivityValue(value) {
+    if (!object.isRecord(value))
+        return undefined;
+    return object.isRecord(value.payload) ? value.payload : value;
+}
+function toolActivityName(value) {
+    if (typeof value.toolName === "string")
+        return value.toolName;
+    return typeof value.name === "string" ? value.name : undefined;
+}
+function serializedTurnContext(steps) {
+    const activity = steps.flatMap((step) => [
+        ...(step.toolCalls ?? []).flatMap((call) => {
+            const value = toolActivityValue(call);
+            const tool = value ? toolActivityName(value) : undefined;
+            if (!value || !tool)
+                return [];
+            return [{ tool, input: value.args ?? value.input }];
+        }),
+        ...(step.toolResults ?? []).flatMap((result) => {
+            const value = toolActivityValue(result);
+            const tool = value ? toolActivityName(value) : undefined;
+            if (!value || !tool)
+                return [];
+            return [
+                {
+                    tool,
+                    output: value.result ?? value.output,
+                    ...(value.isError || value.error ? { isError: true } : {}),
+                },
+            ];
+        }),
+    ]);
+    if (activity.length === 0)
+        return undefined;
+    try {
+        const serialized = JSON.stringify(activity.slice(-12));
+        return serialized.length > MAX_TURN_CONTEXT_CHARS
+            ? serialized.slice(0, MAX_TURN_CONTEXT_CHARS)
+            : serialized;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Generate grounded follow-ups through ChatFast, failing open to an empty list. */
+export async function suggestFollowUps(config, options) {
+    const settings = resolveFollowUpSuggestionsConfig(config.followUpSuggestions);
+    if (!settings || settings.mode === "genie")
+        return [];
+    const timeout = AbortSignal.timeout(settings.timeoutMs);
+    const abortSignal = asyncUtils.combineAbortSignals(options.abortSignal, timeout);
+    const prompt = stringUtils.toDescription({
+        "User message": options.userText,
+        "Assistant answer": options.answer,
+        ...(options.turnContext ? { "Turn tool data": options.turnContext } : {}),
+        ...(options.nativeQuestions?.length
+            ? { "Existing suggestions": JSON.stringify(options.nativeQuestions) }
+            : {}),
+        "Maximum questions": String(settings.limit),
+    });
+    try {
+        const result = await suggestionAgent(config).generate(prompt, {
+            structuredOutput: { schema: FollowUpOutputSchema },
+            ...(options.requestContext ? { requestContext: options.requestContext } : {}),
+            abortSignal,
+        });
+        const parsed = FollowUpOutputSchema.parse(result.object);
+        return acceptedQuestions(parsed.questions, options, settings.limit);
+    }
+    catch (error) {
+        if (!options.abortSignal?.aborted) {
+            logger.warn("generation-failed", { error: errorUtils.errorMessage(error) });
+        }
+        return [];
+    }
+}
+function lastAssistantResponse(messageList) {
+    const messages = messageList.get.response.db();
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role === "assistant")
+            return message;
+    }
+    return undefined;
+}
+function persistedFollowUpData(messageList) {
+    const message = lastAssistantResponse(messageList);
+    if (!message)
+        return undefined;
+    for (const part of message.content.parts) {
+        if (part.type !== FOLLOW_UP_SUGGESTIONS_PART_TYPE || !("data" in part))
+            continue;
+        const parsed = FollowUpSuggestionsPartDataSchema.safeParse(part.data);
+        if (parsed.success)
+            return parsed.data;
+    }
+    return undefined;
+}
+function persistFollowUpData(messageList, data) {
+    const message = lastAssistantResponse(messageList);
+    if (!message)
+        return;
+    messageList.add({
+        id: message.id,
+        role: "assistant",
+        parts: [{ type: FOLLOW_UP_SUGGESTIONS_PART_TYPE, data }],
+    }, "response", { merge: true });
+}
+function rememberGeneratedRunPart(runId, data) {
+    if (!runId)
+        return;
+    generatedRunParts.set(runId, data);
+    const timer = setTimeout(() => generatedRunParts.delete(runId), GENERATED_RUN_PART_TTL_MS);
+    timer.unref();
+}
+/** Build Mastra's final output processor for configured generated follow-ups. */
+export function buildFollowUpSuggestionsProcessor(config, suggester = suggestFollowUps) {
+    const settings = resolveFollowUpSuggestionsConfig(config.followUpSuggestions);
+    if (!settings || settings.mode === "genie")
+        return undefined;
+    return {
+        id: "follow-up-suggestions",
+        async processOutputResult({ result, messageList, requestContext, abortSignal, }) {
+            if (!requestContext || result.finishReason === "abort" || result.finishReason === "error") {
+                return messageList;
+            }
+            const runIdValue = requestContext.getRaw(FOLLOW_UP_RUN_ID_KEY);
+            const runId = typeof runIdValue === "string" ? runIdValue : undefined;
+            const persisted = persistedFollowUpData(messageList);
+            if (persisted) {
+                rememberGeneratedRunPart(runId, persisted);
+                return messageList;
+            }
+            const answer = result.text.trim();
+            const userText = requestContext.getRaw(FOLLOW_UP_USER_TEXT_KEY);
+            if (!answer || typeof userText !== "string")
+                return messageList;
+            const nativeValue = requestContext.getRaw(FOLLOW_UP_NATIVE_QUESTIONS_KEY);
+            const nativeQuestions = settings.mode === "auto" && Array.isArray(nativeValue)
+                ? nativeValue.filter((value) => typeof value === "string")
+                : [];
+            const turnContext = serializedTurnContext(result.steps);
+            const suggestionOptions = {
+                userText,
+                answer,
+                ...(turnContext ? { turnContext } : {}),
+                ...(nativeQuestions.length > 0 ? { nativeQuestions } : {}),
+                requestContext,
+                ...(abortSignal ? { abortSignal } : {}),
+            };
+            const suggested = await suggester(config, suggestionOptions);
+            const questions = acceptedQuestions(suggested, suggestionOptions, settings.limit);
+            if (questions.length === 0)
+                return messageList;
+            const data = FollowUpSuggestionsPartDataSchema.parse({
+                questions,
+                source: "model",
+            });
+            persistFollowUpData(messageList, data);
+            rememberGeneratedRunPart(runId, data);
+            return messageList;
+        },
+    };
+}
+/** Inject the processor's persisted data part before Mastra's finish chunk. */
+export function buildFollowUpSuggestionsTransform(runId) {
+    return () => new TransformStream({
+        transform(chunk, controller) {
+            if (chunk.type === "finish") {
+                const data = generatedRunParts.get(runId);
+                if (data) {
+                    const part = {
+                        type: FOLLOW_UP_SUGGESTIONS_PART_TYPE,
+                        data,
+                    };
+                    controller.enqueue(part);
+                }
+            }
+            controller.enqueue(chunk);
+        },
+    });
+}
+/** Build the optional explicitly callable follow-up suggestion tool. */
+export function buildSuggestFollowUpsTool(config) {
+    return createTool({
+        id: "suggest_follow_ups",
+        description: "Generate a short list of grounded follow-up questions for a completed user message and answer.",
+        inputSchema: FollowUpToolInputSchema,
+        outputSchema: FollowUpOutputSchema,
+        execute: async (input, context) => {
+            const values = FollowUpToolInputSchema.parse(input);
+            const questions = await suggestFollowUps(config, {
+                userText: values.userText,
+                answer: values.answer,
+                ...(values.turnContext ? { turnContext: values.turnContext } : {}),
+                ...(values.nativeQuestions ? { nativeQuestions: values.nativeQuestions } : {}),
+                ...(context?.requestContext ? { requestContext: context.requestContext } : {}),
+                ...(context?.abortSignal ? { abortSignal: context.abortSignal } : {}),
+            });
+            return { questions };
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"follow-up-suggestions.js","sourceRoot":"","sources":["../../src/follow-up-suggestions.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ChatFast post-turn follow-up suggestion generation.\n *\n * @module\n */\n\nimport { asyncUtils, errorUtils, log, object, stringUtils } from \"@dbx-tools/shared-core\";\nimport {\n  FOLLOW_UP_SUGGESTIONS_PART_TYPE,\n  type FollowUpSuggestionsPartData,\n  FollowUpSuggestionsPartDataSchema,\n} from \"@dbx-tools/shared-mastra/wire\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport { Agent } from \"@mastra/core/agent\";\nimport type { MessageList } from \"@mastra/core/agent/message-list\";\nimport type { MastraModelConfig } from \"@mastra/core/llm\";\nimport type { OutputProcessor } from \"@mastra/core/processors\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport type { DataChunkType, LLMStepResult, MastraStreamTransform } from \"@mastra/core/stream\";\nimport { createTool } from \"@mastra/core/tools\";\nimport { z } from \"zod\";\n\nimport type { FollowUpSuggestionsConfig, MastraPluginConfig } from \"./config.ts\";\nimport { buildModel } from \"./model.ts\";\nimport { TYPOGRAPHY_RULE } from \"./style.ts\";\n\nconst logger = log.logger(\"mastra/follow-up-suggestions\");\nconst FOLLOW_UP_MODEL_CLASS = model.ModelClass.ChatFast;\nconst DEFAULT_QUESTION_LIMIT = 3;\nconst MAX_QUESTION_LIMIT = 10;\nconst DEFAULT_TIMEOUT_MS = 10_000;\nconst MAX_TURN_CONTEXT_CHARS = 16_000;\nconst GENERIC_QUESTIONS = new Set([\n  \"anything else\",\n  \"can you tell me more\",\n  \"tell me more\",\n  \"what else\",\n  \"what would you like to know\",\n]);\nconst ASSISTANT_DIRECTED_QUESTIONS = [\n  /^(?:would|do) you (?:like|want|prefer)\\b/,\n  /^(?:should|shall|can|may) (?:i|we)\\b/,\n  /^are you interested\\b/,\n  /^should (?:the |this )?(?:chart|graph|table|visualization|response|output|results?|data)\\b/,\n] as const;\n\n/** Trusted request-context key carrying the current user message. */\nexport const FOLLOW_UP_USER_TEXT_KEY = \"mastra__follow_up_user_text\";\n/** Trusted request-context key carrying native Genie follow-up questions. */\nexport const FOLLOW_UP_NATIVE_QUESTIONS_KEY = \"mastra__follow_up_native_questions\";\n/** Trusted request-context key coordinating one post-turn stream with its processor. */\nexport const FOLLOW_UP_RUN_ID_KEY = \"mastra__follow_up_run_id\";\n\n/** Fully resolved follow-up suggestion settings. */\nexport interface ResolvedFollowUpSuggestionsConfig {\n  mode: \"auto\" | \"generated\" | \"genie\";\n  limit: number;\n  timeoutMs: number;\n  exposeTool: boolean;\n}\n\n/** Inputs for one follow-up generation pass. */\nexport interface SuggestFollowUpsOptions {\n  userText: string;\n  answer: string;\n  /** Bounded serialized tool inputs and outputs that ground the next questions. */\n  turnContext?: string;\n  nativeQuestions?: readonly string[];\n  requestContext?: RequestContext;\n  abortSignal?: AbortSignal;\n}\n\n/** Replaceable suggestion boundary used by the finish callback and tests. */\nexport type FollowUpSuggester = (\n  config: MastraPluginConfig,\n  options: SuggestFollowUpsOptions,\n) => Promise<string[]>;\n\nconst FollowUpOutputSchema = z\n  .object({\n    questions: z\n      .array(z.string().trim().min(1))\n      .max(MAX_QUESTION_LIMIT)\n      .describe(\"Specific next questions grounded in the completed turn.\"),\n  })\n  .strict();\n\nconst FollowUpToolInputSchema = z\n  .object({\n    userText: z.string().trim().min(1).describe(\"User message that started the completed turn.\"),\n    answer: z.string().trim().min(1).describe(\"Assistant answer from the completed turn.\"),\n    turnContext: z\n      .string()\n      .trim()\n      .max(MAX_TURN_CONTEXT_CHARS)\n      .optional()\n      .describe(\"Relevant tool inputs and outputs from the completed turn.\"),\n    nativeQuestions: z\n      .array(z.string().trim().min(1))\n      .optional()\n      .describe(\"Existing follow-up questions to avoid repeating.\"),\n  })\n  .strict();\n\nconst FOLLOW_UP_INSTRUCTIONS = [\n  \"Generate concise questions that a user can send to dig further into a completed assistant turn.\",\n  \"Write every item in the user's voice as a message for the assistant to answer when clicked.\",\n  \"Never address the user or ask what they would like, want, prefer, or how the response should be customized.\",\n  \"Every question must be answerable from the same tools and data domain as the completed turn.\",\n  \"Ground questions in the answer and turn tool data, including displayed chart or table values.\",\n  \"Prefer concrete analyses, comparisons, rankings, calculations, filters, or explanations of the result.\",\n  \"For a chart or table, ask about the values and patterns before suggesting presentation changes.\",\n  \"Good examples include 'Which category has the highest value?', 'How large is the gap between the highest and lowest categories?', and 'What pattern stands out in these values?'.\",\n  \"Do not repeat the user's question, the answer, or an existing suggestion.\",\n  \"Do not ask generic filler such as 'Anything else?' or request unsupported data.\",\n  \"Return zero questions when no useful grounded follow-up exists.\",\n  TYPOGRAPHY_RULE,\n].join(\" \");\n\nconst suggestionAgents = new WeakMap<MastraPluginConfig, Agent>();\nconst generatedRunParts = new Map<string, FollowUpSuggestionsPartData>();\nconst GENERATED_RUN_PART_TTL_MS = 5 * 60_000;\n\n/** Resolve disabled, shorthand, and configured suggestion policy forms. */\nexport function resolveFollowUpSuggestionsConfig(\n  value: MastraPluginConfig[\"followUpSuggestions\"],\n): ResolvedFollowUpSuggestionsConfig | undefined {\n  if (!value) return undefined;\n  const configured: FollowUpSuggestionsConfig = typeof value === \"object\" ? value : { mode: value };\n  return {\n    mode: configured.mode === true ? \"auto\" : configured.mode,\n    limit: Math.min(MAX_QUESTION_LIMIT, Math.max(1, configured.limit ?? DEFAULT_QUESTION_LIMIT)),\n    timeoutMs: Math.min(30_000, Math.max(1_000, configured.timeoutMs ?? DEFAULT_TIMEOUT_MS)),\n    exposeTool: configured.exposeTool ?? false,\n  };\n}\n\nfunction followUpModel(\n  config: MastraPluginConfig,\n): (args: { requestContext: RequestContext }) => Promise<MastraModelConfig> {\n  return ({ requestContext }) =>\n    buildModel(config, requestContext, { modelClass: FOLLOW_UP_MODEL_CLASS });\n}\n\nfunction suggestionAgent(config: MastraPluginConfig): Agent {\n  let agent = suggestionAgents.get(config);\n  if (!agent) {\n    agent = new Agent({\n      id: \"follow-up-suggestions\",\n      name: \"Follow-up suggestions\",\n      description: \"Generates grounded next questions using the fast chat model.\",\n      instructions: FOLLOW_UP_INSTRUCTIONS,\n      model: followUpModel(config),\n    });\n    suggestionAgents.set(config, agent);\n  }\n  return agent;\n}\n\nfunction normalizedQuestion(value: string): string {\n  return value\n    .trim()\n    .toLowerCase()\n    .replace(/[^\\p{L}\\p{N}\\s]/gu, \" \")\n    .replace(/\\s+/g, \" \");\n}\n\nfunction acceptedQuestions(\n  questions: readonly string[],\n  options: SuggestFollowUpsOptions,\n  maxQuestions: number,\n): string[] {\n  const excluded = new Set([\n    normalizedQuestion(options.userText),\n    ...(options.nativeQuestions ?? []).map(normalizedQuestion),\n  ]);\n  const accepted: string[] = [];\n  for (const question of questions) {\n    const trimmed = question.trim();\n    const normalized = normalizedQuestion(trimmed);\n    if (\n      !normalized ||\n      normalized.length < 8 ||\n      excluded.has(normalized) ||\n      GENERIC_QUESTIONS.has(normalized) ||\n      ASSISTANT_DIRECTED_QUESTIONS.some((pattern) => pattern.test(normalized))\n    ) {\n      continue;\n    }\n    excluded.add(normalized);\n    accepted.push(trimmed);\n    if (accepted.length >= maxQuestions) break;\n  }\n  return accepted;\n}\n\nfunction toolActivityValue(value: unknown): Record<string, unknown> | undefined {\n  if (!object.isRecord(value)) return undefined;\n  return object.isRecord(value.payload) ? value.payload : value;\n}\n\nfunction toolActivityName(value: Record<string, unknown>): string | undefined {\n  if (typeof value.toolName === \"string\") return value.toolName;\n  return typeof value.name === \"string\" ? value.name : undefined;\n}\n\nfunction serializedTurnContext(steps: readonly LLMStepResult[]): string | undefined {\n  const activity = steps.flatMap((step) => [\n    ...(step.toolCalls ?? []).flatMap((call) => {\n      const value = toolActivityValue(call);\n      const tool = value ? toolActivityName(value) : undefined;\n      if (!value || !tool) return [];\n      return [{ tool, input: value.args ?? value.input }];\n    }),\n    ...(step.toolResults ?? []).flatMap((result) => {\n      const value = toolActivityValue(result);\n      const tool = value ? toolActivityName(value) : undefined;\n      if (!value || !tool) return [];\n      return [\n        {\n          tool,\n          output: value.result ?? value.output,\n          ...(value.isError || value.error ? { isError: true } : {}),\n        },\n      ];\n    }),\n  ]);\n  if (activity.length === 0) return undefined;\n  try {\n    const serialized = JSON.stringify(activity.slice(-12));\n    return serialized.length > MAX_TURN_CONTEXT_CHARS\n      ? serialized.slice(0, MAX_TURN_CONTEXT_CHARS)\n      : serialized;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Generate grounded follow-ups through ChatFast, failing open to an empty list. */\nexport async function suggestFollowUps(\n  config: MastraPluginConfig,\n  options: SuggestFollowUpsOptions,\n): Promise<string[]> {\n  const settings = resolveFollowUpSuggestionsConfig(config.followUpSuggestions);\n  if (!settings || settings.mode === \"genie\") return [];\n  const timeout = AbortSignal.timeout(settings.timeoutMs);\n  const abortSignal = asyncUtils.combineAbortSignals(options.abortSignal, timeout);\n  const prompt = stringUtils.toDescription({\n    \"User message\": options.userText,\n    \"Assistant answer\": options.answer,\n    ...(options.turnContext ? { \"Turn tool data\": options.turnContext } : {}),\n    ...(options.nativeQuestions?.length\n      ? { \"Existing suggestions\": JSON.stringify(options.nativeQuestions) }\n      : {}),\n    \"Maximum questions\": String(settings.limit),\n  });\n  try {\n    const result = await suggestionAgent(config).generate(prompt, {\n      structuredOutput: { schema: FollowUpOutputSchema },\n      ...(options.requestContext ? { requestContext: options.requestContext } : {}),\n      abortSignal,\n    });\n    const parsed = FollowUpOutputSchema.parse(result.object);\n    return acceptedQuestions(parsed.questions, options, settings.limit);\n  } catch (error) {\n    if (!options.abortSignal?.aborted) {\n      logger.warn(\"generation-failed\", { error: errorUtils.errorMessage(error) });\n    }\n    return [];\n  }\n}\n\nfunction lastAssistantResponse(messageList: MessageList) {\n  const messages = messageList.get.response.db();\n  for (let index = messages.length - 1; index >= 0; index -= 1) {\n    const message = messages[index];\n    if (message?.role === \"assistant\") return message;\n  }\n  return undefined;\n}\n\nfunction persistedFollowUpData(messageList: MessageList): FollowUpSuggestionsPartData | undefined {\n  const message = lastAssistantResponse(messageList);\n  if (!message) return undefined;\n  for (const part of message.content.parts) {\n    if (part.type !== FOLLOW_UP_SUGGESTIONS_PART_TYPE || !(\"data\" in part)) continue;\n    const parsed = FollowUpSuggestionsPartDataSchema.safeParse(part.data);\n    if (parsed.success) return parsed.data;\n  }\n  return undefined;\n}\n\nfunction persistFollowUpData(messageList: MessageList, data: FollowUpSuggestionsPartData): void {\n  const message = lastAssistantResponse(messageList);\n  if (!message) return;\n  messageList.add(\n    {\n      id: message.id,\n      role: \"assistant\",\n      parts: [{ type: FOLLOW_UP_SUGGESTIONS_PART_TYPE, data }],\n    },\n    \"response\",\n    { merge: true },\n  );\n}\n\nfunction rememberGeneratedRunPart(runId: string | undefined, data: FollowUpSuggestionsPartData) {\n  if (!runId) return;\n  generatedRunParts.set(runId, data);\n  const timer = setTimeout(() => generatedRunParts.delete(runId), GENERATED_RUN_PART_TTL_MS);\n  timer.unref();\n}\n\n/** Build Mastra's final output processor for configured generated follow-ups. */\nexport function buildFollowUpSuggestionsProcessor(\n  config: MastraPluginConfig,\n  suggester: FollowUpSuggester = suggestFollowUps,\n): OutputProcessor | undefined {\n  const settings = resolveFollowUpSuggestionsConfig(config.followUpSuggestions);\n  if (!settings || settings.mode === \"genie\") return undefined;\n  return {\n    id: \"follow-up-suggestions\",\n    async processOutputResult({\n      result,\n      messageList,\n      requestContext,\n      abortSignal,\n    }): Promise<MessageList> {\n      if (!requestContext || result.finishReason === \"abort\" || result.finishReason === \"error\") {\n        return messageList;\n      }\n      const runIdValue = requestContext.getRaw(FOLLOW_UP_RUN_ID_KEY);\n      const runId = typeof runIdValue === \"string\" ? runIdValue : undefined;\n      const persisted = persistedFollowUpData(messageList);\n      if (persisted) {\n        rememberGeneratedRunPart(runId, persisted);\n        return messageList;\n      }\n      const answer = result.text.trim();\n      const userText = requestContext.getRaw(FOLLOW_UP_USER_TEXT_KEY);\n      if (!answer || typeof userText !== \"string\") return messageList;\n      const nativeValue = requestContext.getRaw(FOLLOW_UP_NATIVE_QUESTIONS_KEY);\n      const nativeQuestions =\n        settings.mode === \"auto\" && Array.isArray(nativeValue)\n          ? nativeValue.filter((value): value is string => typeof value === \"string\")\n          : [];\n      const turnContext = serializedTurnContext(result.steps);\n      const suggestionOptions: SuggestFollowUpsOptions = {\n        userText,\n        answer,\n        ...(turnContext ? { turnContext } : {}),\n        ...(nativeQuestions.length > 0 ? { nativeQuestions } : {}),\n        requestContext,\n        ...(abortSignal ? { abortSignal } : {}),\n      };\n      const suggested = await suggester(config, suggestionOptions);\n      const questions = acceptedQuestions(suggested, suggestionOptions, settings.limit);\n      if (questions.length === 0) return messageList;\n      const data = FollowUpSuggestionsPartDataSchema.parse({\n        questions,\n        source: \"model\",\n      });\n      persistFollowUpData(messageList, data);\n      rememberGeneratedRunPart(runId, data);\n      return messageList;\n    },\n  };\n}\n\n/** Inject the processor's persisted data part before Mastra's finish chunk. */\nexport function buildFollowUpSuggestionsTransform(runId: string): MastraStreamTransform {\n  return () =>\n    new TransformStream({\n      transform(chunk, controller) {\n        if (chunk.type === \"finish\") {\n          const data = generatedRunParts.get(runId);\n          if (data) {\n            const part: DataChunkType = {\n              type: FOLLOW_UP_SUGGESTIONS_PART_TYPE,\n              data,\n            };\n            controller.enqueue(part as never);\n          }\n        }\n        controller.enqueue(chunk);\n      },\n    });\n}\n\n/** Build the optional explicitly callable follow-up suggestion tool. */\nexport function buildSuggestFollowUpsTool(config: MastraPluginConfig) {\n  return createTool({\n    id: \"suggest_follow_ups\",\n    description:\n      \"Generate a short list of grounded follow-up questions for a completed user message and answer.\",\n    inputSchema: FollowUpToolInputSchema,\n    outputSchema: FollowUpOutputSchema,\n    execute: async (input, context) => {\n      const values = FollowUpToolInputSchema.parse(input);\n      const questions = await suggestFollowUps(config, {\n        userText: values.userText,\n        answer: values.answer,\n        ...(values.turnContext ? { turnContext: values.turnContext } : {}),\n        ...(values.nativeQuestions ? { nativeQuestions: values.nativeQuestions } : {}),\n        ...(context?.requestContext ? { requestContext: context.requestContext } : {}),\n        ...(context?.abortSignal ? { abortSignal: context.abortSignal } : {}),\n      });\n      return { questions };\n    },\n  });\n}\n"]}