@dbx-tools/appkit-mastra 0.3.29 → 0.3.31

package/README.md

@@ -80,7 +80,7 @@ await createApp({
     plugin.mastra({
       agents: { analyst },
       defaultAgent: "analyst",
-      genie: { spaces: { sales: "01ef..." } },
+      genieSpaces: { sales: "01ef..." },
     }),
   ],
 });
@@ -153,6 +153,31 @@ Tool calls dispatch back through the owning AppKit plugin, preserving OBO auth
 and AppKit telemetry behavior. Optional plugins should be guarded with `?.` when
 you spread their tools.
 
+### Tools Flow In, Not Out
+
+The plugin is a tool _consumer_, not an AppKit `ToolProvider`: it deliberately
+implements neither `getAgentTools()` nor `executeAgentTool()`, so its built-in
+tools (`ask_genie`, `get_space_description`, `get_space_serialized`,
+`get_statement`, `prepare_chart`, `render_data`, `summarize`) are reachable only
+from a Mastra agent turn this plugin serves.
+
+That is a property of the tools, not a gap. Each one reads the per-request
+Mastra execution context - the AppKit user stamped on `RequestContext`, the
+`writer` that streams Genie progress events to the chat, the per-call
+`abortSignal` - and refuses to run without it. An AppKit `ToolProvider` call
+carries none of that, so exposing these through one would advertise tools that
+cannot work. Reach for
+[native AppKit Agents](https://developers.databricks.com/docs/appkit/v0) when you
+want your agent tools callable by other AppKit hosts.
+
+Nothing here can be auto-inherited by another host as a side effect: with no
+AppKit `ToolRegistry`, there is no `autoInheritable` surface to opt in or out
+of. Every built-in tool is also read-only (Genie questions, statement reads,
+chart planning, summarization), and the ambient tools stay off the MCP server
+unless `mcp: { tools: true }` names them explicitly. Approval-gated tools you
+register yourself are enforced separately: boot fails if one is registered
+without Mastra storage to persist the suspended run.
+
 ## Memory And Storage
 
 The `memory` and `storage` config fields can be `false`, `true`, or a concrete
@@ -232,19 +257,24 @@ record, resolves the data in the background, and stores a terminal chart or
 error. `chart.fetchChart()` long-polls that cache for route handlers and custom
 clients.
 
+Both take a `userKey`: the chart cache is namespaced by the caller's identity,
+so a chart id lifted from another user's transcript resolves to nothing and the
+embed route answers `404`. Use `config.resolveUserKey()`, which reads the AppKit
+user off the Mastra request context and falls back to the ambient execution
+context.
+
 ```ts
+const userKey = config.resolveUserKey(requestContext);
+
 const { chartId } = await chart.prepareChart({
-  config,
-  request: {
-    title: "Revenue by region",
-    chartType: "bar",
-    instructions: "Compare total revenue by region.",
-    data: rows,
-  },
-  resolveData: async () => rows,
+  config: pluginConfig,
+  userKey,
+  title: "Revenue by region",
+  description: "Compare total revenue by region.",
+  resolveData: async () => ({ rows }),
 });
 
-const resolved = await chart.fetchChart(chartId);
+const resolved = await chart.fetchChart(chartId, { userKey });
 ```
 
 Agents can return `[chart:<id>]` and `[data:<statement_id>]` markers in prose.
@@ -302,7 +332,9 @@ returning `{ agentId, model, displayName }` - the static serving-endpoint an
 agent falls back to when the client pins no model, plus its humanized label.
 `model` / `displayName` are `null` when the agent resolves its model
 dynamically at call time. This lets a model picker label its default option
-without waiting on the `/models` catalogue (so it never flashes a raw id).
+without waiting on the `/models` catalogue (so it never flashes a raw id). A
+`:agentId` that is not registered returns `404` with the registered ids, the
+same as the history and threads routes.
 
 ## Threads, History, And Suggestions
 
@@ -366,6 +398,40 @@ client needs. Use `apiAccess: "full"` only for a trusted first-party console.
 `server.isMastraRequestAllowed()` is exported for tests and custom dispatch
 logic that need the same allowlist.
 
+## Routes
+
+Mounted under the plugin base path, which is `/api/mastra` unless you override
+`name`. Every route below is registered through AppKit's `route()` helper, so it
+appears in the plugin's endpoint map and forwards handler errors to AppKit.
+
+| Method                     | Path                        | Purpose                                                                                     |
+| -------------------------- | --------------------------- | ------------------------------------------------------------------------------------------- |
+| `GET`                      | `/models`                   | Serving-endpoint catalogue for a model picker.                                              |
+| `GET`                      | `/default-model[/:agentId]` | Static default model an agent falls back to, with its humanized label. `404` on unknown id. |
+| `GET`                      | `/suggestions[/:agentId]`   | Starter questions from the configured Genie spaces. Degrades to `[]`.                       |
+| `GET`                      | `/embed/chart/:id`          | Long-polls a `[chart:<id>]` marker's cached spec. `?timeoutMs=` up to 5 minutes.            |
+| `GET`                      | `/embed/data/:id`           | Rows behind a `[data:<statement_id>]` marker. `?limit=` clamped server-side.                |
+| `GET` / `DELETE`           | `/route/history[/:agentId]` | Load or clear the caller's thread messages.                                                 |
+| `GET` / `DELETE` / `PATCH` | `/route/threads[/:agentId]` | List, delete, or rename the caller's conversations.                                         |
+| `POST`                     | `/route/feedback`           | Log a thumbs / comment assessment to the turn's MLflow trace. `404` when feedback is off.   |
+| `POST` / `GET`             | `/mcp`, `/sse`, `/messages` | MCP transports, when `mcp` is enabled.                                                      |
+
+Agent inference itself rides the stock Mastra routes (`/agents/:id/stream`), so
+`@mastra/client-js` and `@dbx-tools/ui-mastra` work without a bespoke protocol.
+
+## Environment Variables
+
+Every value can also be set through plugin config, which wins. These are the
+fallbacks, so a deployment that already follows AppKit's Databricks env naming
+needs no extra wiring.
+
+| Variable                                                            | Effect                                                                    |
+| ------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| `DATABRICKS_SERVING_ENDPOINT_NAME`                                  | Model used when neither the agent nor `defaultModel` names one.           |
+| `DATABRICKS_GENIE_SPACE_ID`                                         | Genie space registered under the `default` alias.                         |
+| `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | Presence of either turns Mastra tracing on when `observability` is unset. |
+| `MLFLOW_EXPERIMENT_ID`, `MLFLOW_EXPERIMENT_NAME`                    | With an OTLP endpoint, turns MLflow feedback on when `feedback` is unset. |
+
 ## Configuration Reference
 
 The plugin config is intentionally centered on the AppKit lifecycle instead of
@@ -377,8 +443,11 @@ requiring callers to assemble a Mastra server by hand.
   name an agent explicitly.
 - `storage` and `memory` accept `true`, `false`, or concrete Mastra Postgres /
   PgVector options. `true` resolves from `lakebase()` when present.
-- `genie.spaces` maps aliases to Genie Space IDs. Those aliases flow into tools,
-  suggestions, and chart/data workflows.
+- `genieSpaces` maps aliases to Genie Space IDs (or to
+  `{ spaceId, hint }` objects). Those aliases flow into tool names,
+  suggestions, and chart/data workflows. An alias present with no space id is a
+  wiring contradiction and fails at construction rather than silently
+  registering no Genie tools.
 - `defaultModel`, `modelOverride`, and `modelFuzzyMatch` control how loose model
   names are resolved through Databricks Model Serving.
 - `feedback` controls whether MLflow feedback routes are exposed. The automatic
@@ -403,8 +472,10 @@ client that talks to these routes.
 - `genie` - Genie prompt, space normalization, Genie toolkits, and suggestions.
 - `chart` / `statement` / `writer` - chart cache, statement row fetches, and
   safe writer events.
-- `history` / `threads` / `pagination` - conversation persistence helpers and
-  route handlers.
+- `history` / `threads` / `pagination` / `validation` - conversation persistence
+  helpers, route handlers, and request-body validation.
+- `defaults` - cache / retry / timeout settings for the plugin's own outbound
+  calls, one constant per call site with its reasoning.
 - `memory` / `storageSchema` - Lakebase-backed Mastra store/vector setup.
 - `workspaces` / `filesystems` - Mastra workspace creation and Databricks
   Workspace file adapters.

package/index.ts

@@ -5,6 +5,7 @@
 export * as agents from "./src/agents";
 export * as chart from "./src/chart";
 export * as config from "./src/config";
+export * as defaults from "./src/defaults";
 export * as filesystems from "./src/filesystems";
 export * as genie from "./src/genie";
 export * as history from "./src/history";
@@ -24,6 +25,7 @@ export * as statement from "./src/statement";
 export * as storageSchema from "./src/storage-schema";
 export * as summarize from "./src/summarize";
 export * as threads from "./src/threads";
+export * as validation from "./src/validation";
 export * as workspaces from "./src/workspaces";
 export * as writer from "./src/writer";
 export type { MastraTools, AppKitToolOptions, ToolkitOptions, MastraPluginToolkitProvider, MastraPlugins, MastraToolsFn, MastraAgentWorkspaceResolver, MastraAgentDefinition, MastraStorageConfigOverride, MastraMemoryConfigOverride, BuiltAgents } from "./src/agents";
@@ -43,4 +45,5 @@ export type { ModelOverrideRequest } from "./src/serving";
 export type { ServingChatMessage } from "./src/serving-sanitize";
 export type { SummarizeOptions } from "./src/summarize";
 export type { ListThreadsOptions, DeleteThreadOptions, RenameThreadOptions, ThreadsRouteOptions } from "./src/threads";
+export type { SchemaIssues } from "./src/validation";
 export type { CreateWorkspaceOptions } from "./src/workspaces";

package/package.json

@@ -27,22 +27,22 @@
     "@opentelemetry/api": "^1.9.1",
     "express": "^5.1.0",
     "pg": "^8.22.0",
-    "zod": "^4.3.6",
-    "@dbx-tools/appkit": "0.3.29",
-    "@dbx-tools/core": "0.3.29",
-    "@dbx-tools/model": "0.3.29",
-    "@dbx-tools/genie": "0.3.29",
-    "@dbx-tools/shared-core": "0.3.29",
-    "@dbx-tools/shared-mastra": "0.3.29",
-    "@dbx-tools/shared-genie": "0.3.29",
-    "@dbx-tools/shared-model": "0.3.29"
+    "zod": "4.3.6",
+    "@dbx-tools/appkit": "0.3.31",
+    "@dbx-tools/genie": "0.3.31",
+    "@dbx-tools/core": "0.3.31",
+    "@dbx-tools/model": "0.3.31",
+    "@dbx-tools/shared-core": "0.3.31",
+    "@dbx-tools/shared-mastra": "0.3.31",
+    "@dbx-tools/shared-genie": "0.3.31",
+    "@dbx-tools/shared-model": "0.3.31"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.29",
+  "version": "0.3.31",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/agents.ts

@@ -15,6 +15,7 @@
  * @module
  */
 
+import { ConfigurationError } from "@databricks/appkit";
 import { plugin } from "@dbx-tools/appkit";
 import { fallback } from "@dbx-tools/model";
 import { log, object, string } from "@dbx-tools/shared-core";
@@ -524,8 +525,9 @@ export async function buildAgents(opts: {
   }
 
   if (!agents[defaultAgentId]) {
-    throw new Error(
-      `mastra: defaultAgent "${defaultAgentId}" not found in registered agents (${ids.join(", ") || "none"})`,
+    throw ConfigurationError.resourceNotFound(
+      `mastra defaultAgent "${defaultAgentId}"`,
+      `Registered agents: ${ids.join(", ") || "none"}.`,
     );
   }
 
@@ -578,7 +580,7 @@ function assertApprovalGatedToolsHaveStorage(
   const detail = gated
     .map(({ agentId, toolIds }) => `${agentId}: ${toolIds.join(", ")}`)
     .join("; ");
-  throw new Error(
+  throw new ConfigurationError(
     "mastra: approval-gated tools require plugin storage (PostgresStore) to persist suspended runs. " +
       `Affected agents/tools: ${detail}. ` +
       "Register lakebase() before mastra() so storage auto-enables, or pass storage: true explicitly.",
@@ -637,7 +639,7 @@ function resolveDefinitions(config: MastraPluginConfig): Record<string, MastraAg
     input.forEach((def, i) => {
       const key = deriveAgentKey(def, i);
       if (out[key]) {
-        throw new Error(
+        throw new ConfigurationError(
           `mastra: duplicate agent id "${key}" derived from name "${def.name ?? ""}"; ` +
             `set unique \`name\`s on each definition`,
         );
