@dbx-tools/appkit-mastra 0.6.15 → 0.6.27

package/lib/src/chart.js

@@ -27,8 +27,8 @@
  * @module
  */
 import { AppKitError, CacheManager, ExecutionError } from "@databricks/appkit";
-import { async, error, hash, log, string } from "@dbx-tools/shared-core";
-import { wire } from "@dbx-tools/shared-mastra";
+import { async, error, hash, json, log, string } from "@dbx-tools/shared-core";
+import { marker, wire } from "@dbx-tools/shared-mastra";
 import { model } from "@dbx-tools/shared-model";
 import { Agent } from "@mastra/core/agent";
 import { createTool } from "@mastra/core/tools";
@@ -58,22 +58,23 @@ const CHART_FAILED_MESSAGE = "Chart generation failed";
  * One series data point. Wide variant set so the planner agent can
  * faithfully pass through whatever the SQL row set contained
  * (numbers, stringified numbers, nulls for missing measurements,
- * `[x, y]` tuples for scatter, `{name, value}` slices for pie)
- * without the structured-output guard rejecting the whole plan.
+ * `[x, y]` tuples for scatter, `[x, y, value]` triples for heatmap,
+ * `{name, value}` slices for pie / funnel / treemap) without the
+ * structured-output guard rejecting the whole plan.
  *
  * Three layers of tolerance:
  *
  *   1. {@link z.preprocess} normalizes wire shapes BEFORE union
  *      dispatch: stringified numbers parse to numbers, finite
- *      checks reject `NaN` / `Infinity`, 2-element arrays coerce
+ *      checks reject `NaN` / `Infinity`, 2-/3-element arrays coerce
  *      tuple components, and `{value}` objects with missing /
  *      stringified `value` get coerced or rejected uniformly.
  *      Anything not handleable becomes `null`.
  *   2. The union accepts `null` as a first-class variant. Echarts
  *      renders null as a gap on bar / line / area (which is the
- *      right visual signal for "missing reading"). Scatter and
- *      pie filter nulls in {@link planToEchartsOption} because
- *      Echarts crashes on null tuples / slices.
+ *      right visual signal for "missing reading"). Scatter, heatmap,
+ *      and slice charts filter nulls in {@link planToEchartsOption}
+ *      because Echarts crashes on null tuples / slices.
  *   3. {@link z.union#catch} backstops the whole thing: if
  *      preprocess somehow produces a shape that still doesn't
  *      match any variant, the bad item becomes `null` instead of
@@ -90,10 +91,11 @@ const chartDataPointSchema = z
         const n = Number(v);
         return Number.isFinite(n) ? n : null;
     }
-    if (Array.isArray(v) && v.length === 2) {
-        const x = typeof v[0] === "number" ? v[0] : Number(v[0]);
-        const y = typeof v[1] === "number" ? v[1] : Number(v[1]);
-        return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null;
+    // Scatter `[x, y]` or heatmap `[xIndex, yIndex, value]`. Coerce
+    // stringified components; reject if any component is non-finite.
+    if (Array.isArray(v) && (v.length === 2 || v.length === 3)) {
+        const nums = v.map((c) => (typeof c === "number" ? c : Number(c)));
+        return nums.every((n) => Number.isFinite(n)) ? nums : null;
     }
     if (typeof v === "object" && v !== null && "value" in v) {
         const obj = v;
@@ -111,18 +113,21 @@ const chartDataPointSchema = z
 }, z.union([
     z.number(),
     z.null(),
-    // `[x, y]` scatter point. Modelled as a length-constrained
-    // homogeneous array rather than `z.tuple`: Zod emits a tuple as
-    // JSON Schema 2020-12 `prefixItems`, and Databricks' Gemini
-    // endpoints reject a `response_json_schema` containing it
-    // ("must be a boolean or an object", since `items` is absent).
-    // `z.array(z.number()).length(2)` emits `items` + `minItems` /
-    // `maxItems`, which every provider understands, and validates
-    // the same two-number shape.
-    z.array(z.number()).length(2),
+    // `[x, y]` scatter or `[x, y, value]` heatmap cell. Modelled as a
+    // length-constrained homogeneous array rather than `z.tuple`:
+    // Zod emits a tuple as JSON Schema 2020-12 `prefixItems`, and
+    // Databricks' Gemini endpoints reject a `response_json_schema`
+    // containing it ("must be a boolean or an object", since
+    // `items` is absent). `minItems` / `maxItems` + `items` is what
+    // every provider understands.
+    z.array(z.number()).min(2).max(3),
     z.object({ name: z.string(), value: z.number() }),
 ]))
     .catch(null);
+/** Per-series mark type used by `combo` charts (bar + line overlay). */
+const seriesMarkTypeSchema = z
+    .union([z.literal("bar"), z.literal("line"), z.literal("area")])
+    .describe("Mark type for this series. Required for `combo` (mix bar and line/area); ignored for other chart types.");
 /**
  * Compact, model-friendly representation of an Echarts spec. The
  * planner agent emits this; {@link planToEchartsOption} expands it
@@ -146,41 +151,79 @@ export const chartPlanSchema = z.object({
         .string()
         .optional()
         .describe(string.toDescription(`
-        Axis label below the chart. Used for bar / line / area / scatter;
-        ignored for pie.
+        Axis label for the primary (usually bottom / value) axis.
+        Used for bar / horizontalBar / line / area / combo / waterfall
+        / scatter / heatmap; ignored for pie / funnel / treemap / radar.
       `)),
     yAxisLabel: z
         .string()
         .optional()
         .describe(string.toDescription(`
-        Axis label to the left of the chart. Used for bar / line / area /
-        scatter; ignored for pie.
+        Axis label for the secondary (usually left) axis. Used for
+        bar / horizontalBar / line / area / combo / waterfall /
+        scatter / heatmap; ignored for pie / funnel / treemap / radar.
       `)),
     categories: z
         .array(z.string())
         .optional()
         .describe(string.toDescription(`
-        X-axis category labels for \`bar\` / \`line\` / \`area\` charts
-        (one per data point in each series). Omit for \`scatter\` (uses
-        [x, y] tuples) and \`pie\` (each slice carries its own \`name\`).
+        Primary category labels. For \`bar\` / \`horizontalBar\` /
+        \`line\` / \`area\` / \`combo\` / \`waterfall\`: one label per
+        data point. For \`heatmap\`: x-axis categories. For \`radar\`:
+        indicator names. Omit for \`scatter\` (\`[x, y]\` tuples) and
+        slice charts (\`pie\` / \`funnel\` / \`treemap\`, each slice
+        carries its own \`name\`).
+      `)),
+    yCategories: z
+        .array(z.string())
+        .optional()
+        .describe(string.toDescription(`
+        Y-axis (row) labels for \`heatmap\`. Optional - when omitted the
+        row labels come from the series names, which is the preferred
+        way to build a heatmap. Omit for every other chart type.
       `)),
     series: z
         .array(z.object({
         name: z.string().describe(string.toDescription(`
             Legend name for this series.
           `)),
+        type: seriesMarkTypeSchema.optional(),
+        yAxisIndex: z
+            .union([z.literal(0), z.literal(1)])
+            .optional()
+            .describe("Which y-axis to bind (0 = left, 1 = right). Use on `combo` when series have different units or scales."),
         data: z.array(chartDataPointSchema).describe(string.toDescription(`
-            Data points. For \`bar\` / \`line\` / \`area\`, an array of
-            numbers aligned to \`categories\`. For \`scatter\`, an array
-            of \`[x, y]\` numeric tuples. For \`pie\`, an array of
-            \`{name, value}\` objects.
+            Data points. For category charts (\`bar\` / \`horizontalBar\`
+            / \`line\` / \`area\` / \`combo\` / \`waterfall\` / \`radar\`),
+            an array of numbers aligned to \`categories\`; for
+            \`waterfall\` those numbers are signed deltas (one series
+            only - never a cumulative base series). For \`heatmap\`,
+            one series per matrix row, holding that row's numbers
+            aligned to \`categories\`. For \`scatter\`, an array of
+            \`[x, y]\` numeric tuples. For \`pie\` / \`funnel\` /
+            \`treemap\`, an array of \`{name, value}\` objects.
           `)),
     }))
-        .min(1)
+        .default([])
         .describe(string.toDescription(`
-        One or more series to plot. Pie charts use exactly one series;
-        bar/line/area can stack multiple series sharing the same
-        \`categories\` axis.
+        One or more series to plot. Required for every chart type
+        except \`custom\`, which carries its series inside \`option\`.
+        Slice charts (\`pie\` / \`funnel\` / \`treemap\`) and
+        \`waterfall\` / \`heatmap\` use exactly one series; \`bar\` /
+        \`line\` / \`area\` / \`combo\` / \`radar\` / \`scatter\` can
+        carry multiple series.
+      `)),
+    option: z
+        .string()
+        .optional()
+        .describe(string.toDescription(`
+        Required for \`custom\`, ignored for every other chart type. A
+        COMPLETE Echarts option, as a JSON object encoded in a string:
+        \`series\` (each with its own \`type\` and that series' own data
+        shape) plus whatever else the chart needs - a coordinate system,
+        \`visualMap\`, axes. Plain JSON values only, never a JavaScript
+        function. A centered title is filled in when the object omits
+        one.
       `)),
 });
 /**
@@ -217,6 +260,18 @@ export const chartPlannerRequestSchema = z.object({
         aggregate larger datasets first.
       `)),
 });
+/**
+ * Agent-facing result of either chart-producing tool.
+ *
+ * `marker` is deliberately redundant with `chartId`: the host still keys the
+ * cache by id, while the model gets the exact opaque token to copy into prose
+ * and has no reason to invent or retype a UUID.
+ */
+export const chartToolOutputSchema = wire.ChartSchema.pick({ chartId: true }).extend({
+    marker: z
+        .string()
+        .describe("Exact embed marker. Copy this complete value verbatim onto its own line; never construct a marker from chartId."),
+});
 /* --------------------------- planner instructions --------------------------- */
 /**
  * Format {@link wire.ChartTypeSchema}'s variants as a single
@@ -245,18 +300,58 @@ const CHART_PLANNER_INSTRUCTIONS = string.toDescription(`
 
   When in doubt between bar and line, prefer bar for unordered
   categories and line for ordered ones (dates, time buckets, ranks).
-  Never pick pie for more than 7 slices.
+  Prefer \`horizontalBar\` when category labels are long. Prefer
+  \`combo\` when one measure is a count/volume and another is a
+  rate/trend. Prefer \`waterfall\` for bridges of signed deltas.
+  Prefer \`scatter\` when correlating two numeric fields (no
+  category axis). Prefer \`heatmap\` for a category x category
+  matrix. Prefer \`radar\` for scoring the same entities across a
+  fixed set of dimensions. Never pick pie for more than 7 slices
+  (use \`treemap\` instead). Prefer \`funnel\` for ordered conversion
+  stages.
+
+  For bar / horizontalBar / line / area / combo / waterfall: pick one
+  column as the category axis (usually the only string-valued column)
+  and one or more numeric columns as series. Sort categories by the
+  primary series value descending unless the data is naturally ordered
+  (dates, ranks, funnel stages, waterfall steps). For \`combo\`, set
+  each series' \`type\` to \`bar\`, \`line\`, or \`area\`, and use
+  \`yAxisIndex: 1\` when a series needs a second scale.
+
+  For waterfall, emit exactly ONE series holding the signed step values
+  (deltas), one per category, in order - positive for a rise, negative
+  for a drop. Do NOT add a cumulative / running-total / base series and
+  do NOT convert the deltas into running totals yourself; the running
+  total is computed for you, and a hand-built base series renders as a
+  plain bar chart instead of a bridge.
+
+  For pie / funnel / treemap: pick the category column for slice names
+  and one numeric column for slice values. Emit a single series of
+  \`{name, value}\` objects.
 
-  For bar / line / area: pick one column as the category axis (usually
-  the only string-valued column) and one or more numeric columns as
-  series. Sort categories by the primary series value descending unless
-  the data is naturally ordered (dates, ranks).
+  For scatter: pick two numeric columns and emit \`[x, y]\` tuples in
+  one or more series (one series per group if a grouping column exists).
 
-  For pie: pick the category column for slice names and one numeric
-  column for slice values. Emit a single series.
+  For heatmap: pick two category columns and one numeric measure. Put
+  the x-axis categories in \`categories\`, then emit ONE SERIES PER ROW
+  of the matrix - the series \`name\` is the row label and \`data\` is
+  the row's numbers, one per entry in \`categories\`, in the same order.
+  Do not compute cell indices.
 
-  For scatter: pick two numeric columns and emit \`[x, y]\` tuples in a
-  single series.
+  For radar: \`categories\` are the indicator names; each series is an
+  array of numbers (one value per indicator).
+
+  For anything the types above cannot express - a sankey, boxplot,
+  candlestick, sunburst, gauge, network graph, calendar, parallel-
+  coordinates plot, or any other Echarts series - use \`custom\` and
+  hand-write the whole Echarts option into \`option\` as a JSON string.
+  Include every part that chart needs: the series with their own
+  \`type\` and data shape, plus any coordinate system, \`visualMap\`,
+  or axes. Leave \`series\`, \`categories\`, and the axis labels out;
+  they are ignored for \`custom\`. Prefer a listed type whenever one
+  genuinely fits - \`custom\` gives up the shared tooltip, legend, and
+  grid defaults, so it is the answer for an unsupported chart shape,
+  not a way to restyle a supported one.
 
   Keep series names human-readable (use the column name; title case it
   lightly if needed). Keep titles concise; do not repeat the user's
@@ -380,7 +475,7 @@ export async function prepareChart(opts) {
     // Fire-and-forget. Failures land in the cache as `error` entries;
     // never escape into an unhandled rejection.
     void runPrepareChart(chartId, opts);
-    return { chartId };
+    return { chartId, marker: marker.formatMarker("chart", chartId) };
 }
 async function runPrepareChart(chartId, opts) {
     const startedAt = Date.now();
@@ -484,16 +579,146 @@ function brandColorCycle(primary, accent) {
 }
 /**
  * Derive an Echarts {@link ChartTheme} from a brand context: the primary +
- * accent colors seed the series cycle, the sans stack becomes the base font,
- * and the brand foreground becomes the base text color.
+ * accent colors seed the series cycle and the sans stack becomes the base
+ * font. Text colors are the renderer's job - see {@link ChartTheme}.
  */
 function brandChartTheme(brand) {
     return {
         color: brandColorCycle(brand.colors.primary, brand.colors.accent),
-        textStyle: { fontFamily: brand.typography.sans, color: brand.colors.foreground },
+        textStyle: { fontFamily: brand.typography.sans },
     };
 }
