@dbx-tools/appkit-mastra 0.1.58 → 0.1.67

package/dist/src/agents.js

@@ -1,470 +0,0 @@
-/**
- * Agent registration for the Mastra AppKit plugin.
- *
- * Mirrors the shape of the AppKit `agents` plugin (`config.agents` map
- * of {@link MastraAgentDefinition}, dual-form `tools` accepting a plain
- * record or a `(plugins) => tools` callback). Resolves each definition
- * into a Mastra `Agent` instance during plugin setup; user-supplied
- * tool callbacks are invoked exactly once with a typed
- * {@link MastraPlugins} map built from registered sibling plugins.
- *
- * When no agents are registered the plugin falls back to a single
- * built-in analyst so the bare `mastra()` call still mounts a working
- * streamable agent for demos.
- */
-import { appkitUtils, logUtils, stringUtils } from "@dbx-tools/shared";
-import { Agent } from "@mastra/core/agent";
-import { createTool } from "@mastra/core/tools";
-import { buildRenderDataTool } from "./chart.js";
-import { buildGenieToolkitProvider, resolveGenieSpaces } from "./genie.js";
-import { buildModel, FALLBACK_MODEL_IDS } from "./model.js";
-import { ResultProcessor } from "./processor.js";
-import { stripStaleChartsProcessor } from "./processors/strip-stale-charts.js";
-/** Re-export of Mastra's native `createTool` for full-feature access. */
-export { createTool } from "@mastra/core/tools";
-/**
- * AppKit-shaped tool factory. Lets users mix-and-match tools across
- * AppKit's `agents` plugin and `mastra` with a single import:
- *
- * ```ts
- * import { tool } from "@dbx-tools/appkit-mastra";
- * import { z } from "zod";
- *
- * get_weather: tool({
- *   description: "Weather",
- *   schema: z.object({ city: z.string() }),
- *   execute: async ({ city }) => `Sunny in ${city}`,
- * }),
- * ```
- *
- * Maps onto Mastra's `createTool`:
- *
- * - `description` -> `description` (required)
- * - `schema` -> `inputSchema` (optional)
- * - `execute(input)` -> `execute(input, ctx)` - Mastra already calls
- *   the first arg with the parsed inputs, so the body shape is
- *   identical. The Mastra `context` arg is forwarded as the second
- *   parameter when the caller declares it.
- * - `id`: optional. Defaults to a stable identifier derived from
- *   `description` (slugified, with a short hash suffix for
- *   uniqueness). Pass an explicit `id` when you need a stable string
- *   for tracing or MCP exposure.
- *
- * Reach for {@link createTool} when you need Mastra-only fields
- * (`outputSchema`, `suspendSchema`, `requireApproval`, `mcp`, etc.).
- */
-export function tool(opts) {
-    const id = opts.id ?? deriveToolId(opts.description);
-    return createTool({
-        id,
-        description: opts.description,
-        ...(opts.schema ? { inputSchema: opts.schema } : {}),
-        execute: opts.execute,
-    });
-}
-/**
- * Build a deterministic Mastra tool id from a description.
- * Delegates to {@link stringUtils.toUniqueSlug}: slug + always-on
- * 6-char FNV-1a base-32 suffix so two tools with the same leading
- * words don't collide in traces. Stable across runs.
- */
-function deriveToolId(description) {
-    return stringUtils.toUniqueSlug(description, { fallbackPrefix: "tool" });
-}
-/**
- * Identity helper that brands a definition as a Mastra agent. Mirrors
- * AppKit's `createAgent(def)` so the registration shape matches:
- *
- * ```ts
- * const support = createAgent({
- *   instructions: "...",
- *   model: "databricks-claude-sonnet-4-6",
- *   tools(plugins) { return { ... }; },
- * });
- * ```
- *
- * Returns the definition unchanged - the wrapper exists only to anchor
- * type inference and to match the AppKit API surface.
- */
-export function createAgent(def) {
-    return def;
-}
-/** Fallback agent id used when `config.agents` is omitted entirely. */
-export const FALLBACK_AGENT_ID = "default";
-/**
- * Default per-turn step ceiling applied to every registered agent
- * when {@link MastraPluginConfig.agentMaxSteps} is unset. Sized to
- * fit a decomposed Genie turn (grounding + several `ask_genie`
- * calls + `prepare_chart` per dataset + the final-text reply) with
- * headroom for the model to chain a couple of follow-ups before
- * answering - well above Mastra's own `agent.generate` default of
- * 5, which would cut multi-step orchestration off mid-loop.
- */
-export const DEFAULT_AGENT_MAX_STEPS = 25;
-const FALLBACK_AGENT_INSTRUCTIONS = `You are a data analyst. The user will ask questions about
-business metrics and may share personal preferences you should remember across turns.
-
-Rules:
-
-1. Quote numbers exactly. Never invent data.
-2. When the user states a preference or durable fact about themselves
-   ("I'm in EU so use EUR", "always show me the SQL"), acknowledge that
-   you will remember it.
-3. If you don't have enough information to answer, ask a clarifying
-   question instead of guessing.`;
-/**
- * Style guardrails appended to every agent's `instructions` to curb
- * common LLM-isms (em dashes, emojis, sycophantic openers, excessive
- * hedging, throwaway closers). Appended rather than prepended so the
- * agent's role/context comes first; the model's recency bias then
- * helps the style rules dominate the response surface.
- *
- * Override globally via {@link MastraPluginConfig.styleInstructions}
- * (pass `false` to disable entirely, or a string to replace).
- */
-export const DEFAULT_STYLE_INSTRUCTIONS = [
-    "Output style:",
-    "",
-    "Use markdown formatting, including headings, lists, and code blocks.",
-    "Avoid lists and headers for short replies.",
-    "Plain prose.",
-    "Use hyphens (-) only. Never use em dashes or en dashes.",
-    "Never use emojis.",
-    "Skip openers like 'Great question', 'Absolutely', and 'I'd be happy to help'.",
-    "Skip closers like 'Let me know if you have any questions'.",
-    "Skip self-disclaimers like 'I should mention' and 'It's important to note'.",
-    "Answer directly.",
-    "Do not include a preamble before the actual answer.",
-    "Use lists and headers only when they clarify a multi-part answer.",
-].join("\n");
-/**
- * Resolve the style block to append to every agent's instructions.
- * Returns `null` when the caller opted out (`styleInstructions: false`).
- */
-function resolveStyleInstructions(config) {
-    if (config.styleInstructions === false)
-        return null;
-    if (typeof config.styleInstructions === "string") {
-        return config.styleInstructions;
-    }
-    return DEFAULT_STYLE_INSTRUCTIONS;
-}
-/**
- * Join an agent's bespoke instructions with the resolved style block.
- * Returns the bespoke text unchanged when the style block is disabled.
- */
-function composeInstructions(agentInstructions, style) {
-    if (!style)
-        return agentInstructions;
-    return `${agentInstructions.trimEnd()}\n\n${style}`;
-}
-/**
- * Resolve every entry in `config.agents` into a Mastra `Agent`
- * instance. When `config.agents` is omitted the plugin registers a
- * single built-in `default` analyst so the bare `mastra()` call still
- * yields a working agent.
- *
- * Per-agent tool callbacks are invoked once with a typed
- * {@link MastraPlugins} index built from registered sibling plugins
- * (currently `genie`; extend `MastraPlugins` to surface more).
- *
- * @throws when `config.defaultAgent` is set to an id that isn't in the
- *   resolved registry; this is a wiring bug, not a runtime condition.
- */
-export async function buildAgents(opts) {
-    const { config, context, memoryBuilder, log } = opts;
-    const definitions = resolveDefinitions(config);
-    const ids = Object.keys(definitions);
-    const defaultAgentId = config.defaultAgent ?? ids[0] ?? FALLBACK_AGENT_ID;
-    const plugins = buildPluginsMap(config, context);
-    // System-default ambient tools every agent gets out of the box.
-    // Currently just `render_data` for inline visualizations; the
-    // user can shadow it by including a same-named tool in their own
-    // `config.tools` or per-agent `tools`. Order in {@link resolveTools}
-    // is `system -> user-ambient -> per-agent`, last write wins.
-    const systemTools = {
-        render_data: buildRenderDataTool(config),
-    };
-    const ambientTools = { ...systemTools, ...(config.tools ?? {}) };
-    const style = resolveStyleInstructions(config);
-    // Default-on protection against the model copying turn-scoped
-    // chartIds from prior assistant tool results into the new
-    // turn's `[chart:<id>]` markers. Opt out per-plugin via
-    // `config.stripStaleCharts: false`.
-    const outputProcessors = [new ResultProcessor()];
-    const inputProcessors = config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor];
-    const agents = {};
-    for (const [id, def] of Object.entries(definitions)) {
-        const tools = await resolveTools(def.tools, plugins, ambientTools);
-        const memory = memoryBuilder?.forAgent(id, def);
-        agents[id] = new Agent({
-            id,
-            name: def.name ?? id,
-            ...(def.description !== undefined ? { description: def.description } : {}),
-            instructions: composeInstructions(def.instructions, style),
-            model: resolveModel(config, def.model),
-            defaultOptions: {
-                maxSteps: config.agentMaxSteps ?? DEFAULT_AGENT_MAX_STEPS,
-            },
-            tools,
-            ...(memory ? { memory } : {}),
-            inputProcessors,
-            outputProcessors,
-        });
-        // Surface the effective default model per agent so operators can
-        // see at a glance which endpoint each agent points at without
-        // having to fire a request and inspect a trace. The value is the
-        // *static* default; per-request overrides (header / query /
-        // body) and the workspace-catalogue fuzzy match still apply at
-        // call time.
-        log.info("agent registered", {
-            id,
-            name: def.name ?? id,
-            defaultModel: describeAgentDefaultModel(config, def),
-            tools: Object.keys(tools),
-        });
-    }
-    if (!agents[defaultAgentId]) {
-        throw new Error(`mastra: defaultAgent "${defaultAgentId}" not found in registered agents (${ids.join(", ") || "none"})`);
-    }
-    log.info("agents ready", { ids, defaultAgentId });
-    return { agents, defaultAgentId };
-}
-/**
- * Best-effort description of the *static* default model an agent will
- * resolve to at call time. Walks the same precedence ladder as
- * {@link resolveModel} / {@link buildModel}:
- *
- *   1. Per-agent `def.model` (string sugar -> the literal id;
- *      function / `DynamicArgument` -> `"<dynamic>"` because the
- *      resolver decides at call time).
- *   2. Plugin-level `config.defaultModel` (same rules).
- *   3. `DATABRICKS_SERVING_ENDPOINT_NAME` env var.
- *   4. First entry of `config.defaultModelFallbacks ?? FALLBACK_MODEL_IDS`.
- *
- * Used for the startup `agent registered` log so operators can see
- * which endpoint each agent points at by default. Per-request
- * overrides (`X-Mastra-Model` etc.) and the workspace-catalogue
- * fuzzy match are still applied at runtime.
- */
-function describeAgentDefaultModel(config, def) {
-    const effective = def.model ?? config.defaultModel;
-    if (typeof effective === "string")
-        return effective;
-    if (effective !== undefined)
-        return "<dynamic>";
-    return (process.env.DATABRICKS_SERVING_ENDPOINT_NAME ??
-        config.defaultModelFallbacks?.[0] ??
-        FALLBACK_MODEL_IDS[0]);
-}
-/**
- * Normalize `config.agents` into a `Record<id, definition>`. Accepts
- * any of the three shapes documented on
- * {@link MastraPluginConfig.agents}:
- *
- * - Record - returned as-is when non-empty.
- * - Single definition (detected via the required `instructions`
- *   field) - keyed by `slugify(def.name)` or `FALLBACK_AGENT_ID`.
- * - Array - keyed by `slugify(def.name)` or `agent_${i}`; duplicate
- *   slugs fail loudly so users know to set explicit names.
- *
- * Omitted or empty inputs fall back to a single built-in analyst so
- * the bare `mastra()` call still mounts a working chat route.
- */
-function resolveDefinitions(config) {
-    const input = config.agents;
-    if (!input)
-        return fallbackDefinitions();
-    if (Array.isArray(input)) {
-        if (input.length === 0)
-            return fallbackDefinitions();
-        const out = {};
-        input.forEach((def, i) => {
-            const key = deriveAgentKey(def, i);
-            if (out[key]) {
-                throw new Error(`mastra: duplicate agent id "${key}" derived from name "${def.name ?? ""}"; ` +
-                    `set unique \`name\`s on each definition`);
-            }
-            out[key] = def;
-        });
-        return out;
-    }
-    // Single-definition shorthand: an agent always has `instructions: string`,
-    // a record-of-agents never has that field directly.
-    if (typeof input.instructions === "string") {
-        const def = input;
-        const key = deriveAgentKey(def);
-        return { [key]: def };
-    }
-    const record = input;
-    if (Object.keys(record).length === 0)
-        return fallbackDefinitions();
-    return record;
-}
-/** Derive a registry id from a definition's `name`, with a fallback. */
-function deriveAgentKey(def, index) {
-    if (def.name) {
-        const slug = stringUtils.toIdentifier(def.name);
-        if (slug)
-            return slug;
-    }
-    return index === undefined ? FALLBACK_AGENT_ID : `agent_${index}`;
-}
-/** Built-in fallback registry used when `agents` is omitted / empty. */
-function fallbackDefinitions() {
-    return {
-        [FALLBACK_AGENT_ID]: {
-            name: "Default Agent",
-            instructions: FALLBACK_AGENT_INSTRUCTIONS,
-        },
-    };
-}
-/**
- * Pick the effective model spec for an agent. Fallback ladder, in
- * order:
- *
- *   1. Per-agent `def.model` (string sugar or `DynamicArgument`).
- *   2. Plugin-level `config.defaultModel` (string sugar or
- *      `DynamicArgument`) - mirrors AppKit's `agents({ defaultModel })`.
- *   3. The auto-resolver that mints user-scoped tokens against
- *      `/serving-endpoints` via {@link buildModel}.
- *
- * String values are treated as `modelId` sugar and threaded through
- * `buildModel`'s override hook so the runtime fuzzy matcher and the
- * per-request `X-Mastra-Model` override layer on top of the static
- * choice. Non-string `DynamicArgument`s are passed through verbatim;
- * callers that need full control over `providerId` / `headers` /
- * `modelId` bypass the resolver pipeline entirely.
- */
-function resolveModel(config, override) {
-    const effective = override ?? config.defaultModel;
-    if (effective === undefined) {
-        return ({ requestContext }) => buildModel(config, requestContext);
-    }
-    if (typeof effective === "string") {
-        const modelId = effective;
-        return ({ requestContext }) => buildModel(config, requestContext, { modelId });
-    }
-    return effective;
-}
-/**
- * Resolve a definition's `tools` field to a flat `MastraTools` record,
- * merging in plugin-level ambient tools (per-agent tools win on key
- * collision). Callback errors propagate verbatim so the original stack
- * survives - the caller already knows which agent was registering.
- */
-async function resolveTools(defTools, plugins, ambientTools) {
-    if (!defTools)
-        return { ...ambientTools };
-    const resolved = typeof defTools === "function" ? await defTools(plugins) : defTools;
-    return { ...ambientTools, ...resolved };
-}
-/**
- * Build the {@link MastraPlugins} runtime proxy handed to
- * `tools(plugins)` callbacks.
- *
- * Implemented as a `Proxy` over the AppKit plugin context so
- * `plugins.<name>` resolves at first access. Any sibling plugin that
- * implements AppKit's standard `ToolProvider` interface
- * (`toolkit(opts?)` + `executeAgentTool(name, args, signal?)`) is
- * auto-adapted into Mastra tools. Unknown names return `undefined`,
- * matching AppKit's `Plugins` semantics so `plugins.foo?.toolkit()`
- * remains safe in environments where `foo` isn't registered.
- *
- * `genie` is special-cased to swap the generic AppKit toolkit (which
- * runs `executeAgentTool` and only emits a single final `tool-result`
- * chunk per call) for the streaming-aware tools built by
- * {@link buildGenieProvider}. The streaming variant forwards each
- * Genie wire event (status, SQL, row counts, errors) out through the
- * Mastra `ctx.writer`, so the UI gets `tool-output` chunks in real
- * time instead of staring at a spinner for the full Genie round-trip.
- */
-function buildPluginsMap(config, context) {
-    const cache = new Map();
-    return new Proxy({}, {
-        get(_target, propName) {
-            if (typeof propName !== "string")
-                return undefined;
-            if (cache.has(propName))
-                return cache.get(propName) ?? undefined;
-            const provider = resolveProvider(config, context, propName);
-            cache.set(propName, provider);
-            return provider ?? undefined;
-        },
-    });
-}
-/**
- * Pick the right {@link MastraPluginToolkitProvider} for a sibling
- * plugin lookup. Returns the Genie agent-backed adapter when
- * the caller asks for `genie` AND at least one space is reachable
- * via {@link resolveGenieSpaces} (the explicit
- * `config.genieSpaces`, the registered AppKit `genie()` plugin's
- * `spaces` config, or the `DATABRICKS_GENIE_SPACE_ID` env var).
- * Falls back to the generic AppKit `ToolProvider` adapter for
- * every other plugin name. `config` is threaded through so the
- * Genie agent inherits the same model resolver / fallback
- * ladder the calling agents use.
- *
- * The Genie agent talks to Genie directly via `@dbx-tools/genie`
- * (`genieEventChat`) and the workspace
- * `statementExecution.getStatement` API. AppKit's stock `genie`
- * plugin is honored only for its resource manifest and `spaces`
- * config so existing `app.yaml` configs and `genie({ spaces })`
- * wiring keep working without change.
- */
-function resolveProvider(config, context, propName) {
-    if (propName === "genie") {
-        const spaces = resolveGenieSpaces(config, context);
-        if (Object.keys(spaces).length === 0)
-            return null;
-        return buildGenieToolkitProvider({
-            spaces,
-            config,
-        });
-    }
-    const plugin = context?.getPlugins().get(propName);
-    return adaptPluginToolkit(plugin);
-}
-/**
- * Adapt an AppKit `ToolProvider` plugin instance into a
- * {@link MastraPluginToolkitProvider}. Returns `null` for any plugin
- * that doesn't implement both `toolkit` and `executeAgentTool` (e.g.
- * `server`, `lakebase` when used only as a Postgres pool, etc.).
- */
-function adaptPluginToolkit(plugin) {
-    if (!plugin || typeof plugin !== "object")
-        return null;
-    const p = plugin;
-    if (typeof p.toolkit !== "function" || typeof p.executeAgentTool !== "function") {
-        return null;
-    }
-    return {
-        toolkit(opts) {
-            const entries = p.toolkit(opts);
-            const tools = {};
-            for (const [key, entry] of Object.entries(entries)) {
-                tools[key] = toolkitEntryToMastraTool(entry, p);
-            }
-            return tools;
-        },
-    };
-}
-/**
- * Wrap a single {@link AppKitToolkitEntry} as a Mastra tool whose
- * `execute` dispatches back through `plugin.executeAgentTool(...)` so
- * AppKit's OBO auth (`asUser`) and telemetry spans stay intact. JSON
- * Schema parameters pass through unchanged - Mastra's `PublicSchema`
- * accepts `JSONSchema7` directly via `@mastra/schema-compat`.
- */
-function toolkitEntryToMastraTool(entry, plugin) {
-    return createTool({
-        id: `${entry.pluginName}__${entry.localName}`,
-        description: entry.def.description,
-        ...(entry.def.parameters ? { inputSchema: entry.def.parameters } : {}),
-        execute: async (input, context) => {
-            const signal = context
-                ?.abortSignal;
-            return plugin.executeAgentTool(entry.localName, input, signal);
-        },
-    });
-}