@@ -749,7 +751,7 @@ function resolveAgentWorkspace(
  * `genie` is special-cased to swap the generic AppKit toolkit (which
  * runs `executeAgentTool` and only emits a single final `tool-result`
  * chunk per call) for the streaming-aware tools built by
- * {@link buildGenieProvider}. The streaming variant forwards each
+ * {@link buildGenieToolkitProvider}. The streaming variant forwards each
  * Genie wire event (status, SQL, row counts, errors) out through the
  * Mastra `ctx.writer`, so the UI gets `tool-output` chunks in real
  * time instead of staring at a spinner for the full Genie round-trip.
@@ -782,12 +784,11 @@ function buildPluginsMap(
  * Genie agent inherits the same model resolver / fallback
  * ladder the calling agents use.
  *
- * The Genie agent talks to Genie directly via `@dbx-tools/genie`
- * (`genieEventChat`) and the workspace
- * `statementExecution.getStatement` API. AppKit's stock `genie`
- * plugin is honored only for its resource manifest and `spaces`
- * config so existing `app.yaml` configs and `genie({ spaces })`
- * wiring keep working without change.
+ * The Genie tools talk to Genie directly through `@dbx-tools/genie`
+ * (`genieEventChat`) and the workspace `statementExecution.getStatement`
+ * API; AppKit's stock `genie` plugin contributes only its resource
+ * manifest and `spaces` config, so an `app.yaml` resource binding and a
+ * `genie({ spaces })` record have the same meaning here as they do there.
  */
 function resolveProvider(
   config: MastraPluginConfig,

package/src/chart.ts

@@ -27,7 +27,7 @@
  * @module
  */
 
-import { CacheManager } from "@databricks/appkit";
+import { AppKitError, CacheManager, ExecutionError } from "@databricks/appkit";
 import { async, error, hash, log, string, type BrandContext } from "@dbx-tools/shared-core";
 import { wire, type Chart, type ChartResult } from "@dbx-tools/shared-mastra";
 import { model } from "@dbx-tools/shared-model";
@@ -36,7 +36,7 @@ import type { RequestContext } from "@mastra/core/request-context";
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 
-import type { MastraPluginConfig } from "./config";
+import { resolveUserKey, type MastraPluginConfig } from "./config";
 import { buildModel } from "./model";
 
 const logger = log.logger("mastra/chart");
@@ -55,20 +55,15 @@ const CHART_CACHE_TTL_SEC = 60 * 60;
 /** Cache namespace; keeps the chart keyspace tidy. */
 const CHART_CACHE_NAMESPACE = "mastra:chart";
 
-/**
- * `userKey` for `CacheManager.generateKey`. Chart ids are minted
- * via `hash.id()` (v4 UUID) and are unguessable, so a
- * constant user key is fine. The HTTP route can re-scope to the
- * requesting user when policy demands it.
- */
-const CHART_CACHE_USER_KEY = "mastra-chart";
-
 /** Default server-side long-poll budget for {@link fetchChart}. */
 const DEFAULT_FETCH_TIMEOUT_MS = 60_000;
 
 /** Default inter-poll sleep for {@link fetchChart}. */
 const DEFAULT_FETCH_INTERVAL_MS = 250;
 
+/** Stable text stored on a chart entry whose planner run failed. */
+const CHART_FAILED_MESSAGE = "Chart generation failed";
+
 /* ------------------------------- schemas ------------------------------- */
 
 /**
@@ -359,23 +354,27 @@ async function runChartPlanner(
 
 /* ------------------------------ cache helpers ------------------------------ */
 
-/** Build the canonical cache key for a `chartId`. */
-async function chartCacheKey(chartId: string): Promise<string> {
-  return (await CacheManager.getInstance()).generateKey(
-    [CHART_CACHE_NAMESPACE, chartId],
-    CHART_CACHE_USER_KEY,
-  );
+/**
+ * Build the canonical cache key for a `chartId` owned by `userKey`.
+ *
+ * The identity is part of the key, not a filter applied after the read, so a
+ * chart id guessed or copied from another user's transcript resolves to a
+ * different key and simply misses. That miss is what the HTTP route turns into
+ * a 404, which is also the answer that leaks the least.
+ */
+async function chartCacheKey(chartId: string, userKey: string): Promise<string> {
+  return (await CacheManager.getInstance()).generateKey([CHART_CACHE_NAMESPACE, chartId], userKey);
 }
 
 /**
- * Persist a {@link Chart} entry under its `chartId`. Refreshes
- * the TTL on every write. Cache-layer failures are logged and
+ * Persist a {@link Chart} entry under its `chartId`, owned by `userKey`.
+ * Refreshes the TTL on every write. Cache-layer failures are logged and
  * swallowed so background runners never throw into the
  * unhandled-rejection stream.
  */
-async function writeChart(entry: Chart): Promise<void> {
+async function writeChart(entry: Chart, userKey: string): Promise<void> {
   try {
-    const key = await chartCacheKey(entry.chartId);
+    const key = await chartCacheKey(entry.chartId, userKey);
     await CacheManager.getInstanceSync().set(key, entry, {
       ttl: CHART_CACHE_TTL_SEC,
     });
@@ -388,12 +387,13 @@ async function writeChart(entry: Chart): Promise<void> {
 }
 
 /**
- * Look up a chart by id. Returns `undefined` on miss, on
- * expiry, or when the cache layer is unhealthy - never throws.
+ * Look up a chart `userKey` owns. Returns `undefined` on miss, on
+ * expiry, when another identity owns the id, or when the cache layer is
+ * unhealthy - never throws.
  */
-async function readChart(chartId: string): Promise<Chart | undefined> {
+async function readChart(chartId: string, userKey: string): Promise<Chart | undefined> {
   try {
-    const key = await chartCacheKey(chartId);
+    const key = await chartCacheKey(chartId, userKey);
     const v = await CacheManager.getInstanceSync().get<Chart>(key);
     return v ?? undefined;
   } catch (err) {
@@ -411,6 +411,11 @@ async function readChart(chartId: string): Promise<Chart | undefined> {
 export interface PrepareChartOptions {
   /** Plugin config; resolves the planner agent's model. */
   config: MastraPluginConfig;
+  /**
+   * Identity that owns the minted chart. Only a {@link fetchChart} call
+   * carrying the same key resolves it. Use {@link resolveUserKey}.
+   */
+  userKey: string;
   /** Display title forwarded to the planner agent. */
   title?: string;
   /** Optional intent hint forwarded to the planner agent. */
@@ -455,7 +460,7 @@ export interface PrepareChartOptions {
  */
 export async function prepareChart(opts: PrepareChartOptions): Promise<{ chartId: string }> {
   const chartId = hash.id();
-  await writeChart({ chartId });
+  await writeChart({ chartId }, opts.userKey);
   logger.debug("queued", { chartId });
   // Fire-and-forget. Failures land in the cache as `error` entries;
   // never escape into an unhandled rejection.
@@ -468,7 +473,7 @@ async function runPrepareChart(chartId: string, opts: PrepareChartOptions): Prom
   try {
     const data = await opts.resolveData(opts.signal);
     if (data.rows.length === 0) {
-      throw new Error("dataset has no rows; nothing to chart");
+      throw new ExecutionError("Dataset has no rows; nothing to chart");
     }
     const result = await runChartPlanner(
       opts.config,
@@ -482,16 +487,18 @@ async function runPrepareChart(chartId: string, opts: PrepareChartOptions): Prom
         ...(opts.signal ? { abortSignal: opts.signal } : {}),
       },
     );
-    await writeChart({ chartId, result });
+    await writeChart({ chartId, result }, opts.userKey);
     logger.info("done", {
       chartId,
       chartType: result.chartType,
       elapsedMs: Date.now() - startedAt,
     });
   } catch (err) {
-    const errText = error.errorMessage(err);
-    logger.warn("error", { chartId, error: errText });
-    await writeChart({ chartId, error: errText });
+    logger.warn("error", { chartId, error: error.errorMessage(err) });
+    // The entry's `error` is rendered in the chat, so only an AppKitError's
+    // own message travels; anything else could carry upstream provider detail.
+    const errText = err instanceof AppKitError ? err.message : CHART_FAILED_MESSAGE;
+    await writeChart({ chartId, error: errText }, opts.userKey);
   }
 }
 
@@ -499,6 +506,11 @@ async function runPrepareChart(chartId: string, opts: PrepareChartOptions): Prom
 
 /** Inputs to {@link fetchChart}. */
 export interface FetchChartOptions {
+  /**
+   * Identity the chart must belong to. A chart minted under a different key
+   * is indistinguishable from an unknown id. Use {@link resolveUserKey}.
+   */
+  userKey: string;
   /**
    * Server-side polling budget in ms. When the entry stays in
    * the processing state past this window, the helper returns the
@@ -524,8 +536,8 @@ export interface FetchChartOptions {
  *   - the resolved {@link Chart} when it settled, errored, or
  *     stayed in processing past `timeoutMs` (so the client can
  *     re-poll);
- *   - `undefined` when the entry is missing or expired (the
- *     consumer should treat as 404).
+ *   - `undefined` when the entry is missing, expired, or owned by
+ *     another identity (the consumer should treat as 404).
  *
  * `signal` lets the caller cancel ahead of timeout (e.g. the HTTP
  * request closed). Cancellation propagates to the inter-poll sleep
@@ -533,7 +545,7 @@ export interface FetchChartOptions {
  */
 export async function fetchChart(
   chartId: string,
-  options: FetchChartOptions = {},
+  options: FetchChartOptions,
 ): Promise<Chart | undefined> {
   const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
   const intervalMs = options.intervalMs ?? DEFAULT_FETCH_INTERVAL_MS;
@@ -542,7 +554,7 @@ export async function fetchChart(
   let last: Chart | undefined;
   while (true) {
     options.signal?.throwIfAborted();
-    last = await readChart(chartId);
+    last = await readChart(chartId, options.userKey);
     if (!last) return undefined;
     if (last.result !== undefined || last.error !== undefined) return last;
     const remaining = deadline - Date.now();
@@ -564,16 +576,34 @@ interface ChartTheme {
   textStyle: { fontFamily: string; color: string };
 }
 
+/**
+ * AppKit's categorical chart palette (`--chart-cat-1` .. `--chart-cat-8` from
+ * `@databricks/appkit-ui`), as hex. Server-rendered chart specs cannot read the
+ * browser's CSS custom properties, so the values are mirrored here to keep a
+ * generated chart visually consistent with the AppKit-styled UI around it.
+ * Keep in sync with AppKit's stylesheet if it changes.
+ */
+const APPKIT_CHART_PALETTE = [
+  "#2463EB", // blue
+  "#2EB88A", // teal
+  "#AB47BD", // purple
+  "#F69E23", // amber
+  "#DD2C4D", // rose
+  "#1BA3BB", // cyan
+  "#9B61D1", // lavender
+  "#34B262", // emerald
+] as const;
+
 /**
  * Expand two brand hex colors into a legible categorical cycle. Echarts
  * repeats the `color` array across series / categories, so a good default
  * needs several distinct hues, not two. We seed with the brand primary and
- * accent (the identity colors) and follow with a fixed, colorblind-friendly
- * spread so multi-series / many-slice charts stay readable while the first
- * one or two marks still land on-brand.
+ * accent (the identity colors) and follow with AppKit's own categorical chart
+ * palette, so multi-series / many-slice charts stay readable and match the
+ * surrounding AppKit UI while the first one or two marks land on-brand.
  */
 function brandColorCycle(primary: string, accent: string): string[] {
-  const spread = ["#5B8FF9", "#F6BD16", "#E86452", "#6DC8EC", "#945FB9", "#FF9845", "#1E9493"];
+  const spread = APPKIT_CHART_PALETTE;
   const seen = new Set<string>();
   return [primary, accent, ...spread].filter((c) => {
     const key = c.toLowerCase();
@@ -742,6 +772,7 @@ export function buildRenderDataTool(config: MastraPluginConfig) {
       const ctx = ctxRaw as { requestContext?: RequestContext } | undefined;
       return prepareChart({
         config,
+        userKey: resolveUserKey(ctx?.requestContext),
         title,
         ...(description ? { description } : {}),
         resolveData: () => Promise.resolve({ rows: data }),