@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/chart.js

@@ -0,0 +1,638 @@
+/**
+ * Chart planner + chart cache.
+ *
+ * Self-contained chart subsystem with two layers:
+ *
+ *   1. Inner planner agent (private). Pure dataset-in /
+ *      `EChartsOption`-out brain. Driven by {@link prepareChart};
+ *      callers never instantiate it directly.
+ *   2. {@link prepareChart}: orchestration on top of the planner.
+ *      Mints a `chartId`, caches an empty `{ chartId }` record
+ *      synchronously, then resolves the dataset and runs the
+ *      planner in the background. The terminal entry settles with
+ *      either `result` (success) or `error` (failure). Both
+ *      undefined means the entry is still processing.
+ *
+ * The cache surface ({@link fetchChart}) is the only state the
+ * HTTP route and the chart-producing tools share. `prepareChart`
+ * is dataset-agnostic - callers supply a `resolveData` callback
+ * that fetches the rows however they like (Genie statement, inline
+ * dataset, custom API). The module has no knowledge of Genie or
+ * statement ids; those concerns live in the tools that wrap it.
+ *
+ * Wire-format schemas live in `@dbx-tools/shared-mastra` so
+ * the demo client and any other UI consumer share the exact same
+ * shape this module reads and writes.
+ *
+ * @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 { model } from "@dbx-tools/shared-model";
+import { Agent } from "@mastra/core/agent";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { resolveUserKey } from "./config.js";
+import { buildModel } from "./model.js";
+const logger = log.logger("mastra/chart");
+/* ------------------------------ constants ------------------------------ */
+/**
+ * TTL for cached chart entries. One hour balances "long enough for
+ * the host UI to fetch the chart well after the model finished
+ * talking" against "short enough that abandoned chart ids don't
+ * pin storage". Matches the typical Databricks OBO token lifetime
+ * so any data re-resolution stays inside the original auth window.
+ */
+const CHART_CACHE_TTL_SEC = 60 * 60;
+/** Cache namespace; keeps the chart keyspace tidy. */
+const CHART_CACHE_NAMESPACE = "mastra:chart";
+/** Default server-side long-poll budget for {@link fetchChart}. */
+const DEFAULT_FETCH_TIMEOUT_MS = 60_000;
+/** Default inter-poll sleep for {@link fetchChart}. */
+const DEFAULT_FETCH_INTERVAL_MS = 250;
+/** Stable text stored on a chart entry whose planner run failed. */
+const CHART_FAILED_MESSAGE = "Chart generation failed";
+/* ------------------------------- schemas ------------------------------- */
+/**
+ * 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.
+ *
+ * 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
+ *      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.
+ *   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
+ *      taking down the entire chart with a
+ *      `Structured output validation failed` error.
+ */
+const chartDataPointSchema = z
+    .preprocess((v) => {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === "number")
+        return Number.isFinite(v) ? v : null;
+    if (typeof v === "string") {
+        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;
+    }
+    if (typeof v === "object" && v !== null && "value" in v) {
+        const obj = v;
+        const val = typeof obj.value === "number" ? obj.value : Number(obj.value);
+        if (!Number.isFinite(val))
+            return null;
+        // Coerce numeric / boolean / nullish names to strings so a
+        // pie slice keyed on a year (`2024`) or category id is
+        // accepted without round-tripping through the catch arm.
+        const rawName = obj.name;
+        const name = typeof rawName === "string" ? rawName : rawName == null ? "" : String(rawName);
+        return { name, value: val };
+    }
+    return null;
+}, 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),
+    z.object({ name: z.string(), value: z.number() }),
+]))
+    .catch(null);
+/**
+ * Compact, model-friendly representation of an Echarts spec. The
+ * planner agent emits this; {@link planToEchartsOption} expands it
+ * into a real `EChartsOption` JSON. Two layers because letting the
+ * model fill in a fully-typed `EChartsOption` is brittle (hundreds
+ * of optional fields, deep unions, version-dependent shapes). A
+ * small "chart plan" schema is much more reliable for a fast model
+ * and keeps animation / tooltip / styling defaults consistent
+ * across charts.
+ */
+export const chartPlanSchema = z.object({
+    chartType: wire.ChartTypeSchema,
+    title: z
+        .string()
+        .optional()
+        .describe(string.toDescription(`
+        Short title shown above the chart. Optional; defaults to the
+        \`title\` argument the caller passed in.
+      `)),
+    xAxisLabel: z
+        .string()
+        .optional()
+        .describe(string.toDescription(`
+        Axis label below the chart. Used for bar / line / area / scatter;
+        ignored for pie.
+      `)),
+    yAxisLabel: z
+        .string()
+        .optional()
+        .describe(string.toDescription(`
+        Axis label to the left of the chart. Used for bar / line / area /
+        scatter; ignored for pie.
+      `)),
+    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\`).
+      `)),
+    series: z
+        .array(z.object({
+        name: z.string().describe(string.toDescription(`
+            Legend name for this series.
+          `)),
+        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.
+          `)),
+    }))
+        .min(1)
+        .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.
+      `)),
+});
+/**
+ * Canonical planner input shape. Tools that source rows from an
+ * inline dataset (`render_data`) use it as their `inputSchema`
+ * verbatim; tools that resolve rows from a remote (`prepare_chart`
+ * over a Genie statement) `omit({ data })` and `extend` with their
+ * own identifier field, so the field-level `.describe()` text
+ * stays a single source of truth. Server-only - the UI never
+ * sees a planner request, only the resolved {@link Chart}.
+ */
+export const chartPlannerRequestSchema = z.object({
+    title: z.string().describe(string.toDescription(`
+        Concise title shown above the chart (e.g. "Top 10 SKUs by Revenue").
+      `)),
+    description: z
+        .string()
+        .optional()
+        .describe(string.toDescription(`
+        One-line intent the chart-planner uses when picking a chart type
+        and axis encodings (e.g. "compare quarterly revenue across
+        regions", "highlight the steep drop after position 5"). Not shown
+        to the user.
+      `)),
+    data: z
+        .array(z.record(z.string(), z.unknown()))
+        .nonempty("Data must contain at least one row")
+        .readonly()
+        .describe(string.toDescription(`
+        Tabular dataset to chart. One object per row, keyed by column
+        name. Values may be strings, numbers, booleans, or null. The
+        chart-planner decides which columns are categories vs. numeric
+        series. Cap at a few hundred rows for legibility; sample /
+        aggregate larger datasets first.
+      `)),
+});
+/* --------------------------- planner instructions --------------------------- */
+/**
+ * Format {@link wire.ChartTypeSchema}'s variants as a single
+ * human-friendly string of `` `<value>` for <description> ``
+ * clauses joined by semicolons, drawn from each variant's own
+ * `.describe()` so the planner prompt stays in lock-step with
+ * the schema by construction.
+ */
+function formatChartTypePicker() {
+    return wire.ChartTypeSchema.options
+        .map((opt) => `\`${opt.value}\` for ${opt.description ?? ""}`)
+        .join("; ");
+}
+/**
+ * System prompt for the inner chart-planning agent. Tuned for a
+ * fast-tier model (Haiku, GPT-5-mini, Gemini Flash Lite).
+ */
+const CHART_PLANNER_INSTRUCTIONS = string.toDescription(`
+  You design Apache Echarts visualizations. The user gives you a
+  tabular dataset (rows of objects) plus a title and an optional
+  description of the intent. You produce a small chart plan (chart
+  type, axis labels, categories, series) that best conveys the data.
+
+  Decision guide. Pick the chart type whose data shape matches the
+  dataset and the user's intent: ${formatChartTypePicker()}.
+
+  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.
+
+  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 pie: pick the category column for slice names and one numeric
+  column for slice values. Emit a single series.
+
+  For scatter: pick two numeric columns and emit \`[x, y]\` tuples in a
+  single series.
+
+  Keep series names human-readable (use the column name; title case it
+  lightly if needed). Keep titles concise; do not repeat the user's
+  title in xAxisLabel / yAxisLabel.
+`);
+/* ----------------------------- planner agent ----------------------------- */
+/**
+ * One planner `Agent` per plugin config. Cached on config object
+ * identity so callers can `prepareChart({ config, ... })` from a
+ * hot path without paying the Agent-constructor cost every call.
+ * `WeakMap` lets retired configs (e.g. test reconfigurations)
+ * release their agent without manual eviction.
+ */
+const plannerAgents = new WeakMap();
+function getPlannerAgent(config) {
+    let agent = plannerAgents.get(config);
+    if (!agent) {
+        agent = new Agent({
+            id: "chart_planner",
+            name: "Chart Planner",
+            description: "Picks chart type and axis encodings for a dataset.",
+            instructions: CHART_PLANNER_INSTRUCTIONS,
+            model: ({ requestContext }) => buildModel(config, requestContext, { modelClass: model.ModelClass.ChatFast }),
+        });
+        plannerAgents.set(config, agent);
+    }
+    return agent;
+}
+/**
+ * Run the planner against `request` and return the resolved
+ * Echarts spec. Throws on planner failure - {@link prepareChart}
+ * catches and stashes the error in the cache entry.
+ */
+async function runChartPlanner(config, request, options = {}) {
+    const { title, description, data } = request;
+    const { requestContext, abortSignal } = options;
+    const prompt = string.toDescription({
+        Title: title,
+        ...(description ? { Description: description } : {}),
+        "Dataset (JSON, one row per object)": JSON.stringify(data, null, 2),
+    });
+    const result = await getPlannerAgent(config).generate(prompt, {
+        structuredOutput: { schema: chartPlanSchema },
+        ...(requestContext ? { requestContext } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+    });
+    const plan = chartPlanSchema.parse(result.object);
+    const option = planToEchartsOption(plan, title, config.brand);
+    return { chartType: plan.chartType, option };
+}
+/* ------------------------------ cache helpers ------------------------------ */
+/**
+ * Build the canonical cache key for a `chartId` owned by `userKey`.
+ *
+ * The identity is part of the key, not a filter applied after the read, so a
+ * chart id guessed or copied from another user's transcript resolves to a
+ * different key and simply misses. That miss is what the HTTP route turns into
+ * a 404, which is also the answer that leaks the least.
+ */
+async function chartCacheKey(chartId, userKey) {
+    return (await CacheManager.getInstance()).generateKey([CHART_CACHE_NAMESPACE, chartId], userKey);
+}
+/**
+ * Persist a {@link Chart} entry under its `chartId`, owned by `userKey`.
+ * Refreshes the TTL on every write. Cache-layer failures are logged and
+ * swallowed so background runners never throw into the
+ * unhandled-rejection stream.
+ */
+async function writeChart(entry, userKey) {
+    try {
+        const key = await chartCacheKey(entry.chartId, userKey);
+        await CacheManager.getInstanceSync().set(key, entry, {
+            ttl: CHART_CACHE_TTL_SEC,
+        });
+    }
+    catch (err) {
+        logger.warn("write-error", {
+            chartId: entry.chartId,
+            error: error.errorMessage(err),
+        });
+    }
+}
+/**
+ * Look up a chart `userKey` owns. Returns `undefined` on miss, on
+ * expiry, when another identity owns the id, or when the cache layer is
+ * unhealthy - never throws.
+ */
+async function readChart(chartId, userKey) {
+    try {
+        const key = await chartCacheKey(chartId, userKey);
+        const v = await CacheManager.getInstanceSync().get(key);
+        return v ?? undefined;
+    }
+    catch (err) {
+        logger.warn("read-error", {
+            chartId,
+            error: error.errorMessage(err),
+        });
+        return undefined;
+    }
+}
+/**
+ * Mint a `chartId`, cache an empty `{ chartId }` placeholder
+ * synchronously, and kick off a background task that resolves the
+ * dataset and runs the planner. Returns the `chartId` once the
+ * placeholder lands so the first {@link fetchChart} call always
+ * sees an entry (no spurious 404 race).
+ *
+ * The background task swallows its own failures and writes them
+ * as `error` entries, so callers never see a rejected promise.
+ * Cache state machine:
+ *
+ *   - just after this call returns: `{ chartId }` (processing)
+ *   - on planner success:           `{ chartId, result }`
+ *   - on data / planner failure:    `{ chartId, error }`
+ */
+export async function prepareChart(opts) {
+    const chartId = hash.id();
+    await writeChart({ chartId }, opts.userKey);
+    logger.debug("queued", { chartId });
+    // Fire-and-forget. Failures land in the cache as `error` entries;
+    // never escape into an unhandled rejection.
+    void runPrepareChart(chartId, opts);
+    return { chartId };
+}
+async function runPrepareChart(chartId, opts) {
+    const startedAt = Date.now();
+    try {
+        const data = await opts.resolveData(opts.signal);
+        if (data.rows.length === 0) {
+            throw new ExecutionError("Dataset has no rows; nothing to chart");
+        }
+        const result = await runChartPlanner(opts.config, {
+            title: opts.title ?? "Chart",
+            ...(opts.description ? { description: opts.description } : {}),
+            data: data.rows,
+        }, {
+            ...(opts.requestContext ? { requestContext: opts.requestContext } : {}),
+            ...(opts.signal ? { abortSignal: opts.signal } : {}),
+        });
+        await writeChart({ chartId, result }, opts.userKey);
+        logger.info("done", {
+            chartId,
+            chartType: result.chartType,
+            elapsedMs: Date.now() - startedAt,
+        });
+    }
+    catch (err) {
+        logger.warn("error", { chartId, error: error.errorMessage(err) });
+        // The entry's `error` is rendered in the chat, so only an AppKitError's
+        // own message travels; anything else could carry upstream provider detail.
+        const errText = err instanceof AppKitError ? err.message : CHART_FAILED_MESSAGE;
+        await writeChart({ chartId, error: errText }, opts.userKey);
+    }
+}
+/**
+ * Long-poll the chart cache until the entry settles (`result` or
+ * `error` set), the entry is missing, or the server-side timeout
+ * elapses.
+ *
+ * Returns:
+ *   - the resolved {@link Chart} when it settled, errored, or
+ *     stayed in processing past `timeoutMs` (so the client can
+ *     re-poll);
+ *   - `undefined` when the entry is missing, expired, or owned by
+ *     another identity (the consumer should treat as 404).
+ *
+ * `signal` lets the caller cancel ahead of timeout (e.g. the HTTP
+ * request closed). Cancellation propagates to the inter-poll sleep
+ * so the helper returns immediately.
+ */
+export async function fetchChart(chartId, options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+    const intervalMs = options.intervalMs ?? DEFAULT_FETCH_INTERVAL_MS;
+    const deadline = Date.now() + timeoutMs;
+    let last;
+    while (true) {
+        options.signal?.throwIfAborted();
+        last = await readChart(chartId, options.userKey);
+        if (!last)
+            return undefined;
+        if (last.result !== undefined || last.error !== undefined)
+            return last;
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return last;
+        await async.sleep(Math.min(intervalMs, remaining), options.signal);
+    }
+}
+/**
+ * AppKit's categorical chart palette (`--chart-cat-1` .. `--chart-cat-8` from
+ * `@databricks/appkit-ui`), as hex. Server-rendered chart specs cannot read the
+ * browser's CSS custom properties, so the values are mirrored here to keep a
+ * generated chart visually consistent with the AppKit-styled UI around it.
+ * Keep in sync with AppKit's stylesheet if it changes.
+ */
+const APPKIT_CHART_PALETTE = [
+    "#2463EB", // blue
+    "#2EB88A", // teal
+    "#AB47BD", // purple
+    "#F69E23", // amber
+    "#DD2C4D", // rose
+    "#1BA3BB", // cyan
+    "#9B61D1", // lavender
+    "#34B262", // emerald
+];
+/**
+ * Expand two brand hex colors into a legible categorical cycle. Echarts
+ * repeats the `color` array across series / categories, so a good default
+ * needs several distinct hues, not two. We seed with the brand primary and
+ * accent (the identity colors) and follow with AppKit's own categorical chart
+ * palette, so multi-series / many-slice charts stay readable and match the
+ * surrounding AppKit UI while the first one or two marks land on-brand.
+ */
+function brandColorCycle(primary, accent) {
+    const spread = APPKIT_CHART_PALETTE;
+    const seen = new Set();
+    return [primary, accent, ...spread].filter((c) => {
+        const key = c.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/**
+ * 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.
+ */
+function brandChartTheme(brand) {
+    return {
+        color: brandColorCycle(brand.colors.primary, brand.colors.accent),
+        textStyle: { fontFamily: brand.typography.sans, color: brand.colors.foreground },
+    };
+}
+/* ----------------------------- echarts expansion ----------------------------- */
+/**
+ * Expand a {@link ChartPlan} into a full Echarts `EChartsOption`
+ * JSON. Centralized here so the planner agent only fills in the
+ * compact plan shape; tooltip / animation / color / grid defaults
+ * stay consistent across charts and are easy to tune without
+ * retraining model behaviour.
+ *
+ * When `brand` is set, the resolved spec is themed with the brand's series
+ * color cycle and base text style (see {@link brandChartTheme}); otherwise
+ * Echarts' defaults apply.
+ */
+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));
+        return themed({
+            title: { text: baseTitle, left: "center" },
+            tooltip: { trigger: "item" },
+            legend: { bottom: 0 },
+            series: [
+                {
+                    name: plan.series[0]?.name ?? baseTitle,
+                    type: "pie",
+                    radius: ["35%", "65%"],
+                    data: slices,
+                },
+            ],
+        });
+    }
+    if (plan.chartType === "scatter") {
+        // Echarts crashes on null scatter points - keep only valid
+        // `[x, y]` tuples. Bare numbers / objects / nulls from a
+        // mismatched plan get dropped silently.
+        return themed({
+            title: { text: baseTitle, left: "center" },
+            tooltip: { trigger: "item" },
+            legend: { bottom: 0 },
+            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),
+            })),
+        });
+    }
+    // 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" },
+        tooltip: { trigger: "axis" },
+        legend: { bottom: 0 },
+        grid,
+        xAxis: {
+            type: "category",
+            data: plan.categories ?? [],
+            name: plan.xAxisLabel,
+        },
+        yAxis: { type: "value", name: plan.yAxisLabel },
+        series: plan.series.map((s) => ({
+            name: s.name,
+            type: seriesType,
+            data: s.data,
+            smooth: seriesType === "line",
+            ...(isArea ? { areaStyle: {} } : {}),
+        })),
+    });
+}
+/* ----------------------------- render_data tool ----------------------------- */
+/**
+ * Build the `render_data` Mastra tool bound to the given plugin
+ * config. Auto-wired as a system tool on every agent (see
+ * `agents.ts`); per-agent tools can shadow it by registering a
+ * same-named entry.
+ *
+ * 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.
+ *
+ * For Genie statement results, prefer the Genie agent's
+ * `prepare_chart` tool, which accepts a `statement_id` and
+ * resolves the rows lazily.
+ */
+export function buildRenderDataTool(config) {
+    return createTool({
+        id: "render_data",
+        description: string.toDescription([
+            `
+        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.
+      `,
+            `
+        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
+        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
+        same turn (the tool is parallel-safe) and interleave the
+        markers with prose so each chart sits next to its
+        commentary.
+      `,
+            `
+        Use whenever a SQL row set, API response, or hand-built
+        dataset would land better as a picture than as a list or
+        table. Cap input at a few hundred rows; sample or aggregate
+        larger datasets first.
+      `,
+        ]),
+        inputSchema: chartPlannerRequestSchema,
+        outputSchema: wire.ChartSchema.pick({ chartId: true }),
+        execute: async (input, ctxRaw) => {
+            const { title, description, data } = input;
+            const ctx = ctxRaw;
+            return prepareChart({
+                config,
+                userKey: resolveUserKey(ctx?.requestContext),
+                title,
+                ...(description ? { description } : {}),
+                resolveData: () => Promise.resolve({ rows: data }),
+                ...(ctx?.requestContext ? { requestContext: ctx.requestContext } : {}),
+            });
+        },
+    });
+}
+//# 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\";\nimport { buildModel } from \"./model\";\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"]}