-/* ----------------------------- echarts expansion ----------------------------- */
+/** Keep only `{name, value}` slices; drop nulls / bare numbers / tuples. */
+function namedSlices(data) {
+    return data.filter((d) => d !== null && typeof d === "object" && !Array.isArray(d));
+}
+/** Keep only finite numbers (category / radar / waterfall series). */
+function numericPoints(data) {
+    return data.filter((d) => typeof d === "number" && Number.isFinite(d));
+}
+/** Keep only `[x, y]` scatter tuples. */
+function scatterPoints(data) {
+    return data.filter((d) => Array.isArray(d) && d.length === 2);
+}
+/** Keep only `[xIndex, yIndex, value]` heatmap cells. */
+function heatmapCells(data) {
+    return data.filter((d) => Array.isArray(d) && d.length === 3);
+}
+/**
+ * Resolve a heatmap's cells and row labels from either shape the
+ * planner may produce.
+ *
+ * The documented shape is ONE series of `[xIndex, yIndex, value]`
+ * triples, but index arithmetic is exactly the kind of bookkeeping a
+ * fast model gets wrong, and the failure is silent (every cell is
+ * dropped and the grid renders empty). So the row-per-series shape it
+ * already produces reliably for bar charts - one series per matrix
+ * row, numbers aligned to `categories` - is accepted too and turned
+ * into triples here.
+ *
+ * Row order reads top-to-bottom: Echarts' category y-axis counts index
+ * 0 from the BOTTOM, so a row-derived matrix reverses both the axis
+ * labels and the row indices, putting the first series at the top the
+ * way the model listed it.
+ */
+function heatmapMatrix(plan) {
+    const triples = heatmapCells(plan.series[0]?.data ?? []);
+    if (triples.length > 0) {
+        return { cells: triples, yCategories: plan.yCategories ?? [] };
+    }
+    const rows = plan.series.map((s) => ({ name: s.name, values: numericPoints(s.data) }));
+    const labels = plan.yCategories ?? rows.map((r) => r.name);
+    const lastRow = rows.length - 1;
+    return {
+        cells: rows.flatMap((row, rowIndex) => row.values.map((value, columnIndex) => [columnIndex, lastRow - rowIndex, value])),
+        yCategories: [...labels].reverse(),
+    };
+}
+/** Sequential light-to-brand ramp for heatmap intensity. */
+const HEATMAP_RAMP = ["#EAF1FE", "#9CBDF7", "#4C86EE", "#2463EB", "#14387F"];
+/** Above this many cells, printed values overlap and are suppressed. */
+const HEATMAP_LABEL_MAX_CELLS = 60;
+/** Rising step fill (emerald) and falling step fill (rose). */
+const WATERFALL_INCREASE_COLOR = "#2EB88A";
+const WATERFALL_DECREASE_COLOR = "#DD2C4D";
+/** Series names the waterfall expansion emits. */
+const WATERFALL_HELPER_NAME = "Running total";
+const WATERFALL_INCREASE_NAME = "Increase";
+const WATERFALL_DECREASE_NAME = "Decrease";
+/**
+ * A model asked for a bridge often builds the running total itself and
+ * hands back a cumulative-base series alongside the deltas - which
+ * renders as two plain bar series, not a waterfall (the base bars are
+ * the tall ones). The base is recognizable by name, so it is dropped
+ * here and the running total recomputed from the deltas.
+ */
+const WATERFALL_BASE_NAME = /\b(base|cumulative|running|helper|total|start(ing)?)\b/i;
+/**
+ * Pick the signed-delta series out of a waterfall plan, ignoring any
+ * cumulative-base series the planner built by hand
+ * ({@link WATERFALL_BASE_NAME}). Falls back to the first series when
+ * every name looks like a base, since dropping them all would leave
+ * nothing to plot.
+ */
+function waterfallDeltaSeries(series) {
+    return series.find((s) => !WATERFALL_BASE_NAME.test(s.name)) ?? series[0];
+}
+/**
+ * Build the stacked transparent-base + increase + decrease series that
+ * Echarts uses for a waterfall (it has no native waterfall type).
+ * Values are signed deltas; the transparent helper carries the running
+ * total so each visible bar starts where the previous one ended.
+ *
+ * The helper is `silent`, so with an item-triggered tooltip it is
+ * invisible to both the eye and the pointer - the alternative, an axis
+ * tooltip that hides the helper row, needs a function formatter, and
+ * this spec has to survive JSON serialization to the browser.
+ */
+function waterfallSeries(values) {
+    const helpers = [];
+    const increases = [];
+    const decreases = [];
+    let cumulative = 0;
+    for (const value of values) {
+        if (value >= 0) {
+            helpers.push(cumulative);
+            increases.push(value);
+            decreases.push("-");
+        }
+        else {
+            helpers.push(cumulative + value);
+            increases.push("-");
+            decreases.push(-value);
+        }
+        cumulative += value;
+    }
+    const transparent = { borderColor: "transparent", color: "transparent" };
+    return [
+        {
+            name: WATERFALL_HELPER_NAME,
+            type: "bar",
+            stack: "total",
+            silent: true,
+            itemStyle: transparent,
+            emphasis: { itemStyle: transparent },
+            data: helpers,
+        },
+        {
+            name: WATERFALL_INCREASE_NAME,
+            type: "bar",
+            stack: "total",
+            itemStyle: { color: WATERFALL_INCREASE_COLOR },
+            data: increases,
+        },
+        {
+            name: WATERFALL_DECREASE_NAME,
+            type: "bar",
+            stack: "total",
+            itemStyle: { color: WATERFALL_DECREASE_COLOR },
+            data: decreases,
+        },
+    ];
+}
 /**
  * Expand a {@link ChartPlan} into a full Echarts `EChartsOption`
  * JSON. Centralized here so the planner agent only fills in the
@@ -505,26 +730,44 @@ function brandChartTheme(brand) {
  * color cycle and base text style (see {@link brandChartTheme}); otherwise
  * Echarts' defaults apply.
  */