package/dist/src/chart.d.ts

@@ -1,153 +0,0 @@
-/**
- * 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/appkit-mastra-shared` so
- * the demo client and any other UI consumer share the exact same
- * shape this module reads and writes.
- */
-import { type Chart } from "@dbx-tools/appkit-mastra-shared";
-import type { RequestContext } from "@mastra/core/request-context";
-import { z } from "zod";
-import type { MastraPluginConfig } from "./config.js";
-/**
- * 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 declare const chartPlannerRequestSchema: z.ZodObject<{
-    title: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    data: z.ZodReadonly<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-}, z.core.$strip>;
-export type ChartPlannerRequest = z.infer<typeof chartPlannerRequestSchema>;
-/** Inputs to {@link prepareChart}. */
-export interface PrepareChartOptions {
-    /** Plugin config; resolves the planner agent's model. */
-    config: MastraPluginConfig;
-    /** Display title forwarded to the planner agent. */
-    title?: string;
-    /** Optional intent hint forwarded to the planner agent. */
-    description?: string;
-    /**
-     * Resolves the rows to chart. Called once, in the background.
-     * Any thrown error lands in the cache as the entry's `error`
-     * field (never propagated to the caller of {@link prepareChart}).
-     * An empty `rows` array is rejected as `"dataset has no rows;
-     * nothing to chart"`.
-     */
-    resolveData: (signal?: AbortSignal) => Promise<{
-        rows: ReadonlyArray<Record<string, unknown>>;
-    }>;
-    /**
-     * Per-request `RequestContext`. Forwarded to the planner agent so
-     * user-scoped model resolution (OBO) stays in effect.
-     */
-    requestContext?: RequestContext;
-    /**
-     * Cooperative cancellation. Forwarded to `resolveData` and the
-     * planner agent. Note: the chart task continues running in the
-     * background after the parent request ends, so external abort
-     * signals are best-effort; typical use is to leave this unset
-     * and let the 1h TTL cap stale entries.
-     */
-    signal?: AbortSignal;
-}
-/**
- * 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 declare function prepareChart(opts: PrepareChartOptions): Promise<{
-    chartId: string;
-}>;
-/** Inputs to {@link fetchChart}. */
-export interface FetchChartOptions {
-    /**
-     * Server-side polling budget in ms. When the entry stays in
-     * the processing state past this window, the helper returns the
-     * last seen value (still processing) so the client can re-poll.
-     * Defaults to {@link DEFAULT_FETCH_TIMEOUT_MS} (60s).
-     */
-    timeoutMs?: number;
-    /**
-     * Poll interval in ms. Defaults to
-     * {@link DEFAULT_FETCH_INTERVAL_MS} (250ms).
-     */
-    intervalMs?: number;
-    /** External cancellation handle (e.g. request `req.signal`). */
-    signal?: AbortSignal;
-}
-/**
- * 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 or expired (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 declare function fetchChart(chartId: string, options?: FetchChartOptions): Promise<Chart | undefined>;
-/**
- * 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 declare function buildRenderDataTool(config: MastraPluginConfig): import("@mastra/core/tools").Tool<{
-    title: string;
-    data: readonly Record<string, unknown>[];
-    description?: string | undefined;
-}, {
-    chartId: string;
-}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "render_data", unknown>;