@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/summarize.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Small-tier summarization for the Mastra plugin.
+ *
+ * Two surfaces, both backed by the fast / small chat tier
+ * ({@link model.ModelClass.ChatFast}) resolved through the same
+ * `/serving-endpoints` pipeline as the main agents:
+ *
+ *   - A dedicated `summarize` tool (see {@link buildSummarizeTool})
+ *     agents can call to condense arbitrary text without burning the
+ *     heavyweight chat model.
+ *   - The model + instructions Mastra's memory uses to auto-name
+ *     conversation threads (`generateTitle`), so titling reuses the
+ *     same small tier rather than the agent's primary model.
+ *
+ * Mirrors the chart-planner wiring in `chart.ts`: a per-config cached
+ * `Agent` on the fast tier, invoked via `agent.generate(...)` inside
+ * the active `asUser` scope so tokens stay user-scoped.
+ *
+ * @module
+ */
+import type { MastraModelConfig } from "@mastra/core/llm";
+import type { RequestContext } from "@mastra/core/request-context";
+import type { MastraPluginConfig } from "./config.js";
+/**
+ * Instructions Mastra's `generateTitle` hands the small-tier model to
+ * name a conversation thread from its opening turn. Kept terse so the
+ * model returns a bare title with no decoration.
+ */
+export declare const TITLE_INSTRUCTIONS: string;
+/**
+ * Resolve the small-tier model for summarization / titling. Reused by
+ * both the summarizer agent and Mastra memory's `generateTitle`.
+ *
+ * Returned as a `requestContext`-taking function (a Mastra
+ * `DynamicArgument<MastraModelConfig>`) so each call mints user-scoped
+ * tokens via {@link buildModel}, exactly like the primary agents.
+ */
+export declare function summaryModel(config: MastraPluginConfig): (args: {
+    requestContext: RequestContext;
+}) => Promise<MastraModelConfig>;
+/** Options accepted by {@link summarizeText}. */
+export interface SummarizeOptions {
+    /** Extra guidance for the summary (length, focus, format). */
+    instructions?: string;
+    /** Soft cap on summary length, in words. */
+    maxWords?: number;
+    /** Active request context, so the model resolver mints user-scoped tokens. */
+    requestContext?: RequestContext;
+    /** Abort signal bridged from the calling tool / request. */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Summarize `text` with the small-tier summarizer agent, returning the
+ * trimmed summary string. Throws on model failure (the caller decides
+ * how to degrade).
+ */
+export declare function summarizeText(config: MastraPluginConfig, text: string, options?: SummarizeOptions): Promise<string>;
+/**
+ * Build the `summarize` tool. Exposed as an ambient system tool (like
+ * `render_data`) so every agent can offload condensing long content,
+ * notes, transcripts, or bulky tool results to the fast tier instead of
+ * spending its primary chat model. The tool reads the live
+ * `requestContext` / `abortSignal` off the Mastra execution context so
+ * its model call stays user-scoped and cancels with the turn.
+ */
+export declare function buildSummarizeTool(config: MastraPluginConfig): import("@mastra/core/tools").Tool<{
+    text: string;
+    instructions?: string | undefined;
+    maxWords?: number | undefined;
+}, unknown, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "summarize", unknown>;

package/lib/src/summarize.js

@@ -0,0 +1,142 @@
+/**
+ * Small-tier summarization for the Mastra plugin.
+ *
+ * Two surfaces, both backed by the fast / small chat tier
+ * ({@link model.ModelClass.ChatFast}) resolved through the same
+ * `/serving-endpoints` pipeline as the main agents:
+ *
+ *   - A dedicated `summarize` tool (see {@link buildSummarizeTool})
+ *     agents can call to condense arbitrary text without burning the
+ *     heavyweight chat model.
+ *   - The model + instructions Mastra's memory uses to auto-name
+ *     conversation threads (`generateTitle`), so titling reuses the
+ *     same small tier rather than the agent's primary model.
+ *
+ * Mirrors the chart-planner wiring in `chart.ts`: a per-config cached
+ * `Agent` on the fast tier, invoked via `agent.generate(...)` inside
+ * the active `asUser` scope so tokens stay user-scoped.
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+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";
+/** Fast / small chat tier used for both titling and summaries. */
+const SUMMARY_MODEL_CLASS = model.ModelClass.ChatFast;
+/** System prompt for the summarizer agent (and the `summarize` tool). */
+const SUMMARIZER_INSTRUCTIONS = [
+    "You are a summarization engine.",
+    "Given a block of text, produce a faithful, concise summary of it.",
+    "Default to a few sentences; follow any length guidance the caller gives.",
+    "Plain prose. No preamble, no headers, no bullet points unless asked.",
+    "Never use emojis. Use hyphens (-) only, never em dashes or en dashes.",
+    "Never add information, opinions, or details not present in the input.",
+    "Output only the summary.",
+].join("\n");
+/**
+ * Instructions Mastra's `generateTitle` hands the small-tier model to
+ * name a conversation thread from its opening turn. Kept terse so the
+ * model returns a bare title with no decoration.
+ */
+export const TITLE_INSTRUCTIONS = [
+    "Generate a short, specific title for this conversation, 3 to 6 words.",
+    "Capture the user's topic, not the assistant's response.",
+    "Plain text only: no surrounding quotes, no trailing punctuation,",
+    "no emojis, and no em dashes. Output only the title.",
+].join(" ");
+/**
+ * Resolve the small-tier model for summarization / titling. Reused by
+ * both the summarizer agent and Mastra memory's `generateTitle`.
+ *
+ * Returned as a `requestContext`-taking function (a Mastra
+ * `DynamicArgument<MastraModelConfig>`) so each call mints user-scoped
+ * tokens via {@link buildModel}, exactly like the primary agents.
+ */
+export function summaryModel(config) {
+    return ({ requestContext }) => buildModel(config, requestContext, { modelClass: SUMMARY_MODEL_CLASS });
+}
+/**
+ * One summarizer `Agent` per plugin config, cached on config-object
+ * identity so a hot tool path doesn't pay the constructor cost each
+ * call. `WeakMap` lets retired configs (e.g. test reconfigurations)
+ * release their agent without manual eviction.
+ */
+const summarizerAgents = new WeakMap();
+function getSummarizerAgent(config) {
+    let agent = summarizerAgents.get(config);
+    if (!agent) {
+        agent = new Agent({
+            id: "summarizer",
+            name: "Summarizer",
+            description: "Condenses text into a short summary using a fast, small model.",
+            instructions: SUMMARIZER_INSTRUCTIONS,
+            model: summaryModel(config),
+        });
+        summarizerAgents.set(config, agent);
+    }
+    return agent;
+}
+/** Inputs accepted by the `summarize` tool. */
+const summarizeInput = z.object({
+    text: z.string().min(1).describe("The text to summarize."),
+    instructions: z
+        .string()
+        .optional()
+        .describe("Optional extra guidance for the summary, e.g. 'one sentence' or 'list the action items'."),
+    maxWords: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Optional soft cap on the summary length, in words."),
+});
+/**
+ * Summarize `text` with the small-tier summarizer agent, returning the
+ * trimmed summary string. Throws on model failure (the caller decides
+ * how to degrade).
+ */
+export async function summarizeText(config, text, options = {}) {
+    const { instructions, maxWords, requestContext, abortSignal } = options;
+    const prompt = string.toDescription({
+        ...(instructions ? { Guidance: instructions } : {}),
+        ...(maxWords !== undefined ? { "Max length (words)": String(maxWords) } : {}),
+        Text: text,
+    });
+    const result = await getSummarizerAgent(config).generate(prompt, {
+        ...(requestContext ? { requestContext } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+    });
+    return result.text.trim();
+}
+/**
+ * Build the `summarize` tool. Exposed as an ambient system tool (like
+ * `render_data`) so every agent can offload condensing long content,
+ * notes, transcripts, or bulky tool results to the fast tier instead of
+ * spending its primary chat model. The tool reads the live
+ * `requestContext` / `abortSignal` off the Mastra execution context so
+ * its model call stays user-scoped and cancels with the turn.
+ */
+export function buildSummarizeTool(config) {
+    return createTool({
+        id: "summarize",
+        description: "Summarize a block of text using a fast, small model. Use it to condense long " +
+            "content, notes, transcripts, or tool results into a short summary without " +
+            "spending the main chat model.",
+        inputSchema: summarizeInput,
+        execute: async (input, context) => {
+            const { text, instructions, maxWords } = input;
+            const ctx = context;
+            const summary = await summarizeText(config, text, {
+                ...(instructions ? { instructions } : {}),
+                ...(maxWords !== undefined ? { maxWords } : {}),
+                ...(ctx?.requestContext ? { requestContext: ctx.requestContext } : {}),
+                ...(ctx?.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
+            });
+            return { summary };
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"summarize.js","sourceRoot":"","sources":["../../src/summarize.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Small-tier summarization for the Mastra plugin.\n *\n * Two surfaces, both backed by the fast / small chat tier\n * ({@link model.ModelClass.ChatFast}) resolved through the same\n * `/serving-endpoints` pipeline as the main agents:\n *\n *   - A dedicated `summarize` tool (see {@link buildSummarizeTool})\n *     agents can call to condense arbitrary text without burning the\n *     heavyweight chat model.\n *   - The model + instructions Mastra's memory uses to auto-name\n *     conversation threads (`generateTitle`), so titling reuses the\n *     same small tier rather than the agent's primary model.\n *\n * Mirrors the chart-planner wiring in `chart.ts`: a per-config cached\n * `Agent` on the fast tier, invoked via `agent.generate(...)` inside\n * the active `asUser` scope so tokens stay user-scoped.\n *\n * @module\n */\n\nimport { string } from \"@dbx-tools/shared-core\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport { Agent } from \"@mastra/core/agent\";\nimport type { MastraModelConfig } from \"@mastra/core/llm\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport { createTool } from \"@mastra/core/tools\";\nimport { z } from \"zod\";\n\nimport type { MastraPluginConfig } from \"./config\";\nimport { buildModel } from \"./model\";\n\n/** Fast / small chat tier used for both titling and summaries. */\nconst SUMMARY_MODEL_CLASS = model.ModelClass.ChatFast;\n\n/** System prompt for the summarizer agent (and the `summarize` tool). */\nconst SUMMARIZER_INSTRUCTIONS = [\n  \"You are a summarization engine.\",\n  \"Given a block of text, produce a faithful, concise summary of it.\",\n  \"Default to a few sentences; follow any length guidance the caller gives.\",\n  \"Plain prose. No preamble, no headers, no bullet points unless asked.\",\n  \"Never use emojis. Use hyphens (-) only, never em dashes or en dashes.\",\n  \"Never add information, opinions, or details not present in the input.\",\n  \"Output only the summary.\",\n].join(\"\\n\");\n\n/**\n * Instructions Mastra's `generateTitle` hands the small-tier model to\n * name a conversation thread from its opening turn. Kept terse so the\n * model returns a bare title with no decoration.\n */\nexport const TITLE_INSTRUCTIONS = [\n  \"Generate a short, specific title for this conversation, 3 to 6 words.\",\n  \"Capture the user's topic, not the assistant's response.\",\n  \"Plain text only: no surrounding quotes, no trailing punctuation,\",\n  \"no emojis, and no em dashes. Output only the title.\",\n].join(\" \");\n\n/**\n * Resolve the small-tier model for summarization / titling. Reused by\n * both the summarizer agent and Mastra memory's `generateTitle`.\n *\n * Returned as a `requestContext`-taking function (a Mastra\n * `DynamicArgument<MastraModelConfig>`) so each call mints user-scoped\n * tokens via {@link buildModel}, exactly like the primary agents.\n */\nexport function summaryModel(\n  config: MastraPluginConfig,\n): (args: { requestContext: RequestContext }) => Promise<MastraModelConfig> {\n  return ({ requestContext }) =>\n    buildModel(config, requestContext, { modelClass: SUMMARY_MODEL_CLASS });\n}\n\n/**\n * One summarizer `Agent` per plugin config, cached on config-object\n * identity so a hot tool path doesn't pay the constructor cost each\n * call. `WeakMap` lets retired configs (e.g. test reconfigurations)\n * release their agent without manual eviction.\n */\nconst summarizerAgents = new WeakMap<MastraPluginConfig, Agent>();\n\nfunction getSummarizerAgent(config: MastraPluginConfig): Agent {\n  let agent = summarizerAgents.get(config);\n  if (!agent) {\n    agent = new Agent({\n      id: \"summarizer\",\n      name: \"Summarizer\",\n      description: \"Condenses text into a short summary using a fast, small model.\",\n      instructions: SUMMARIZER_INSTRUCTIONS,\n      model: summaryModel(config),\n    });\n    summarizerAgents.set(config, agent);\n  }\n  return agent;\n}\n\n/** Inputs accepted by the `summarize` tool. */\nconst summarizeInput = z.object({\n  text: z.string().min(1).describe(\"The text to summarize.\"),\n  instructions: z\n    .string()\n    .optional()\n    .describe(\n      \"Optional extra guidance for the summary, e.g. 'one sentence' or 'list the action items'.\",\n    ),\n  maxWords: z\n    .number()\n    .int()\n    .positive()\n    .optional()\n    .describe(\"Optional soft cap on the summary length, in words.\"),\n});\n\n/** Options accepted by {@link summarizeText}. */\nexport interface SummarizeOptions {\n  /** Extra guidance for the summary (length, focus, format). */\n  instructions?: string;\n  /** Soft cap on summary length, in words. */\n  maxWords?: number;\n  /** Active request context, so the model resolver mints user-scoped tokens. */\n  requestContext?: RequestContext;\n  /** Abort signal bridged from the calling tool / request. */\n  abortSignal?: AbortSignal;\n}\n\n/**\n * Summarize `text` with the small-tier summarizer agent, returning the\n * trimmed summary string. Throws on model failure (the caller decides\n * how to degrade).\n */\nexport async function summarizeText(\n  config: MastraPluginConfig,\n  text: string,\n  options: SummarizeOptions = {},\n): Promise<string> {\n  const { instructions, maxWords, requestContext, abortSignal } = options;\n  const prompt = string.toDescription({\n    ...(instructions ? { Guidance: instructions } : {}),\n    ...(maxWords !== undefined ? { \"Max length (words)\": String(maxWords) } : {}),\n    Text: text,\n  });\n  const result = await getSummarizerAgent(config).generate(prompt, {\n    ...(requestContext ? { requestContext } : {}),\n    ...(abortSignal ? { abortSignal } : {}),\n  });\n  return result.text.trim();\n}\n\n/**\n * Build the `summarize` tool. Exposed as an ambient system tool (like\n * `render_data`) so every agent can offload condensing long content,\n * notes, transcripts, or bulky tool results to the fast tier instead of\n * spending its primary chat model. The tool reads the live\n * `requestContext` / `abortSignal` off the Mastra execution context so\n * its model call stays user-scoped and cancels with the turn.\n */\nexport function buildSummarizeTool(config: MastraPluginConfig) {\n  return createTool({\n    id: \"summarize\",\n    description:\n      \"Summarize a block of text using a fast, small model. Use it to condense long \" +\n      \"content, notes, transcripts, or tool results into a short summary without \" +\n      \"spending the main chat model.\",\n    inputSchema: summarizeInput,\n    execute: async (input, context) => {\n      const { text, instructions, maxWords } = input as z.infer<typeof summarizeInput>;\n      const ctx = context as\n        { requestContext?: RequestContext; abortSignal?: AbortSignal } | undefined;\n      const summary = await summarizeText(config, text, {\n        ...(instructions ? { instructions } : {}),\n        ...(maxWords !== undefined ? { maxWords } : {}),\n        ...(ctx?.requestContext ? { requestContext: ctx.requestContext } : {}),\n        ...(ctx?.abortSignal ? { abortSignal: ctx.abortSignal } : {}),\n      });\n      return { summary };\n    },\n  });\n}\n"]}

package/lib/src/threads.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Conversation-thread listing exposed as a Mastra custom API route.
+ *
+ * Backed entirely by native Mastra: looks up the active agent by id,
+ * asks its `Memory` instance to `listThreads` filtered to the caller's
+ * resource, and shapes each into the JSON-safe {@link MastraThread}
+ * wire type. A sibling `DELETE` removes a single named thread.
+ *
+ * A sibling `DELETE` removes a single named thread; a `PATCH` renames
+ * one ({@link renameThread}).
+ *
+ * Like {@link historyRoute} this registers through Mastra's
+ * `registerApiRoute` so it shares the `MastraServer` auth-middleware
+ * pipeline (in `./server.ts`), which has already stamped the resource
+ * id (`MASTRA_RESOURCE_ID_KEY`) and the targeted thread id
+ * (`MASTRA_THREAD_ID_KEY`, resolved from the thread-selection header /
+ * cookie) on `RequestContext` by the time a handler runs. Resource
+ * scoping lives here so a caller can only ever see, rename, or delete
+ * its own threads; no cookie or user lookups happen in this module.
+ *
+ * @module
+ */
+import { type MastraThread, type MastraThreadsResponse } from "@dbx-tools/shared-mastra";
+import type { Agent } from "@mastra/core/agent";
+/** Inputs accepted by {@link listThreads}. */
+export interface ListThreadsOptions {
+    agent: Agent;
+    resourceId: string;
+    page?: number;
+    perPage?: number;
+}
+/**
+ * Fetch a page of the resource's conversation threads, newest
+ * (`updatedAt` DESC) first.
+ *
+ * Uses the agent's resolved `Memory` (`getMemory()`) so the per-agent
+ * storage namespace (`mastra_<agentId>` schema) applies automatically.
+ * When the agent has no memory configured the response is a successful
+ * empty page so callers don't have to special-case stateless agents.
+ */
+export declare function listThreads(opts: ListThreadsOptions): Promise<MastraThreadsResponse>;
+/** Inputs accepted by {@link deleteThread}. */
+export interface DeleteThreadOptions {
+    agent: Agent;
+    threadId: string;
+    resourceId: string;
+}
+/**
+ * Delete a single named thread (and every message on it).
+ *
+ * Ownership is enforced: the thread is only removed when it belongs to
+ * the calling resource, so a client can't delete another user's
+ * conversation by guessing its id. A thread that doesn't exist (or
+ * isn't owned by the caller) is a successful no-op (`deleted: false`)
+ * so the UI can fire-and-forget.
+ */
+export declare function deleteThread(opts: DeleteThreadOptions): Promise<{
+    deleted: boolean;
+}>;
+/** Inputs accepted by {@link renameThread}. */
+export interface RenameThreadOptions {
+    agent: Agent;
+    threadId: string;
+    resourceId: string;
+    title: string;
+}
+/**
+ * Rename a single thread, returning the updated wire thread.
+ *
+ * Ownership is enforced the same way {@link deleteThread} enforces it:
+ * the title is only changed when the thread belongs to the calling
+ * resource, so a client can't rename another user's conversation by
+ * guessing its id. Existing thread `metadata` is preserved untouched
+ * (Mastra's `updateThread` replaces the row, so it must be passed back
+ * in). Returns `null` when the thread doesn't exist, isn't owned by the
+ * caller, or the agent has no memory configured, letting the route map
+ * that to a 404.
+ */
+export declare function renameThread(opts: RenameThreadOptions): Promise<MastraThread | null>;
+/** Options accepted by {@link threadsRoute}. */
+export type ThreadsRouteOptions = {
+    path: `${string}:agentId${string}`;
+    agent?: never;
+} | {
+    path: string;
+    agent: string;
+};
+/**
+ * Register the `<path>` Mastra custom API route. Handles three methods
+ * on the same mount:
+ *
+ *   - `GET`: a page of the resource's conversation threads
+ *     ({@link listThreads}).
+ *   - `DELETE`: remove the thread named by the thread-selection header
+ *     / `?threadId=` query ({@link deleteThread}). The id is read from
+ *     `RequestContext` (the auth middleware resolves it the same way it
+ *     does for streaming and history), so the client deletes any of its
+ *     threads by stamping the target id - no separate path param.
+ *   - `PATCH`: rename the thread named by the thread-selection header /
+ *     `?threadId=` query to the `{ title }` in the JSON body
+ *     ({@link renameThread}). Targets a thread the same way `DELETE`
+ *     does; 404s when the thread isn't owned by the caller.
+ *
+ * Follows the `@mastra/ai-sdk` agent-binding convention: pass `agent`
+ * for a fixed-agent mount, or include `:agentId` in the path for
+ * dynamic routing. The plugin registers both `/route/threads` (default
+ * agent) and `/route/threads/:agentId`.
+ */
+export declare function threadsRoute(options: ThreadsRouteOptions): import("@mastra/core/server").ApiRoute[];