-function planToEchartsOption(plan, fallbackTitle, brand) {
+export function planToEchartsOption(plan, fallbackTitle, brand) {
     const baseTitle = plan.title ?? fallbackTitle;
     const grid = { left: 48, right: 24, top: 56, bottom: 48, containLabel: true };
     const theme = brand ? brandChartTheme(brand) : undefined;
     const themed = (option) => theme ? { ...theme, ...option } : option;
-    if (plan.chartType === "pie") {
-        // Echarts crashes on null pie slices - filter them out.
-        // `{name, value}` slices are the only valid pie data shape,
-        // so drop bare numbers / tuples / nulls the planner may
-        // have leaked into a pie series.
-        const slices = (plan.series[0]?.data ?? []).filter((d) => d !== null && typeof d === "object" && !Array.isArray(d));
+    const title = { text: baseTitle, left: "center" };
+    const legend = { bottom: 0 };
+    if (plan.chartType === "custom") {
+        // The option arrives as a JSON STRING, not a nested object: this plan is
+        // the planner's provider-enforced structured output, and a free-form
+        // object becomes an unconstrained `additionalProperties` schema that
+        // strict OpenAI and Gemini endpoints reject - which would break EVERY
+        // chart, not just this one (same class of hazard as the `prefixItems`
+        // note on `chartDataPointSchema`). A malformed string costs one chart.
+        // Nothing here is eval'd; a string-valued Echarts formatter is a
+        // template, not code.
+        const option = json.parseRecord(plan.option);
+        if (!option) {
+            throw new Error('chartType "custom" needs an `option` holding a JSON object');
+        }
+        // Title is the one default worth filling: every other branch guarantees
+        // one and the renderer reserves grid space for it. A title the model set
+        // wins, as does every other field it declared.
+        return themed({ title, ...option });
+    }
+    if (plan.chartType === "pie" || plan.chartType === "funnel" || plan.chartType === "treemap") {
+        const slices = namedSlices(plan.series[0]?.data ?? []);
+        const seriesType = plan.chartType;
         return themed({
-            title: { text: baseTitle, left: "center" },
+            title,
             tooltip: { trigger: "item" },
-            legend: { bottom: 0 },
+            legend: seriesType === "treemap" ? undefined : legend,
             series: [
                 {
                     name: plan.series[0]?.name ?? baseTitle,
-                    type: "pie",
-                    radius: ["35%", "65%"],
+                    type: seriesType,
+                    ...(seriesType === "pie" ? { radius: ["35%", "65%"] } : {}),
+                    ...(seriesType === "funnel" ? { sort: "descending" } : {}),
                     data: slices,
                 },
             ],
@@ -535,26 +778,166 @@ function planToEchartsOption(plan, fallbackTitle, brand) {
         // `[x, y]` tuples. Bare numbers / objects / nulls from a
         // mismatched plan get dropped silently.
         return themed({
-            title: { text: baseTitle, left: "center" },
+            title,
             tooltip: { trigger: "item" },
-            legend: { bottom: 0 },
+            legend,
             grid,
             xAxis: { type: "value", name: plan.xAxisLabel },
             yAxis: { type: "value", name: plan.yAxisLabel },
             series: plan.series.map((s) => ({
                 name: s.name,
                 type: "scatter",
-                data: s.data.filter((d) => Array.isArray(d) && d.length === 2),
+                data: scatterPoints(s.data),
+            })),
+        });
+    }
+    if (plan.chartType === "heatmap") {
+        const { cells, yCategories } = heatmapMatrix(plan);
+        const values = cells.map((c) => c[2]);
+        const min = values.length > 0 ? Math.min(...values) : 0;
+        const max = values.length > 0 ? Math.max(...values) : 1;
+        return themed({
+            title,
+            tooltip: { position: "top" },
+            // The visualMap ramp sits below the plot, so the grid gives up
+            // more bottom room than an axis-only chart needs.
+            grid: { ...grid, bottom: 72 },
+            xAxis: {
+                type: "category",
+                data: plan.categories ?? [],
+                name: plan.xAxisLabel,
+                splitArea: { show: true },
+            },
+            yAxis: {
+                type: "category",
+                data: yCategories,
+                name: plan.yAxisLabel,
+                splitArea: { show: true },
+            },
+            visualMap: {
+                // Echarts hides every cell when min === max (a uniform matrix),
+                // so a degenerate range is widened by one.
+                min,
+                max: max > min ? max : min + 1,
+                calculable: true,
+                orient: "horizontal",
+                left: "center",
+                bottom: 8,
+                inRange: { color: HEATMAP_RAMP },
+            },
+            series: [
+                {
+                    name: plan.series[0]?.name ?? baseTitle,
+                    type: "heatmap",
+                    data: cells,
+                    // Printed cell values are unreadable once the grid is dense.
+                    label: { show: cells.length <= HEATMAP_LABEL_MAX_CELLS },
+                    emphasis: { itemStyle: { shadowBlur: 10, shadowColor: "rgba(0, 0, 0, 0.3)" } },
+                },
+            ],
+        });
+    }
+    if (plan.chartType === "radar") {
+        const indicators = (plan.categories ?? []).map((name, index) => {
+            const peak = Math.max(0, ...plan.series.map((s) => {
+                const nums = numericPoints(s.data);
+                return nums[index] ?? 0;
+            }));
+            return { name, max: peak > 0 ? peak : 1 };
+        });
+        return themed({
+            title,
+            tooltip: { trigger: "item" },
+            legend,
+            radar: { indicator: indicators },
+            series: [
+                {
+                    type: "radar",
+                    data: plan.series.map((s) => ({
+                        name: s.name,
+                        value: numericPoints(s.data),
+                    })),
+                },
+            ],
+        });
+    }
+    if (plan.chartType === "waterfall") {
+        const values = numericPoints(waterfallDeltaSeries(plan.series)?.data ?? []);
+        return themed({
+            title,
+            // Item-triggered so the transparent `silent` offset bars never
+            // surface in a tooltip (see `waterfallSeries`).
+            tooltip: { trigger: "item" },
+            // Only the two visible steps belong in the legend.
+            legend: { ...legend, data: [WATERFALL_INCREASE_NAME, WATERFALL_DECREASE_NAME] },
+            grid,
+            xAxis: {
+                type: "category",
+                data: plan.categories ?? [],
+                name: plan.xAxisLabel,
+            },
+            yAxis: { type: "value", name: plan.yAxisLabel },
+            series: waterfallSeries(values),
+        });
+    }
+    if (plan.chartType === "horizontalBar") {
+        return themed({
+            title,
+            tooltip: { trigger: "axis", axisPointer: { type: "shadow" } },
+            legend,
+            grid,
+            xAxis: { type: "value", name: plan.xAxisLabel },
+            yAxis: {
+                type: "category",
+                data: plan.categories ?? [],
+                name: plan.yAxisLabel,
+            },
+            series: plan.series.map((s) => ({
+                name: s.name,
+                type: "bar",
+                data: s.data,
             })),
         });
     }
+    if (plan.chartType === "combo") {
+        const usesRightAxis = plan.series.some((s) => s.yAxisIndex === 1);
+        return themed({
+            title,
+            tooltip: { trigger: "axis" },
+            legend,
+            grid,
+            xAxis: {
+                type: "category",
+                data: plan.categories ?? [],
+                name: plan.xAxisLabel,
+            },
+            yAxis: usesRightAxis
+                ? [
+                    { type: "value", name: plan.yAxisLabel },
+                    { type: "value", name: undefined },
+                ]
+                : { type: "value", name: plan.yAxisLabel },
+            series: plan.series.map((s) => {
+                const mark = s.type ?? "bar";
+                const seriesType = mark === "area" ? "line" : mark;
+                return {
+                    name: s.name,
+                    type: seriesType,
+                    data: s.data,
+                    yAxisIndex: s.yAxisIndex ?? 0,
+                    smooth: seriesType === "line",
+                    ...(mark === "area" ? { areaStyle: {} } : {}),
+                };
+            }),
+        });
+    }
     // bar / line / area share the same axis layout.
     const isArea = plan.chartType === "area";
     const seriesType = plan.chartType === "bar" ? "bar" : "line";
     return themed({
-        title: { text: baseTitle, left: "center" },
+        title,
         tooltip: { trigger: "axis" },
-        legend: { bottom: 0 },
+        legend,
         grid,
         xAxis: {
             type: "category",
@@ -581,9 +964,8 @@ function planToEchartsOption(plan, fallbackTitle, brand) {
  * Thin wrapper over {@link prepareChart} for callers that already
  * have a dataset in hand. Mints a `chartId` synchronously, caches
  * an empty placeholder, and kicks off the chart-planner in the
- * background. Returns just the `chartId`; the host UI resolves
- * `[chart:<chartId>]` markers by hitting the plugin's
- * `/embed/chart/:id` route.
+ * background. Returns the `chartId` plus its ready-to-copy `marker`; the host
+ * UI resolves that marker through the plugin's `/embed/chart/:id` route.
  *
  * For Genie statement results, prefer the Genie agent's
  * `prepare_chart` tool, which accepts a `statement_id` and
@@ -597,14 +979,15 @@ export function buildRenderDataTool(config) {
         Submit a tabular dataset for inline rendering as a chart in
         the user's view. Pass a title, the raw rows (array of objects
         keyed by column name), and an optional one-line description
-        of the insight to highlight. Returns a short \`chartId\`;
-        the chart renders inline at the position you embed the
-        matching \`[chart:<chartId>]\` marker.
+        of the insight to highlight. Returns \`chartId\` plus the
+        complete \`marker\`; copy the returned marker VERBATIM onto
+        its own line where the chart should render. Never construct,
+        alter, or invent a chart marker yourself.
       `,
             `
-        Placement contract: embed \`[chart:<chartId>]\` on its own
-        line (blank lines above and below) wherever you want the
-        chart to appear in your reply. The chart resolves
+        Placement contract: embed the returned \`marker\` on its own
+        line (blank lines above and below) wherever you want the chart
+        to appear in your reply. The chart resolves
         asynchronously - the tool returns the id immediately and the
         host UI fetches the chart from the cache once the planner
         lands. You can call \`render_data\` multiple times in the
@@ -620,7 +1003,7 @@ export function buildRenderDataTool(config) {
       `,
         ]),
         inputSchema: chartPlannerRequestSchema,
-        outputSchema: wire.ChartSchema.pick({ chartId: true }),
+        outputSchema: chartToolOutputSchema,
         execute: async (input, ctxRaw) => {
             const { title, description, data } = input;
             const ctx = ctxRaw;
@@ -635,4 +1018,4 @@ export function buildRenderDataTool(config) {
         },
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.js","sourceRoot":"","sources":["../../src/chart.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Chart planner + chart cache.\n *\n * Self-contained chart subsystem with two layers:\n *\n *   1. Inner planner agent (private). Pure dataset-in /\n *      `EChartsOption`-out brain. Driven by {@link prepareChart};\n *      callers never instantiate it directly.\n *   2. {@link prepareChart}: orchestration on top of the planner.\n *      Mints a `chartId`, caches an empty `{ chartId }` record\n *      synchronously, then resolves the dataset and runs the\n *      planner in the background. The terminal entry settles with\n *      either `result` (success) or `error` (failure). Both\n *      undefined means the entry is still processing.\n *\n * The cache surface ({@link fetchChart}) is the only state the\n * HTTP route and the chart-producing tools share. `prepareChart`\n * is dataset-agnostic - callers supply a `resolveData` callback\n * that fetches the rows however they like (Genie statement, inline\n * dataset, custom API). The module has no knowledge of Genie or\n * statement ids; those concerns live in the tools that wrap it.\n *\n * Wire-format schemas live in `@dbx-tools/shared-mastra` so\n * the demo client and any other UI consumer share the exact same\n * shape this module reads and writes.\n *\n * @module\n */\n\nimport { AppKitError, CacheManager, ExecutionError } from \"@databricks/appkit\";\nimport { async, error, hash, log, string, type BrandContext } from \"@dbx-tools/shared-core\";\nimport { wire, type Chart, type ChartResult } from \"@dbx-tools/shared-mastra\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport { Agent } from \"@mastra/core/agent\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport { createTool } from \"@mastra/core/tools\";\nimport { z } from \"zod\";\n\nimport { resolveUserKey, type MastraPluginConfig } from \"./config.ts\";\nimport { buildModel } from \"./model.ts\";\n\nconst logger = log.logger(\"mastra/chart\");\n\n/* ------------------------------ constants ------------------------------ */\n\n/**\n * TTL for cached chart entries. One hour balances \"long enough for\n * the host UI to fetch the chart well after the model finished\n * talking\" against \"short enough that abandoned chart ids don't\n * pin storage\". Matches the typical Databricks OBO token lifetime\n * so any data re-resolution stays inside the original auth window.\n */\nconst CHART_CACHE_TTL_SEC = 60 * 60;\n\n/** Cache namespace; keeps the chart keyspace tidy. */\nconst CHART_CACHE_NAMESPACE = \"mastra:chart\";\n\n/** Default server-side long-poll budget for {@link fetchChart}. */\nconst DEFAULT_FETCH_TIMEOUT_MS = 60_000;\n\n/** Default inter-poll sleep for {@link fetchChart}. */\nconst DEFAULT_FETCH_INTERVAL_MS = 250;\n\n/** Stable text stored on a chart entry whose planner run failed. */\nconst CHART_FAILED_MESSAGE = \"Chart generation failed\";\n\n/* ------------------------------- schemas ------------------------------- */\n\n/**\n * One series data point. Wide variant set so the planner agent can\n * faithfully pass through whatever the SQL row set contained\n * (numbers, stringified numbers, nulls for missing measurements,\n * `[x, y]` tuples for scatter, `{name, value}` slices for pie)\n * without the structured-output guard rejecting the whole plan.\n *\n * Three layers of tolerance:\n *\n *   1. {@link z.preprocess} normalizes wire shapes BEFORE union\n *      dispatch: stringified numbers parse to numbers, finite\n *      checks reject `NaN` / `Infinity`, 2-element arrays coerce\n *      tuple components, and `{value}` objects with missing /\n *      stringified `value` get coerced or rejected uniformly.\n *      Anything not handleable becomes `null`.\n *   2. The union accepts `null` as a first-class variant. Echarts\n *      renders null as a gap on bar / line / area (which is the\n *      right visual signal for \"missing reading\"). Scatter and\n *      pie filter nulls in {@link planToEchartsOption} because\n *      Echarts crashes on null tuples / slices.\n *   3. {@link z.union#catch} backstops the whole thing: if\n *      preprocess somehow produces a shape that still doesn't\n *      match any variant, the bad item becomes `null` instead of\n *      taking down the entire chart with a\n *      `Structured output validation failed` error.\n */\nconst chartDataPointSchema = z\n  .preprocess(\n    (v) => {\n      if (v === null || v === undefined) return null;\n      if (typeof v === \"number\") return Number.isFinite(v) ? v : null;\n      if (typeof v === \"string\") {\n        const n = Number(v);\n        return Number.isFinite(n) ? n : null;\n      }\n      if (Array.isArray(v) && v.length === 2) {\n        const x = typeof v[0] === \"number\" ? v[0] : Number(v[0]);\n        const y = typeof v[1] === \"number\" ? v[1] : Number(v[1]);\n        return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null;\n      }\n      if (typeof v === \"object\" && v !== null && \"value\" in v) {\n        const obj = v as { name?: unknown; value: unknown };\n        const val = typeof obj.value === \"number\" ? obj.value : Number(obj.value);\n        if (!Number.isFinite(val)) return null;\n        // Coerce numeric / boolean / nullish names to strings so a\n        // pie slice keyed on a year (`2024`) or category id is\n        // accepted without round-tripping through the catch arm.\n        const rawName = obj.name;\n        const name = typeof rawName === \"string\" ? rawName : rawName == null ? \"\" : String(rawName);\n        return { name, value: val };\n      }\n      return null;\n    },\n    z.union([\n      z.number(),\n      z.null(),\n      // `[x, y]` scatter point. Modelled as a length-constrained\n      // homogeneous array rather than `z.tuple`: Zod emits a tuple as\n      // JSON Schema 2020-12 `prefixItems`, and Databricks' Gemini\n      // endpoints reject a `response_json_schema` containing it\n      // (\"must be a boolean or an object\", since `items` is absent).\n      // `z.array(z.number()).length(2)` emits `items` + `minItems` /\n      // `maxItems`, which every provider understands, and validates\n      // the same two-number shape.\n      z.array(z.number()).length(2),\n      z.object({ name: z.string(), value: z.number() }),\n    ]),\n  )\n  .catch(null);\n\n/**\n * Compact, model-friendly representation of an Echarts spec. The\n * planner agent emits this; {@link planToEchartsOption} expands it\n * into a real `EChartsOption` JSON. Two layers because letting the\n * model fill in a fully-typed `EChartsOption` is brittle (hundreds\n * of optional fields, deep unions, version-dependent shapes). A\n * small \"chart plan\" schema is much more reliable for a fast model\n * and keeps animation / tooltip / styling defaults consistent\n * across charts.\n */\nexport const chartPlanSchema = z.object({\n  chartType: wire.ChartTypeSchema,\n  title: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Short title shown above the chart. Optional; defaults to the\n        \\`title\\` argument the caller passed in.\n      `),\n    ),\n  xAxisLabel: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Axis label below the chart. Used for bar / line / area / scatter;\n        ignored for pie.\n      `),\n    ),\n  yAxisLabel: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Axis label to the left of the chart. Used for bar / line / area /\n        scatter; ignored for pie.\n      `),\n    ),\n  categories: z\n    .array(z.string())\n    .optional()\n    .describe(\n      string.toDescription(`\n        X-axis category labels for \\`bar\\` / \\`line\\` / \\`area\\` charts\n        (one per data point in each series). Omit for \\`scatter\\` (uses\n        [x, y] tuples) and \\`pie\\` (each slice carries its own \\`name\\`).\n      `),\n    ),\n  series: z\n    .array(\n      z.object({\n        name: z.string().describe(\n          string.toDescription(`\n            Legend name for this series.\n          `),\n        ),\n        data: z.array(chartDataPointSchema).describe(\n          string.toDescription(`\n            Data points. For \\`bar\\` / \\`line\\` / \\`area\\`, an array of\n            numbers aligned to \\`categories\\`. For \\`scatter\\`, an array\n            of \\`[x, y]\\` numeric tuples. For \\`pie\\`, an array of\n            \\`{name, value}\\` objects.\n          `),\n        ),\n      }),\n    )\n    .min(1)\n    .describe(\n      string.toDescription(`\n        One or more series to plot. Pie charts use exactly one series;\n        bar/line/area can stack multiple series sharing the same\n        \\`categories\\` axis.\n      `),\n    ),\n});\n\ntype ChartPlan = z.infer<typeof chartPlanSchema>;\n\n/**\n * Canonical planner input shape. Tools that source rows from an\n * inline dataset (`render_data`) use it as their `inputSchema`\n * verbatim; tools that resolve rows from a remote (`prepare_chart`\n * over a Genie statement) `omit({ data })` and `extend` with their\n * own identifier field, so the field-level `.describe()` text\n * stays a single source of truth. Server-only - the UI never\n * sees a planner request, only the resolved {@link Chart}.\n */\nexport const chartPlannerRequestSchema = z.object({\n  title: z.string().describe(\n    string.toDescription(`\n        Concise title shown above the chart (e.g. \"Top 10 SKUs by Revenue\").\n      `),\n  ),\n  description: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        One-line intent the chart-planner uses when picking a chart type\n        and axis encodings (e.g. \"compare quarterly revenue across\n        regions\", \"highlight the steep drop after position 5\"). Not shown\n        to the user.\n      `),\n    ),\n  data: z\n    .array(z.record(z.string(), z.unknown()))\n    .nonempty(\"Data must contain at least one row\")\n    .readonly()\n    .describe(\n      string.toDescription(`\n        Tabular dataset to chart. One object per row, keyed by column\n        name. Values may be strings, numbers, booleans, or null. The\n        chart-planner decides which columns are categories vs. numeric\n        series. Cap at a few hundred rows for legibility; sample /\n        aggregate larger datasets first.\n      `),\n    ),\n});\n\nexport type ChartPlannerRequest = z.infer<typeof chartPlannerRequestSchema>;\n\n/* --------------------------- planner instructions --------------------------- */\n\n/**\n * Format {@link wire.ChartTypeSchema}'s variants as a single\n * human-friendly string of `` `<value>` for <description> ``\n * clauses joined by semicolons, drawn from each variant's own\n * `.describe()` so the planner prompt stays in lock-step with\n * the schema by construction.\n */\nfunction formatChartTypePicker(): string {\n  return wire.ChartTypeSchema.options\n    .map((opt) => `\\`${opt.value}\\` for ${opt.description ?? \"\"}`)\n    .join(\"; \");\n}\n\n/**\n * System prompt for the inner chart-planning agent. Tuned for a\n * fast-tier model (Haiku, GPT-5-mini, Gemini Flash Lite).\n */\nconst CHART_PLANNER_INSTRUCTIONS = string.toDescription(`\n  You design Apache Echarts visualizations. The user gives you a\n  tabular dataset (rows of objects) plus a title and an optional\n  description of the intent. You produce a small chart plan (chart\n  type, axis labels, categories, series) that best conveys the data.\n\n  Decision guide. Pick the chart type whose data shape matches the\n  dataset and the user's intent: ${formatChartTypePicker()}.\n\n  When in doubt between bar and line, prefer bar for unordered\n  categories and line for ordered ones (dates, time buckets, ranks).\n  Never pick pie for more than 7 slices.\n\n  For bar / line / area: pick one column as the category axis (usually\n  the only string-valued column) and one or more numeric columns as\n  series. Sort categories by the primary series value descending unless\n  the data is naturally ordered (dates, ranks).\n\n  For pie: pick the category column for slice names and one numeric\n  column for slice values. Emit a single series.\n\n  For scatter: pick two numeric columns and emit \\`[x, y]\\` tuples in a\n  single series.\n\n  Keep series names human-readable (use the column name; title case it\n  lightly if needed). Keep titles concise; do not repeat the user's\n  title in xAxisLabel / yAxisLabel.\n`);\n\n/* ----------------------------- planner agent ----------------------------- */\n\n/**\n * One planner `Agent` per plugin config. Cached on config object\n * identity so callers can `prepareChart({ config, ... })` from a\n * hot path without paying the Agent-constructor cost every call.\n * `WeakMap` lets retired configs (e.g. test reconfigurations)\n * release their agent without manual eviction.\n */\nconst plannerAgents = new WeakMap<MastraPluginConfig, Agent>();\n\nfunction getPlannerAgent(config: MastraPluginConfig): Agent {\n  let agent = plannerAgents.get(config);\n  if (!agent) {\n    agent = new Agent({\n      id: \"chart_planner\",\n      name: \"Chart Planner\",\n      description: \"Picks chart type and axis encodings for a dataset.\",\n      instructions: CHART_PLANNER_INSTRUCTIONS,\n      model: ({ requestContext }) =>\n        buildModel(config, requestContext, { modelClass: model.ModelClass.ChatFast }),\n    });\n    plannerAgents.set(config, agent);\n  }\n  return agent;\n}\n\n/**\n * Run the planner against `request` and return the resolved\n * Echarts spec. Throws on planner failure - {@link prepareChart}\n * catches and stashes the error in the cache entry.\n */\nasync function runChartPlanner(\n  config: MastraPluginConfig,\n  request: ChartPlannerRequest,\n  options: { requestContext?: RequestContext; abortSignal?: AbortSignal } = {},\n): Promise<ChartResult> {\n  const { title, description, data } = request;\n  const { requestContext, abortSignal } = options;\n  const prompt = string.toDescription({\n    Title: title,\n    ...(description ? { Description: description } : {}),\n    \"Dataset (JSON, one row per object)\": JSON.stringify(data, null, 2),\n  });\n  const result = await getPlannerAgent(config).generate(prompt, {\n    structuredOutput: { schema: chartPlanSchema },\n    ...(requestContext ? { requestContext } : {}),\n    ...(abortSignal ? { abortSignal } : {}),\n  });\n  const plan = chartPlanSchema.parse(result.object);\n  const option = planToEchartsOption(plan, title, config.brand);\n  return { chartType: plan.chartType, option };\n}\n\n/* ------------------------------ cache helpers ------------------------------ */\n\n/**\n * Build the canonical cache key for a `chartId` owned by `userKey`.\n *\n * The identity is part of the key, not a filter applied after the read, so a\n * chart id guessed or copied from another user's transcript resolves to a\n * different key and simply misses. That miss is what the HTTP route turns into\n * a 404, which is also the answer that leaks the least.\n */\nasync function chartCacheKey(chartId: string, userKey: string): Promise<string> {\n  return (await CacheManager.getInstance()).generateKey([CHART_CACHE_NAMESPACE, chartId], userKey);\n}\n\n/**\n * Persist a {@link Chart} entry under its `chartId`, owned by `userKey`.\n * Refreshes the TTL on every write. Cache-layer failures are logged and\n * swallowed so background runners never throw into the\n * unhandled-rejection stream.\n */\nasync function writeChart(entry: Chart, userKey: string): Promise<void> {\n  try {\n    const key = await chartCacheKey(entry.chartId, userKey);\n    await CacheManager.getInstanceSync().set(key, entry, {\n      ttl: CHART_CACHE_TTL_SEC,\n    });\n  } catch (err) {\n    logger.warn(\"write-error\", {\n      chartId: entry.chartId,\n      error: error.errorMessage(err),\n    });\n  }\n}\n\n/**\n * Look up a chart `userKey` owns. Returns `undefined` on miss, on\n * expiry, when another identity owns the id, or when the cache layer is\n * unhealthy - never throws.\n */\nasync function readChart(chartId: string, userKey: string): Promise<Chart | undefined> {\n  try {\n    const key = await chartCacheKey(chartId, userKey);\n    const v = await CacheManager.getInstanceSync().get<Chart>(key);\n    return v ?? undefined;\n  } catch (err) {\n    logger.warn(\"read-error\", {\n      chartId,\n      error: error.errorMessage(err),\n    });\n    return undefined;\n  }\n}\n\n/* --------------------------- prepareChart orchestrator --------------------------- */\n\n/** Inputs to {@link prepareChart}. */\nexport interface PrepareChartOptions {\n  /** Plugin config; resolves the planner agent's model. */\n  config: MastraPluginConfig;\n  /**\n   * Identity that owns the minted chart. Only a {@link fetchChart} call\n   * carrying the same key resolves it. Use {@link resolveUserKey}.\n   */\n  userKey: string;\n  /** Display title forwarded to the planner agent. */\n  title?: string;\n  /** Optional intent hint forwarded to the planner agent. */\n  description?: string;\n  /**\n   * Resolves the rows to chart. Called once, in the background.\n   * Any thrown error lands in the cache as the entry's `error`\n   * field (never propagated to the caller of {@link prepareChart}).\n   * An empty `rows` array is rejected as `\"dataset has no rows;\n   * nothing to chart\"`.\n   */\n  resolveData: (signal?: AbortSignal) => Promise<{ rows: ReadonlyArray<Record<string, unknown>> }>;\n  /**\n   * Per-request `RequestContext`. Forwarded to the planner agent so\n   * user-scoped model resolution (OBO) stays in effect.\n   */\n  requestContext?: RequestContext;\n  /**\n   * Cooperative cancellation. Forwarded to `resolveData` and the\n   * planner agent. Note: the chart task continues running in the\n   * background after the parent request ends, so external abort\n   * signals are best-effort; typical use is to leave this unset\n   * and let the 1h TTL cap stale entries.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Mint a `chartId`, cache an empty `{ chartId }` placeholder\n * synchronously, and kick off a background task that resolves the\n * dataset and runs the planner. Returns the `chartId` once the\n * placeholder lands so the first {@link fetchChart} call always\n * sees an entry (no spurious 404 race).\n *\n * The background task swallows its own failures and writes them\n * as `error` entries, so callers never see a rejected promise.\n * Cache state machine:\n *\n *   - just after this call returns: `{ chartId }` (processing)\n *   - on planner success:           `{ chartId, result }`\n *   - on data / planner failure:    `{ chartId, error }`\n */\nexport async function prepareChart(opts: PrepareChartOptions): Promise<{ chartId: string }> {\n  const chartId = hash.id();\n  await writeChart({ chartId }, opts.userKey);\n  logger.debug(\"queued\", { chartId });\n  // Fire-and-forget. Failures land in the cache as `error` entries;\n  // never escape into an unhandled rejection.\n  void runPrepareChart(chartId, opts);\n  return { chartId };\n}\n\nasync function runPrepareChart(chartId: string, opts: PrepareChartOptions): Promise<void> {\n  const startedAt = Date.now();\n  try {\n    const data = await opts.resolveData(opts.signal);\n    if (data.rows.length === 0) {\n      throw new ExecutionError(\"Dataset has no rows; nothing to chart\");\n    }\n    const result = await runChartPlanner(\n      opts.config,\n      {\n        title: opts.title ?? \"Chart\",\n        ...(opts.description ? { description: opts.description } : {}),\n        data: data.rows as ChartPlannerRequest[\"data\"],\n      },\n      {\n        ...(opts.requestContext ? { requestContext: opts.requestContext } : {}),\n        ...(opts.signal ? { abortSignal: opts.signal } : {}),\n      },\n    );\n    await writeChart({ chartId, result }, opts.userKey);\n    logger.info(\"done\", {\n      chartId,\n      chartType: result.chartType,\n      elapsedMs: Date.now() - startedAt,\n    });\n  } catch (err) {\n    logger.warn(\"error\", { chartId, error: error.errorMessage(err) });\n    // The entry's `error` is rendered in the chat, so only an AppKitError's\n    // own message travels; anything else could carry upstream provider detail.\n    const errText = err instanceof AppKitError ? err.message : CHART_FAILED_MESSAGE;\n    await writeChart({ chartId, error: errText }, opts.userKey);\n  }\n}\n\n/* ------------------------------- long-poll fetch ------------------------------- */\n\n/** Inputs to {@link fetchChart}. */\nexport interface FetchChartOptions {\n  /**\n   * Identity the chart must belong to. A chart minted under a different key\n   * is indistinguishable from an unknown id. Use {@link resolveUserKey}.\n   */\n  userKey: string;\n  /**\n   * Server-side polling budget in ms. When the entry stays in\n   * the processing state past this window, the helper returns the\n   * last seen value (still processing) so the client can re-poll.\n   * Defaults to {@link DEFAULT_FETCH_TIMEOUT_MS} (60s).\n   */\n  timeoutMs?: number;\n  /**\n   * Poll interval in ms. Defaults to\n   * {@link DEFAULT_FETCH_INTERVAL_MS} (250ms).\n   */\n  intervalMs?: number;\n  /** External cancellation handle (e.g. request `req.signal`). */\n  signal?: AbortSignal;\n}\n\n/**\n * Long-poll the chart cache until the entry settles (`result` or\n * `error` set), the entry is missing, or the server-side timeout\n * elapses.\n *\n * Returns:\n *   - the resolved {@link Chart} when it settled, errored, or\n *     stayed in processing past `timeoutMs` (so the client can\n *     re-poll);\n *   - `undefined` when the entry is missing, expired, or owned by\n *     another identity (the consumer should treat as 404).\n *\n * `signal` lets the caller cancel ahead of timeout (e.g. the HTTP\n * request closed). Cancellation propagates to the inter-poll sleep\n * so the helper returns immediately.\n */\nexport async function fetchChart(\n  chartId: string,\n  options: FetchChartOptions,\n): Promise<Chart | undefined> {\n  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;\n  const intervalMs = options.intervalMs ?? DEFAULT_FETCH_INTERVAL_MS;\n  const deadline = Date.now() + timeoutMs;\n\n  let last: Chart | undefined;\n  while (true) {\n    options.signal?.throwIfAborted();\n    last = await readChart(chartId, options.userKey);\n    if (!last) return undefined;\n    if (last.result !== undefined || last.error !== undefined) return last;\n    const remaining = deadline - Date.now();\n    if (remaining <= 0) return last;\n    await async.sleep(Math.min(intervalMs, remaining), options.signal);\n  }\n}\n\n/* ----------------------------- echarts theme ----------------------------- */\n\n/**\n * The slice of an Echarts option that carries brand identity: the series\n * color cycle and the base text style (font family + foreground color).\n * Derived from a {@link BrandContext} by {@link brandChartTheme} and merged\n * into every spec by {@link planToEchartsOption}.\n */\ninterface ChartTheme {\n  color: string[];\n  textStyle: { fontFamily: string; color: string };\n}\n\n/**\n * AppKit's categorical chart palette (`--chart-cat-1` .. `--chart-cat-8` from\n * `@databricks/appkit-ui`), as hex. Server-rendered chart specs cannot read the\n * browser's CSS custom properties, so the values are mirrored here to keep a\n * generated chart visually consistent with the AppKit-styled UI around it.\n * Keep in sync with AppKit's stylesheet if it changes.\n */\nconst APPKIT_CHART_PALETTE = [\n  \"#2463EB\", // blue\n  \"#2EB88A\", // teal\n  \"#AB47BD\", // purple\n  \"#F69E23\", // amber\n  \"#DD2C4D\", // rose\n  \"#1BA3BB\", // cyan\n  \"#9B61D1\", // lavender\n  \"#34B262\", // emerald\n] as const;\n\n/**\n * Expand two brand hex colors into a legible categorical cycle. Echarts\n * repeats the `color` array across series / categories, so a good default\n * needs several distinct hues, not two. We seed with the brand primary and\n * accent (the identity colors) and follow with AppKit's own categorical chart\n * palette, so multi-series / many-slice charts stay readable and match the\n * surrounding AppKit UI while the first one or two marks land on-brand.\n */\nfunction brandColorCycle(primary: string, accent: string): string[] {\n  const spread = APPKIT_CHART_PALETTE;\n  const seen = new Set<string>();\n  return [primary, accent, ...spread].filter((c) => {\n    const key = c.toLowerCase();\n    if (seen.has(key)) return false;\n    seen.add(key);\n    return true;\n  });\n}\n\n/**\n * Derive an Echarts {@link ChartTheme} from a brand context: the primary +\n * accent colors seed the series cycle, the sans stack becomes the base font,\n * and the brand foreground becomes the base text color.\n */\nfunction brandChartTheme(brand: BrandContext): ChartTheme {\n  return {\n    color: brandColorCycle(brand.colors.primary, brand.colors.accent),\n    textStyle: { fontFamily: brand.typography.sans, color: brand.colors.foreground },\n  };\n}\n\n/* ----------------------------- echarts expansion ----------------------------- */\n\n/**\n * Expand a {@link ChartPlan} into a full Echarts `EChartsOption`\n * JSON. Centralized here so the planner agent only fills in the\n * compact plan shape; tooltip / animation / color / grid defaults\n * stay consistent across charts and are easy to tune without\n * retraining model behaviour.\n *\n * When `brand` is set, the resolved spec is themed with the brand's series\n * color cycle and base text style (see {@link brandChartTheme}); otherwise\n * Echarts' defaults apply.\n */\nfunction planToEchartsOption(\n  plan: ChartPlan,\n  fallbackTitle: string,\n  brand?: BrandContext,\n): Record<string, unknown> {\n  const baseTitle = plan.title ?? fallbackTitle;\n  const grid = { left: 48, right: 24, top: 56, bottom: 48, containLabel: true };\n  const theme = brand ? brandChartTheme(brand) : undefined;\n  const themed = (option: Record<string, unknown>): Record<string, unknown> =>\n    theme ? { ...theme, ...option } : option;\n\n  if (plan.chartType === \"pie\") {\n    // Echarts crashes on null pie slices - filter them out.\n    // `{name, value}` slices are the only valid pie data shape,\n    // so drop bare numbers / tuples / nulls the planner may\n    // have leaked into a pie series.\n    const slices = (plan.series[0]?.data ?? []).filter(\n      (d): d is { name: string; value: number } =>\n        d !== null && typeof d === \"object\" && !Array.isArray(d),\n    );\n    return themed({\n      title: { text: baseTitle, left: \"center\" },\n      tooltip: { trigger: \"item\" },\n      legend: { bottom: 0 },\n      series: [\n        {\n          name: plan.series[0]?.name ?? baseTitle,\n          type: \"pie\",\n          radius: [\"35%\", \"65%\"],\n          data: slices,\n        },\n      ],\n    });\n  }\n\n  if (plan.chartType === \"scatter\") {\n    // Echarts crashes on null scatter points - keep only valid\n    // `[x, y]` tuples. Bare numbers / objects / nulls from a\n    // mismatched plan get dropped silently.\n    return themed({\n      title: { text: baseTitle, left: \"center\" },\n      tooltip: { trigger: \"item\" },\n      legend: { bottom: 0 },\n      grid,\n      xAxis: { type: \"value\", name: plan.xAxisLabel },\n      yAxis: { type: \"value\", name: plan.yAxisLabel },\n      series: plan.series.map((s) => ({\n        name: s.name,\n        type: \"scatter\",\n        data: s.data.filter((d): d is [number, number] => Array.isArray(d) && d.length === 2),\n      })),\n    });\n  }\n\n  // bar / line / area share the same axis layout.\n  const isArea = plan.chartType === \"area\";\n  const seriesType = plan.chartType === \"bar\" ? \"bar\" : \"line\";\n  return themed({\n    title: { text: baseTitle, left: \"center\" },\n    tooltip: { trigger: \"axis\" },\n    legend: { bottom: 0 },\n    grid,\n    xAxis: {\n      type: \"category\",\n      data: plan.categories ?? [],\n      name: plan.xAxisLabel,\n    },\n    yAxis: { type: \"value\", name: plan.yAxisLabel },\n    series: plan.series.map((s) => ({\n      name: s.name,\n      type: seriesType,\n      data: s.data,\n      smooth: seriesType === \"line\",\n      ...(isArea ? { areaStyle: {} } : {}),\n    })),\n  });\n}\n\n/* ----------------------------- render_data tool ----------------------------- */\n\n/**\n * Build the `render_data` Mastra tool bound to the given plugin\n * config. Auto-wired as a system tool on every agent (see\n * `agents.ts`); per-agent tools can shadow it by registering a\n * same-named entry.\n *\n * Thin wrapper over {@link prepareChart} for callers that already\n * have a dataset in hand. Mints a `chartId` synchronously, caches\n * an empty placeholder, and kicks off the chart-planner in the\n * background. Returns just the `chartId`; the host UI resolves\n * `[chart:<chartId>]` markers by hitting the plugin's\n * `/embed/chart/:id` route.\n *\n * For Genie statement results, prefer the Genie agent's\n * `prepare_chart` tool, which accepts a `statement_id` and\n * resolves the rows lazily.\n */\nexport function buildRenderDataTool(config: MastraPluginConfig) {\n  return createTool({\n    id: \"render_data\",\n    description: string.toDescription([\n      `\n        Submit a tabular dataset for inline rendering as a chart in\n        the user's view. Pass a title, the raw rows (array of objects\n        keyed by column name), and an optional one-line description\n        of the insight to highlight. Returns a short \\`chartId\\`;\n        the chart renders inline at the position you embed the\n        matching \\`[chart:<chartId>]\\` marker.\n      `,\n      `\n        Placement contract: embed \\`[chart:<chartId>]\\` on its own\n        line (blank lines above and below) wherever you want the\n        chart to appear in your reply. The chart resolves\n        asynchronously - the tool returns the id immediately and the\n        host UI fetches the chart from the cache once the planner\n        lands. You can call \\`render_data\\` multiple times in the\n        same turn (the tool is parallel-safe) and interleave the\n        markers with prose so each chart sits next to its\n        commentary.\n      `,\n      `\n        Use whenever a SQL row set, API response, or hand-built\n        dataset would land better as a picture than as a list or\n        table. Cap input at a few hundred rows; sample or aggregate\n        larger datasets first.\n      `,\n    ]),\n    inputSchema: chartPlannerRequestSchema,\n    outputSchema: wire.ChartSchema.pick({ chartId: true }),\n    execute: async (input, ctxRaw) => {\n      const { title, description, data } = input as ChartPlannerRequest;\n      const ctx = ctxRaw as { requestContext?: RequestContext } | undefined;\n      return prepareChart({\n        config,\n        userKey: resolveUserKey(ctx?.requestContext),\n        title,\n        ...(description ? { description } : {}),\n        resolveData: () => Promise.resolve({ rows: data }),\n        ...(ctx?.requestContext ? { requestContext: ctx.requestContext } : {}),\n      });\n    },\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.js","sourceRoot":"","sources":["../../src/chart.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Chart planner + chart cache.\n *\n * Self-contained chart subsystem with two layers:\n *\n *   1. Inner planner agent (private). Pure dataset-in /\n *      `EChartsOption`-out brain. Driven by {@link prepareChart};\n *      callers never instantiate it directly.\n *   2. {@link prepareChart}: orchestration on top of the planner.\n *      Mints a `chartId`, caches an empty `{ chartId }` record\n *      synchronously, then resolves the dataset and runs the\n *      planner in the background. The terminal entry settles with\n *      either `result` (success) or `error` (failure). Both\n *      undefined means the entry is still processing.\n *\n * The cache surface ({@link fetchChart}) is the only state the\n * HTTP route and the chart-producing tools share. `prepareChart`\n * is dataset-agnostic - callers supply a `resolveData` callback\n * that fetches the rows however they like (Genie statement, inline\n * dataset, custom API). The module has no knowledge of Genie or\n * statement ids; those concerns live in the tools that wrap it.\n *\n * Wire-format schemas live in `@dbx-tools/shared-mastra` so\n * the demo client and any other UI consumer share the exact same\n * shape this module reads and writes.\n *\n * @module\n */\n\nimport { AppKitError, CacheManager, ExecutionError } from \"@databricks/appkit\";\nimport { async, error, hash, json, log, string, type BrandContext } from \"@dbx-tools/shared-core\";\nimport { marker, wire, type Chart, type ChartResult } from \"@dbx-tools/shared-mastra\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport { Agent } from \"@mastra/core/agent\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport { createTool } from \"@mastra/core/tools\";\nimport { z } from \"zod\";\n\nimport { resolveUserKey, type MastraPluginConfig } from \"./config.ts\";\nimport { buildModel } from \"./model.ts\";\n\nconst logger = log.logger(\"mastra/chart\");\n\n/* ------------------------------ constants ------------------------------ */\n\n/**\n * TTL for cached chart entries. One hour balances \"long enough for\n * the host UI to fetch the chart well after the model finished\n * talking\" against \"short enough that abandoned chart ids don't\n * pin storage\". Matches the typical Databricks OBO token lifetime\n * so any data re-resolution stays inside the original auth window.\n */\nconst CHART_CACHE_TTL_SEC = 60 * 60;\n\n/** Cache namespace; keeps the chart keyspace tidy. */\nconst CHART_CACHE_NAMESPACE = \"mastra:chart\";\n\n/** Default server-side long-poll budget for {@link fetchChart}. */\nconst DEFAULT_FETCH_TIMEOUT_MS = 60_000;\n\n/** Default inter-poll sleep for {@link fetchChart}. */\nconst DEFAULT_FETCH_INTERVAL_MS = 250;\n\n/** Stable text stored on a chart entry whose planner run failed. */\nconst CHART_FAILED_MESSAGE = \"Chart generation failed\";\n\n/* ------------------------------- schemas ------------------------------- */\n\n/**\n * One series data point. Wide variant set so the planner agent can\n * faithfully pass through whatever the SQL row set contained\n * (numbers, stringified numbers, nulls for missing measurements,\n * `[x, y]` tuples for scatter, `[x, y, value]` triples for heatmap,\n * `{name, value}` slices for pie / funnel / treemap) without the\n * structured-output guard rejecting the whole plan.\n *\n * Three layers of tolerance:\n *\n *   1. {@link z.preprocess} normalizes wire shapes BEFORE union\n *      dispatch: stringified numbers parse to numbers, finite\n *      checks reject `NaN` / `Infinity`, 2-/3-element arrays coerce\n *      tuple components, and `{value}` objects with missing /\n *      stringified `value` get coerced or rejected uniformly.\n *      Anything not handleable becomes `null`.\n *   2. The union accepts `null` as a first-class variant. Echarts\n *      renders null as a gap on bar / line / area (which is the\n *      right visual signal for \"missing reading\"). Scatter, heatmap,\n *      and slice charts filter nulls in {@link planToEchartsOption}\n *      because Echarts crashes on null tuples / slices.\n *   3. {@link z.union#catch} backstops the whole thing: if\n *      preprocess somehow produces a shape that still doesn't\n *      match any variant, the bad item becomes `null` instead of\n *      taking down the entire chart with a\n *      `Structured output validation failed` error.\n */\nconst chartDataPointSchema = z\n  .preprocess(\n    (v) => {\n      if (v === null || v === undefined) return null;\n      if (typeof v === \"number\") return Number.isFinite(v) ? v : null;\n      if (typeof v === \"string\") {\n        const n = Number(v);\n        return Number.isFinite(n) ? n : null;\n      }\n      // Scatter `[x, y]` or heatmap `[xIndex, yIndex, value]`. Coerce\n      // stringified components; reject if any component is non-finite.\n      if (Array.isArray(v) && (v.length === 2 || v.length === 3)) {\n        const nums = v.map((c) => (typeof c === \"number\" ? c : Number(c)));\n        return nums.every((n) => Number.isFinite(n)) ? nums : null;\n      }\n      if (typeof v === \"object\" && v !== null && \"value\" in v) {\n        const obj = v as { name?: unknown; value: unknown };\n        const val = typeof obj.value === \"number\" ? obj.value : Number(obj.value);\n        if (!Number.isFinite(val)) return null;\n        // Coerce numeric / boolean / nullish names to strings so a\n        // pie slice keyed on a year (`2024`) or category id is\n        // accepted without round-tripping through the catch arm.\n        const rawName = obj.name;\n        const name = typeof rawName === \"string\" ? rawName : rawName == null ? \"\" : String(rawName);\n        return { name, value: val };\n      }\n      return null;\n    },\n    z.union([\n      z.number(),\n      z.null(),\n      // `[x, y]` scatter or `[x, y, value]` heatmap cell. Modelled as a\n      // length-constrained homogeneous array rather than `z.tuple`:\n      // Zod emits a tuple as JSON Schema 2020-12 `prefixItems`, and\n      // Databricks' Gemini endpoints reject a `response_json_schema`\n      // containing it (\"must be a boolean or an object\", since\n      // `items` is absent). `minItems` / `maxItems` + `items` is what\n      // every provider understands.\n      z.array(z.number()).min(2).max(3),\n      z.object({ name: z.string(), value: z.number() }),\n    ]),\n  )\n  .catch(null);\n\n/** Per-series mark type used by `combo` charts (bar + line overlay). */\nconst seriesMarkTypeSchema = z\n  .union([z.literal(\"bar\"), z.literal(\"line\"), z.literal(\"area\")])\n  .describe(\n    \"Mark type for this series. Required for `combo` (mix bar and line/area); ignored for other chart types.\",\n  );\n\n/**\n * Compact, model-friendly representation of an Echarts spec. The\n * planner agent emits this; {@link planToEchartsOption} expands it\n * into a real `EChartsOption` JSON. Two layers because letting the\n * model fill in a fully-typed `EChartsOption` is brittle (hundreds\n * of optional fields, deep unions, version-dependent shapes). A\n * small \"chart plan\" schema is much more reliable for a fast model\n * and keeps animation / tooltip / styling defaults consistent\n * across charts.\n */\nexport const chartPlanSchema = z.object({\n  chartType: wire.ChartTypeSchema,\n  title: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Short title shown above the chart. Optional; defaults to the\n        \\`title\\` argument the caller passed in.\n      `),\n    ),\n  xAxisLabel: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Axis label for the primary (usually bottom / value) axis.\n        Used for bar / horizontalBar / line / area / combo / waterfall\n        / scatter / heatmap; ignored for pie / funnel / treemap / radar.\n      `),\n    ),\n  yAxisLabel: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Axis label for the secondary (usually left) axis. Used for\n        bar / horizontalBar / line / area / combo / waterfall /\n        scatter / heatmap; ignored for pie / funnel / treemap / radar.\n      `),\n    ),\n  categories: z\n    .array(z.string())\n    .optional()\n    .describe(\n      string.toDescription(`\n        Primary category labels. For \\`bar\\` / \\`horizontalBar\\` /\n        \\`line\\` / \\`area\\` / \\`combo\\` / \\`waterfall\\`: one label per\n        data point. For \\`heatmap\\`: x-axis categories. For \\`radar\\`:\n        indicator names. Omit for \\`scatter\\` (\\`[x, y]\\` tuples) and\n        slice charts (\\`pie\\` / \\`funnel\\` / \\`treemap\\`, each slice\n        carries its own \\`name\\`).\n      `),\n    ),\n  yCategories: z\n    .array(z.string())\n    .optional()\n    .describe(\n      string.toDescription(`\n        Y-axis (row) labels for \\`heatmap\\`. Optional - when omitted the\n        row labels come from the series names, which is the preferred\n        way to build a heatmap. Omit for every other chart type.\n      `),\n    ),\n  series: z\n    .array(\n      z.object({\n        name: z.string().describe(\n          string.toDescription(`\n            Legend name for this series.\n          `),\n        ),\n        type: seriesMarkTypeSchema.optional(),\n        yAxisIndex: z\n          .union([z.literal(0), z.literal(1)])\n          .optional()\n          .describe(\n            \"Which y-axis to bind (0 = left, 1 = right). Use on `combo` when series have different units or scales.\",\n          ),\n        data: z.array(chartDataPointSchema).describe(\n          string.toDescription(`\n            Data points. For category charts (\\`bar\\` / \\`horizontalBar\\`\n            / \\`line\\` / \\`area\\` / \\`combo\\` / \\`waterfall\\` / \\`radar\\`),\n            an array of numbers aligned to \\`categories\\`; for\n            \\`waterfall\\` those numbers are signed deltas (one series\n            only - never a cumulative base series). For \\`heatmap\\`,\n            one series per matrix row, holding that row's numbers\n            aligned to \\`categories\\`. For \\`scatter\\`, an array of\n            \\`[x, y]\\` numeric tuples. For \\`pie\\` / \\`funnel\\` /\n            \\`treemap\\`, an array of \\`{name, value}\\` objects.\n          `),\n        ),\n      }),\n    )\n    .default([])\n    .describe(\n      string.toDescription(`\n        One or more series to plot. Required for every chart type\n        except \\`custom\\`, which carries its series inside \\`option\\`.\n        Slice charts (\\`pie\\` / \\`funnel\\` / \\`treemap\\`) and\n        \\`waterfall\\` / \\`heatmap\\` use exactly one series; \\`bar\\` /\n        \\`line\\` / \\`area\\` / \\`combo\\` / \\`radar\\` / \\`scatter\\` can\n        carry multiple series.\n      `),\n    ),\n  option: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Required for \\`custom\\`, ignored for every other chart type. A\n        COMPLETE Echarts option, as a JSON object encoded in a string:\n        \\`series\\` (each with its own \\`type\\` and that series' own data\n        shape) plus whatever else the chart needs - a coordinate system,\n        \\`visualMap\\`, axes. Plain JSON values only, never a JavaScript\n        function. A centered title is filled in when the object omits\n        one.\n      `),\n    ),\n});\n\ntype ChartPlan = z.infer<typeof chartPlanSchema>;\n\n/**\n * Canonical planner input shape. Tools that source rows from an\n * inline dataset (`render_data`) use it as their `inputSchema`\n * verbatim; tools that resolve rows from a remote (`prepare_chart`\n * over a Genie statement) `omit({ data })` and `extend` with their\n * own identifier field, so the field-level `.describe()` text\n * stays a single source of truth. Server-only - the UI never\n * sees a planner request, only the resolved {@link Chart}.\n */\nexport const chartPlannerRequestSchema = z.object({\n  title: z.string().describe(\n    string.toDescription(`\n        Concise title shown above the chart (e.g. \"Top 10 SKUs by Revenue\").\n      `),\n  ),\n  description: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        One-line intent the chart-planner uses when picking a chart type\n        and axis encodings (e.g. \"compare quarterly revenue across\n        regions\", \"highlight the steep drop after position 5\"). Not shown\n        to the user.\n      `),\n    ),\n  data: z\n    .array(z.record(z.string(), z.unknown()))\n    .nonempty(\"Data must contain at least one row\")\n    .readonly()\n    .describe(\n      string.toDescription(`\n        Tabular dataset to chart. One object per row, keyed by column\n        name. Values may be strings, numbers, booleans, or null. The\n        chart-planner decides which columns are categories vs. numeric\n        series. Cap at a few hundred rows for legibility; sample /\n        aggregate larger datasets first.\n      `),\n    ),\n});\n\nexport type ChartPlannerRequest = z.infer<typeof chartPlannerRequestSchema>;\n\n/**\n * Agent-facing result of either chart-producing tool.\n *\n * `marker` is deliberately redundant with `chartId`: the host still keys the\n * cache by id, while the model gets the exact opaque token to copy into prose\n * and has no reason to invent or retype a UUID.\n */\nexport const chartToolOutputSchema = wire.ChartSchema.pick({ chartId: true }).extend({\n  marker: z\n    .string()\n    .describe(\n      \"Exact embed marker. Copy this complete value verbatim onto its own line; never construct a marker from chartId.\",\n    ),\n});\n\n/** Result returned synchronously while chart planning continues in the background. */\nexport type ChartToolOutput = z.infer<typeof chartToolOutputSchema>;\n\n/* --------------------------- planner instructions --------------------------- */\n\n/**\n * Format {@link wire.ChartTypeSchema}'s variants as a single\n * human-friendly string of `` `<value>` for <description> ``\n * clauses joined by semicolons, drawn from each variant's own\n * `.describe()` so the planner prompt stays in lock-step with\n * the schema by construction.\n */\nfunction formatChartTypePicker(): string {\n  return wire.ChartTypeSchema.options\n    .map((opt) => `\\`${opt.value}\\` for ${opt.description ?? \"\"}`)\n    .join(\"; \");\n}\n\n/**\n * System prompt for the inner chart-planning agent. Tuned for a\n * fast-tier model (Haiku, GPT-5-mini, Gemini Flash Lite).\n */\nconst CHART_PLANNER_INSTRUCTIONS = string.toDescription(`\n  You design Apache Echarts visualizations. The user gives you a\n  tabular dataset (rows of objects) plus a title and an optional\n  description of the intent. You produce a small chart plan (chart\n  type, axis labels, categories, series) that best conveys the data.\n\n  Decision guide. Pick the chart type whose data shape matches the\n  dataset and the user's intent: ${formatChartTypePicker()}.\n\n  When in doubt between bar and line, prefer bar for unordered\n  categories and line for ordered ones (dates, time buckets, ranks).\n  Prefer \\`horizontalBar\\` when category labels are long. Prefer\n  \\`combo\\` when one measure is a count/volume and another is a\n  rate/trend. Prefer \\`waterfall\\` for bridges of signed deltas.\n  Prefer \\`scatter\\` when correlating two numeric fields (no\n  category axis). Prefer \\`heatmap\\` for a category x category\n  matrix. Prefer \\`radar\\` for scoring the same entities across a\n  fixed set of dimensions. Never pick pie for more than 7 slices\n  (use \\`treemap\\` instead). Prefer \\`funnel\\` for ordered conversion\n  stages.\n\n  For bar / horizontalBar / line / area / combo / waterfall: pick one\n  column as the category axis (usually the only string-valued column)\n  and one or more numeric columns as series. Sort categories by the\n  primary series value descending unless the data is naturally ordered\n  (dates, ranks, funnel stages, waterfall steps). For \\`combo\\`, set\n  each series' \\`type\\` to \\`bar\\`, \\`line\\`, or \\`area\\`, and use\n  \\`yAxisIndex: 1\\` when a series needs a second scale.\n\n  For waterfall, emit exactly ONE series holding the signed step values\n  (deltas), one per category, in order - positive for a rise, negative\n  for a drop. Do NOT add a cumulative / running-total / base series and\n  do NOT convert the deltas into running totals yourself; the running\n  total is computed for you, and a hand-built base series renders as a\n  plain bar chart instead of a bridge.\n\n  For pie / funnel / treemap: pick the category column for slice names\n  and one numeric column for slice values. Emit a single series of\n  \\`{name, value}\\` objects.\n\n  For scatter: pick two numeric columns and emit \\`[x, y]\\` tuples in\n  one or more series (one series per group if a grouping column exists).\n\n  For heatmap: pick two category columns and one numeric measure. Put\n  the x-axis categories in \\`categories\\`, then emit ONE SERIES PER ROW\n  of the matrix - the series \\`name\\` is the row label and \\`data\\` is\n  the row's numbers, one per entry in \\`categories\\`, in the same order.\n  Do not compute cell indices.\n\n  For radar: \\`categories\\` are the indicator names; each series is an\n  array of numbers (one value per indicator).\n\n  For anything the types above cannot express - a sankey, boxplot,\n  candlestick, sunburst, gauge, network graph, calendar, parallel-\n  coordinates plot, or any other Echarts series - use \\`custom\\` and\n  hand-write the whole Echarts option into \\`option\\` as a JSON string.\n  Include every part that chart needs: the series with their own\n  \\`type\\` and data shape, plus any coordinate system, \\`visualMap\\`,\n  or axes. Leave \\`series\\`, \\`categories\\`, and the axis labels out;\n  they are ignored for \\`custom\\`. Prefer a listed type whenever one\n  genuinely fits - \\`custom\\` gives up the shared tooltip, legend, and\n  grid defaults, so it is the answer for an unsupported chart shape,\n  not a way to restyle a supported one.\n\n  Keep series names human-readable (use the column name; title case it\n  lightly if needed). Keep titles concise; do not repeat the user's\n  title in xAxisLabel / yAxisLabel.\n`);\n\n/* ----------------------------- planner agent ----------------------------- */\n\n/**\n * One planner `Agent` per plugin config. Cached on config object\n * identity so callers can `prepareChart({ config, ... })` from a\n * hot path without paying the Agent-constructor cost every call.\n * `WeakMap` lets retired configs (e.g. test reconfigurations)\n * release their agent without manual eviction.\n */\nconst plannerAgents = new WeakMap<MastraPluginConfig, Agent>();\n\nfunction getPlannerAgent(config: MastraPluginConfig): Agent {\n  let agent = plannerAgents.get(config);\n  if (!agent) {\n    agent = new Agent({\n      id: \"chart_planner\",\n      name: \"Chart Planner\",\n      description: \"Picks chart type and axis encodings for a dataset.\",\n      instructions: CHART_PLANNER_INSTRUCTIONS,\n      model: ({ requestContext }) =>\n        buildModel(config, requestContext, { modelClass: model.ModelClass.ChatFast }),\n    });\n    plannerAgents.set(config, agent);\n  }\n  return agent;\n}\n\n/**\n * Run the planner against `request` and return the resolved\n * Echarts spec. Throws on planner failure - {@link prepareChart}\n * catches and stashes the error in the cache entry.\n */\nasync function runChartPlanner(\n  config: MastraPluginConfig,\n  request: ChartPlannerRequest,\n  options: { requestContext?: RequestContext; abortSignal?: AbortSignal } = {},\n): Promise<ChartResult> {\n  const { title, description, data } = request;\n  const { requestContext, abortSignal } = options;\n  const prompt = string.toDescription({\n    Title: title,\n    ...(description ? { Description: description } : {}),\n    \"Dataset (JSON, one row per object)\": JSON.stringify(data, null, 2),\n  });\n  const result = await getPlannerAgent(config).generate(prompt, {\n    structuredOutput: { schema: chartPlanSchema },\n    ...(requestContext ? { requestContext } : {}),\n    ...(abortSignal ? { abortSignal } : {}),\n  });\n  const plan = chartPlanSchema.parse(result.object);\n  const option = planToEchartsOption(plan, title, config.brand);\n  return { chartType: plan.chartType, option };\n}\n\n/* ------------------------------ cache helpers ------------------------------ */\n\n/**\n * Build the canonical cache key for a `chartId` owned by `userKey`.\n *\n * The identity is part of the key, not a filter applied after the read, so a\n * chart id guessed or copied from another user's transcript resolves to a\n * different key and simply misses. That miss is what the HTTP route turns into\n * a 404, which is also the answer that leaks the least.\n */\nasync function chartCacheKey(chartId: string, userKey: string): Promise<string> {\n  return (await CacheManager.getInstance()).generateKey([CHART_CACHE_NAMESPACE, chartId], userKey);\n}\n\n/**\n * Persist a {@link Chart} entry under its `chartId`, owned by `userKey`.\n * Refreshes the TTL on every write. Cache-layer failures are logged and\n * swallowed so background runners never throw into the\n * unhandled-rejection stream.\n */\nasync function writeChart(entry: Chart, userKey: string): Promise<void> {\n  try {\n    const key = await chartCacheKey(entry.chartId, userKey);\n    await CacheManager.getInstanceSync().set(key, entry, {\n      ttl: CHART_CACHE_TTL_SEC,\n    });\n  } catch (err) {\n    logger.warn(\"write-error\", {\n      chartId: entry.chartId,\n      error: error.errorMessage(err),\n    });\n  }\n}\n\n/**\n * Look up a chart `userKey` owns. Returns `undefined` on miss, on\n * expiry, when another identity owns the id, or when the cache layer is\n * unhealthy - never throws.\n */\nasync function readChart(chartId: string, userKey: string): Promise<Chart | undefined> {\n  try {\n    const key = await chartCacheKey(chartId, userKey);\n    const v = await CacheManager.getInstanceSync().get<Chart>(key);\n    return v ?? undefined;\n  } catch (err) {\n    logger.warn(\"read-error\", {\n      chartId,\n      error: error.errorMessage(err),\n    });\n    return undefined;\n  }\n}\n\n/* --------------------------- prepareChart orchestrator --------------------------- */\n\n/** Inputs to {@link prepareChart}. */\nexport interface PrepareChartOptions {\n  /** Plugin config; resolves the planner agent's model. */\n  config: MastraPluginConfig;\n  /**\n   * Identity that owns the minted chart. Only a {@link fetchChart} call\n   * carrying the same key resolves it. Use {@link resolveUserKey}.\n   */\n  userKey: string;\n  /** Display title forwarded to the planner agent. */\n  title?: string;\n  /** Optional intent hint forwarded to the planner agent. */\n  description?: string;\n  /**\n   * Resolves the rows to chart. Called once, in the background.\n   * Any thrown error lands in the cache as the entry's `error`\n   * field (never propagated to the caller of {@link prepareChart}).\n   * An empty `rows` array is rejected as `\"dataset has no rows;\n   * nothing to chart\"`.\n   */\n  resolveData: (signal?: AbortSignal) => Promise<{ rows: ReadonlyArray<Record<string, unknown>> }>;\n  /**\n   * Per-request `RequestContext`. Forwarded to the planner agent so\n   * user-scoped model resolution (OBO) stays in effect.\n   */\n  requestContext?: RequestContext;\n  /**\n   * Cooperative cancellation. Forwarded to `resolveData` and the\n   * planner agent. Note: the chart task continues running in the\n   * background after the parent request ends, so external abort\n   * signals are best-effort; typical use is to leave this unset\n   * and let the 1h TTL cap stale entries.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Mint a `chartId`, cache an empty `{ chartId }` placeholder\n * synchronously, and kick off a background task that resolves the\n * dataset and runs the planner. Returns the `chartId` once the\n * placeholder lands so the first {@link fetchChart} call always\n * sees an entry (no spurious 404 race).\n *\n * The background task swallows its own failures and writes them\n * as `error` entries, so callers never see a rejected promise.\n * Cache state machine:\n *\n *   - just after this call returns: `{ chartId }` (processing)\n *   - on planner success:           `{ chartId, result }`\n *   - on data / planner failure:    `{ chartId, error }`\n */\nexport async function prepareChart(opts: PrepareChartOptions): Promise<ChartToolOutput> {\n  const chartId = hash.id();\n  await writeChart({ chartId }, opts.userKey);\n  logger.debug(\"queued\", { chartId });\n  // Fire-and-forget. Failures land in the cache as `error` entries;\n  // never escape into an unhandled rejection.\n  void runPrepareChart(chartId, opts);\n  return { chartId, marker: marker.formatMarker(\"chart\", chartId) };\n}\n\nasync function runPrepareChart(chartId: string, opts: PrepareChartOptions): Promise<void> {\n  const startedAt = Date.now();\n  try {\n    const data = await opts.resolveData(opts.signal);\n    if (data.rows.length === 0) {\n      throw new ExecutionError(\"Dataset has no rows; nothing to chart\");\n    }\n    const result = await runChartPlanner(\n      opts.config,\n      {\n        title: opts.title ?? \"Chart\",\n        ...(opts.description ? { description: opts.description } : {}),\n        data: data.rows as ChartPlannerRequest[\"data\"],\n      },\n      {\n        ...(opts.requestContext ? { requestContext: opts.requestContext } : {}),\n        ...(opts.signal ? { abortSignal: opts.signal } : {}),\n      },\n    );\n    await writeChart({ chartId, result }, opts.userKey);\n    logger.info(\"done\", {\n      chartId,\n      chartType: result.chartType,\n      elapsedMs: Date.now() - startedAt,\n    });\n  } catch (err) {\n    logger.warn(\"error\", { chartId, error: error.errorMessage(err) });\n    // The entry's `error` is rendered in the chat, so only an AppKitError's\n    // own message travels; anything else could carry upstream provider detail.\n    const errText = err instanceof AppKitError ? err.message : CHART_FAILED_MESSAGE;\n    await writeChart({ chartId, error: errText }, opts.userKey);\n  }\n}\n\n/* ------------------------------- long-poll fetch ------------------------------- */\n\n/** Inputs to {@link fetchChart}. */\nexport interface FetchChartOptions {\n  /**\n   * Identity the chart must belong to. A chart minted under a different key\n   * is indistinguishable from an unknown id. Use {@link resolveUserKey}.\n   */\n  userKey: string;\n  /**\n   * Server-side polling budget in ms. When the entry stays in\n   * the processing state past this window, the helper returns the\n   * last seen value (still processing) so the client can re-poll.\n   * Defaults to {@link DEFAULT_FETCH_TIMEOUT_MS} (60s).\n   */\n  timeoutMs?: number;\n  /**\n   * Poll interval in ms. Defaults to\n   * {@link DEFAULT_FETCH_INTERVAL_MS} (250ms).\n   */\n  intervalMs?: number;\n  /** External cancellation handle (e.g. request `req.signal`). */\n  signal?: AbortSignal;\n}\n\n/**\n * Long-poll the chart cache until the entry settles (`result` or\n * `error` set), the entry is missing, or the server-side timeout\n * elapses.\n *\n * Returns:\n *   - the resolved {@link Chart} when it settled, errored, or\n *     stayed in processing past `timeoutMs` (so the client can\n *     re-poll);\n *   - `undefined` when the entry is missing, expired, or owned by\n *     another identity (the consumer should treat as 404).\n *\n * `signal` lets the caller cancel ahead of timeout (e.g. the HTTP\n * request closed). Cancellation propagates to the inter-poll sleep\n * so the helper returns immediately.\n */\nexport async function fetchChart(\n  chartId: string,\n  options: FetchChartOptions,\n): Promise<Chart | undefined> {\n  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;\n  const intervalMs = options.intervalMs ?? DEFAULT_FETCH_INTERVAL_MS;\n  const deadline = Date.now() + timeoutMs;\n\n  let last: Chart | undefined;\n  while (true) {\n    options.signal?.throwIfAborted();\n    last = await readChart(chartId, options.userKey);\n    if (!last) return undefined;\n    if (last.result !== undefined || last.error !== undefined) return last;\n    const remaining = deadline - Date.now();\n    if (remaining <= 0) return last;\n    await async.sleep(Math.min(intervalMs, remaining), options.signal);\n  }\n}\n\n/* ----------------------------- echarts theme ----------------------------- */\n\n/**\n * The slice of an Echarts option that carries brand identity: the series\n * color cycle and the base font stack. Derived from a {@link BrandContext}\n * by {@link brandChartTheme} and merged into every spec by\n * {@link planToEchartsOption}.\n *\n * Deliberately carries no text COLOR. A spec is planned here, on the\n * server, and read later in a browser whose light/dark theme this code\n * cannot know; baking in the brand's single (light) foreground produced\n * near-black labels that disappeared against a dark chat surface. The\n * renderer resolves chrome colors from AppKit's live CSS tokens instead\n * (`@dbx-tools/ui-mastra`'s `chart-theme` + `normalizeChartOption`),\n * leaving this theme the parts that read the same in either mode.\n */\ninterface ChartTheme {\n  color: string[];\n  textStyle: { fontFamily: string };\n}\n\n/**\n * AppKit's categorical chart palette (`--chart-cat-1` .. `--chart-cat-8` from\n * `@databricks/appkit-ui`), as hex. Server-rendered chart specs cannot read the\n * browser's CSS custom properties, so the values are mirrored here to keep a\n * generated chart visually consistent with the AppKit-styled UI around it.\n * Keep in sync with AppKit's stylesheet if it changes.\n */\nconst APPKIT_CHART_PALETTE = [\n  \"#2463EB\", // blue\n  \"#2EB88A\", // teal\n  \"#AB47BD\", // purple\n  \"#F69E23\", // amber\n  \"#DD2C4D\", // rose\n  \"#1BA3BB\", // cyan\n  \"#9B61D1\", // lavender\n  \"#34B262\", // emerald\n] as const;\n\n/**\n * Expand two brand hex colors into a legible categorical cycle. Echarts\n * repeats the `color` array across series / categories, so a good default\n * needs several distinct hues, not two. We seed with the brand primary and\n * accent (the identity colors) and follow with AppKit's own categorical chart\n * palette, so multi-series / many-slice charts stay readable and match the\n * surrounding AppKit UI while the first one or two marks land on-brand.\n */\nfunction brandColorCycle(primary: string, accent: string): string[] {\n  const spread = APPKIT_CHART_PALETTE;\n  const seen = new Set<string>();\n  return [primary, accent, ...spread].filter((c) => {\n    const key = c.toLowerCase();\n    if (seen.has(key)) return false;\n    seen.add(key);\n    return true;\n  });\n}\n\n/**\n * Derive an Echarts {@link ChartTheme} from a brand context: the primary +\n * accent colors seed the series cycle and the sans stack becomes the base\n * font. Text colors are the renderer's job - see {@link ChartTheme}.\n */\nfunction brandChartTheme(brand: BrandContext): ChartTheme {\n  return {\n    color: brandColorCycle(brand.colors.primary, brand.colors.accent),\n    textStyle: { fontFamily: brand.typography.sans },\n  };\n}\n\n/* ----------------------------- echarts expansion ----------------------------- */\n\ntype NamedSlice = { name: string; value: number };\ntype ScatterPoint = [number, number];\ntype HeatmapCell = [number, number, number];\n\n/** Keep only `{name, value}` slices; drop nulls / bare numbers / tuples. */\nfunction namedSlices(data: ChartPlan[\"series\"][number][\"data\"]): NamedSlice[] {\n  return data.filter(\n    (d): d is NamedSlice => d !== null && typeof d === \"object\" && !Array.isArray(d),\n  );\n}\n\n/** Keep only finite numbers (category / radar / waterfall series). */\nfunction numericPoints(data: ChartPlan[\"series\"][number][\"data\"]): number[] {\n  return data.filter((d): d is number => typeof d === \"number\" && Number.isFinite(d));\n}\n\n/** Keep only `[x, y]` scatter tuples. */\nfunction scatterPoints(data: ChartPlan[\"series\"][number][\"data\"]): ScatterPoint[] {\n  return data.filter(\n    (d): d is ScatterPoint => Array.isArray(d) && d.length === 2,\n  ) as ScatterPoint[];\n}\n\n/** Keep only `[xIndex, yIndex, value]` heatmap cells. */\nfunction heatmapCells(data: ChartPlan[\"series\"][number][\"data\"]): HeatmapCell[] {\n  return data.filter((d): d is HeatmapCell => Array.isArray(d) && d.length === 3) as HeatmapCell[];\n}\n\n/**\n * Resolve a heatmap's cells and row labels from either shape the\n * planner may produce.\n *\n * The documented shape is ONE series of `[xIndex, yIndex, value]`\n * triples, but index arithmetic is exactly the kind of bookkeeping a\n * fast model gets wrong, and the failure is silent (every cell is\n * dropped and the grid renders empty). So the row-per-series shape it\n * already produces reliably for bar charts - one series per matrix\n * row, numbers aligned to `categories` - is accepted too and turned\n * into triples here.\n *\n * Row order reads top-to-bottom: Echarts' category y-axis counts index\n * 0 from the BOTTOM, so a row-derived matrix reverses both the axis\n * labels and the row indices, putting the first series at the top the\n * way the model listed it.\n */\nfunction heatmapMatrix(plan: ChartPlan): { cells: HeatmapCell[]; yCategories: string[] } {\n  const triples = heatmapCells(plan.series[0]?.data ?? []);\n  if (triples.length > 0) {\n    return { cells: triples, yCategories: plan.yCategories ?? [] };\n  }\n  const rows = plan.series.map((s) => ({ name: s.name, values: numericPoints(s.data) }));\n  const labels = plan.yCategories ?? rows.map((r) => r.name);\n  const lastRow = rows.length - 1;\n  return {\n    cells: rows.flatMap((row, rowIndex) =>\n      row.values.map((value, columnIndex): HeatmapCell => [columnIndex, lastRow - rowIndex, value]),\n    ),\n    yCategories: [...labels].reverse(),\n  };\n}\n\n/** Sequential light-to-brand ramp for heatmap intensity. */\nconst HEATMAP_RAMP = [\"#EAF1FE\", \"#9CBDF7\", \"#4C86EE\", \"#2463EB\", \"#14387F\"];\n\n/** Above this many cells, printed values overlap and are suppressed. */\nconst HEATMAP_LABEL_MAX_CELLS = 60;\n\n/** Rising step fill (emerald) and falling step fill (rose). */\nconst WATERFALL_INCREASE_COLOR = \"#2EB88A\";\nconst WATERFALL_DECREASE_COLOR = \"#DD2C4D\";\n\n/** Series names the waterfall expansion emits. */\nconst WATERFALL_HELPER_NAME = \"Running total\";\nconst WATERFALL_INCREASE_NAME = \"Increase\";\nconst WATERFALL_DECREASE_NAME = \"Decrease\";\n\n/**\n * A model asked for a bridge often builds the running total itself and\n * hands back a cumulative-base series alongside the deltas - which\n * renders as two plain bar series, not a waterfall (the base bars are\n * the tall ones). The base is recognizable by name, so it is dropped\n * here and the running total recomputed from the deltas.\n */\nconst WATERFALL_BASE_NAME = /\\b(base|cumulative|running|helper|total|start(ing)?)\\b/i;\n\n/**\n * Pick the signed-delta series out of a waterfall plan, ignoring any\n * cumulative-base series the planner built by hand\n * ({@link WATERFALL_BASE_NAME}). Falls back to the first series when\n * every name looks like a base, since dropping them all would leave\n * nothing to plot.\n */\nfunction waterfallDeltaSeries(\n  series: ChartPlan[\"series\"],\n): ChartPlan[\"series\"][number] | undefined {\n  return series.find((s) => !WATERFALL_BASE_NAME.test(s.name)) ?? series[0];\n}\n\n/**\n * Build the stacked transparent-base + increase + decrease series that\n * Echarts uses for a waterfall (it has no native waterfall type).\n * Values are signed deltas; the transparent helper carries the running\n * total so each visible bar starts where the previous one ended.\n *\n * The helper is `silent`, so with an item-triggered tooltip it is\n * invisible to both the eye and the pointer - the alternative, an axis\n * tooltip that hides the helper row, needs a function formatter, and\n * this spec has to survive JSON serialization to the browser.\n */\nfunction waterfallSeries(values: number[]): Array<Record<string, unknown>> {\n  const helpers: number[] = [];\n  const increases: Array<number | \"-\"> = [];\n  const decreases: Array<number | \"-\"> = [];\n  let cumulative = 0;\n  for (const value of values) {\n    if (value >= 0) {\n      helpers.push(cumulative);\n      increases.push(value);\n      decreases.push(\"-\");\n    } else {\n      helpers.push(cumulative + value);\n      increases.push(\"-\");\n      decreases.push(-value);\n    }\n    cumulative += value;\n  }\n  const transparent = { borderColor: \"transparent\", color: \"transparent\" };\n  return [\n    {\n      name: WATERFALL_HELPER_NAME,\n      type: \"bar\",\n      stack: \"total\",\n      silent: true,\n      itemStyle: transparent,\n      emphasis: { itemStyle: transparent },\n      data: helpers,\n    },\n    {\n      name: WATERFALL_INCREASE_NAME,\n      type: \"bar\",\n      stack: \"total\",\n      itemStyle: { color: WATERFALL_INCREASE_COLOR },\n      data: increases,\n    },\n    {\n      name: WATERFALL_DECREASE_NAME,\n      type: \"bar\",\n      stack: \"total\",\n      itemStyle: { color: WATERFALL_DECREASE_COLOR },\n      data: decreases,\n    },\n  ];\n}\n\n/**\n * Expand a {@link ChartPlan} into a full Echarts `EChartsOption`\n * JSON. Centralized here so the planner agent only fills in the\n * compact plan shape; tooltip / animation / color / grid defaults\n * stay consistent across charts and are easy to tune without\n * retraining model behaviour.\n *\n * When `brand` is set, the resolved spec is themed with the brand's series\n * color cycle and base text style (see {@link brandChartTheme}); otherwise\n * Echarts' defaults apply.\n */\nexport function planToEchartsOption(\n  plan: ChartPlan,\n  fallbackTitle: string,\n  brand?: BrandContext,\n): Record<string, unknown> {\n  const baseTitle = plan.title ?? fallbackTitle;\n  const grid = { left: 48, right: 24, top: 56, bottom: 48, containLabel: true };\n  const theme = brand ? brandChartTheme(brand) : undefined;\n  const themed = (option: Record<string, unknown>): Record<string, unknown> =>\n    theme ? { ...theme, ...option } : option;\n  const title = { text: baseTitle, left: \"center\" };\n  const legend = { bottom: 0 };\n\n  if (plan.chartType === \"custom\") {\n    // The option arrives as a JSON STRING, not a nested object: this plan is\n    // the planner's provider-enforced structured output, and a free-form\n    // object becomes an unconstrained `additionalProperties` schema that\n    // strict OpenAI and Gemini endpoints reject - which would break EVERY\n    // chart, not just this one (same class of hazard as the `prefixItems`\n    // note on `chartDataPointSchema`). A malformed string costs one chart.\n    // Nothing here is eval'd; a string-valued Echarts formatter is a\n    // template, not code.\n    const option = json.parseRecord(plan.option);\n    if (!option) {\n      throw new Error('chartType \"custom\" needs an `option` holding a JSON object');\n    }\n    // Title is the one default worth filling: every other branch guarantees\n    // one and the renderer reserves grid space for it. A title the model set\n    // wins, as does every other field it declared.\n    return themed({ title, ...option });\n  }\n\n  if (plan.chartType === \"pie\" || plan.chartType === \"funnel\" || plan.chartType === \"treemap\") {\n    const slices = namedSlices(plan.series[0]?.data ?? []);\n    const seriesType = plan.chartType;\n    return themed({\n      title,\n      tooltip: { trigger: \"item\" },\n      legend: seriesType === \"treemap\" ? undefined : legend,\n      series: [\n        {\n          name: plan.series[0]?.name ?? baseTitle,\n          type: seriesType,\n          ...(seriesType === \"pie\" ? { radius: [\"35%\", \"65%\"] } : {}),\n          ...(seriesType === \"funnel\" ? { sort: \"descending\" } : {}),\n          data: slices,\n        },\n      ],\n    });\n  }\n\n  if (plan.chartType === \"scatter\") {\n    // Echarts crashes on null scatter points - keep only valid\n    // `[x, y]` tuples. Bare numbers / objects / nulls from a\n    // mismatched plan get dropped silently.\n    return themed({\n      title,\n      tooltip: { trigger: \"item\" },\n      legend,\n      grid,\n      xAxis: { type: \"value\", name: plan.xAxisLabel },\n      yAxis: { type: \"value\", name: plan.yAxisLabel },\n      series: plan.series.map((s) => ({\n        name: s.name,\n        type: \"scatter\",\n        data: scatterPoints(s.data),\n      })),\n    });\n  }\n\n  if (plan.chartType === \"heatmap\") {\n    const { cells, yCategories } = heatmapMatrix(plan);\n    const values = cells.map((c) => c[2]);\n    const min = values.length > 0 ? Math.min(...values) : 0;\n    const max = values.length > 0 ? Math.max(...values) : 1;\n    return themed({\n      title,\n      tooltip: { position: \"top\" },\n      // The visualMap ramp sits below the plot, so the grid gives up\n      // more bottom room than an axis-only chart needs.\n      grid: { ...grid, bottom: 72 },\n      xAxis: {\n        type: \"category\",\n        data: plan.categories ?? [],\n        name: plan.xAxisLabel,\n        splitArea: { show: true },\n      },\n      yAxis: {\n        type: \"category\",\n        data: yCategories,\n        name: plan.yAxisLabel,\n        splitArea: { show: true },\n      },\n      visualMap: {\n        // Echarts hides every cell when min === max (a uniform matrix),\n        // so a degenerate range is widened by one.\n        min,\n        max: max > min ? max : min + 1,\n        calculable: true,\n        orient: \"horizontal\",\n        left: \"center\",\n        bottom: 8,\n        inRange: { color: HEATMAP_RAMP },\n      },\n      series: [\n        {\n          name: plan.series[0]?.name ?? baseTitle,\n          type: \"heatmap\",\n          data: cells,\n          // Printed cell values are unreadable once the grid is dense.\n          label: { show: cells.length <= HEATMAP_LABEL_MAX_CELLS },\n          emphasis: { itemStyle: { shadowBlur: 10, shadowColor: \"rgba(0, 0, 0, 0.3)\" } },\n        },\n      ],\n    });\n  }\n\n  if (plan.chartType === \"radar\") {\n    const indicators = (plan.categories ?? []).map((name, index) => {\n      const peak = Math.max(\n        0,\n        ...plan.series.map((s) => {\n          const nums = numericPoints(s.data);\n          return nums[index] ?? 0;\n        }),\n      );\n      return { name, max: peak > 0 ? peak : 1 };\n    });\n    return themed({\n      title,\n      tooltip: { trigger: \"item\" },\n      legend,\n      radar: { indicator: indicators },\n      series: [\n        {\n          type: \"radar\",\n          data: plan.series.map((s) => ({\n            name: s.name,\n            value: numericPoints(s.data),\n          })),\n        },\n      ],\n    });\n  }\n\n  if (plan.chartType === \"waterfall\") {\n    const values = numericPoints(waterfallDeltaSeries(plan.series)?.data ?? []);\n    return themed({\n      title,\n      // Item-triggered so the transparent `silent` offset bars never\n      // surface in a tooltip (see `waterfallSeries`).\n      tooltip: { trigger: \"item\" },\n      // Only the two visible steps belong in the legend.\n      legend: { ...legend, data: [WATERFALL_INCREASE_NAME, WATERFALL_DECREASE_NAME] },\n      grid,\n      xAxis: {\n        type: \"category\",\n        data: plan.categories ?? [],\n        name: plan.xAxisLabel,\n      },\n      yAxis: { type: \"value\", name: plan.yAxisLabel },\n      series: waterfallSeries(values),\n    });\n  }\n\n  if (plan.chartType === \"horizontalBar\") {\n    return themed({\n      title,\n      tooltip: { trigger: \"axis\", axisPointer: { type: \"shadow\" } },\n      legend,\n      grid,\n      xAxis: { type: \"value\", name: plan.xAxisLabel },\n      yAxis: {\n        type: \"category\",\n        data: plan.categories ?? [],\n        name: plan.yAxisLabel,\n      },\n      series: plan.series.map((s) => ({\n        name: s.name,\n        type: \"bar\",\n        data: s.data,\n      })),\n    });\n  }\n\n  if (plan.chartType === \"combo\") {\n    const usesRightAxis = plan.series.some((s) => s.yAxisIndex === 1);\n    return themed({\n      title,\n      tooltip: { trigger: \"axis\" },\n      legend,\n      grid,\n      xAxis: {\n        type: \"category\",\n        data: plan.categories ?? [],\n        name: plan.xAxisLabel,\n      },\n      yAxis: usesRightAxis\n        ? [\n            { type: \"value\", name: plan.yAxisLabel },\n            { type: \"value\", name: undefined },\n          ]\n        : { type: \"value\", name: plan.yAxisLabel },\n      series: plan.series.map((s) => {\n        const mark = s.type ?? \"bar\";\n        const seriesType = mark === \"area\" ? \"line\" : mark;\n        return {\n          name: s.name,\n          type: seriesType,\n          data: s.data,\n          yAxisIndex: s.yAxisIndex ?? 0,\n          smooth: seriesType === \"line\",\n          ...(mark === \"area\" ? { areaStyle: {} } : {}),\n        };\n      }),\n    });\n  }\n\n  // bar / line / area share the same axis layout.\n  const isArea = plan.chartType === \"area\";\n  const seriesType = plan.chartType === \"bar\" ? \"bar\" : \"line\";\n  return themed({\n    title,\n    tooltip: { trigger: \"axis\" },\n    legend,\n    grid,\n    xAxis: {\n      type: \"category\",\n      data: plan.categories ?? [],\n      name: plan.xAxisLabel,\n    },\n    yAxis: { type: \"value\", name: plan.yAxisLabel },\n    series: plan.series.map((s) => ({\n      name: s.name,\n      type: seriesType,\n      data: s.data,\n      smooth: seriesType === \"line\",\n      ...(isArea ? { areaStyle: {} } : {}),\n    })),\n  });\n}\n\n/* ----------------------------- render_data tool ----------------------------- */\n\n/**\n * Build the `render_data` Mastra tool bound to the given plugin\n * config. Auto-wired as a system tool on every agent (see\n * `agents.ts`); per-agent tools can shadow it by registering a\n * same-named entry.\n *\n * Thin wrapper over {@link prepareChart} for callers that already\n * have a dataset in hand. Mints a `chartId` synchronously, caches\n * an empty placeholder, and kicks off the chart-planner in the\n * background. Returns the `chartId` plus its ready-to-copy `marker`; the host\n * UI resolves that marker through the plugin's `/embed/chart/:id` route.\n *\n * For Genie statement results, prefer the Genie agent's\n * `prepare_chart` tool, which accepts a `statement_id` and\n * resolves the rows lazily.\n */\nexport function buildRenderDataTool(config: MastraPluginConfig) {\n  return createTool({\n    id: \"render_data\",\n    description: string.toDescription([\n      `\n        Submit a tabular dataset for inline rendering as a chart in\n        the user's view. Pass a title, the raw rows (array of objects\n        keyed by column name), and an optional one-line description\n        of the insight to highlight. Returns \\`chartId\\` plus the\n        complete \\`marker\\`; copy the returned marker VERBATIM onto\n        its own line where the chart should render. Never construct,\n        alter, or invent a chart marker yourself.\n      `,\n      `\n        Placement contract: embed the returned \\`marker\\` on its own\n        line (blank lines above and below) wherever you want the chart\n        to appear in your reply. The chart resolves\n        asynchronously - the tool returns the id immediately and the\n        host UI fetches the chart from the cache once the planner\n        lands. You can call \\`render_data\\` multiple times in the\n        same turn (the tool is parallel-safe) and interleave the\n        markers with prose so each chart sits next to its\n        commentary.\n      `,\n      `\n        Use whenever a SQL row set, API response, or hand-built\n        dataset would land better as a picture than as a list or\n        table. Cap input at a few hundred rows; sample or aggregate\n        larger datasets first.\n      `,\n    ]),\n    inputSchema: chartPlannerRequestSchema,\n    outputSchema: chartToolOutputSchema,\n    execute: async (input, ctxRaw) => {\n      const { title, description, data } = input as ChartPlannerRequest;\n      const ctx = ctxRaw as { requestContext?: RequestContext } | undefined;\n      return prepareChart({\n        config,\n        userKey: resolveUserKey(ctx?.requestContext),\n        title,\n        ...(description ? { description } : {}),\n        resolveData: () => Promise.resolve({ rows: data }),\n        ...(ctx?.requestContext ? { requestContext: ctx.requestContext } : {}),\n      });\n    },\n  });\n}\n"]}