@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/genie.js

@@ -0,0 +1,969 @@
+/**
+ * Genie tools for Mastra.
+ *
+ * Surfaces each configured Genie space as a small set of flat Mastra
+ * tools the calling agent drives directly - no inner orchestrator
+ * agent. The central agent decomposes user questions, picks which
+ * space to ask, streams the per-turn wire events (status, thinking,
+ * sql, rows) through `ctx.writer`, and composes the final reply.
+ * Rows are never fetched eagerly: the agent reads a statement's
+ * values only when it needs to reason about them, otherwise it embeds
+ * a `[data:<statement_id>]` marker in prose and lets the host UI
+ * resolve the data. Charts are minted asynchronously and referenced
+ * by `[chart:<chartId>]` markers so prose isn't blocked on chart
+ * generation; the host UI fetches the cached spec by id once ready.
+ * Space description and serialized-space lookups are available for
+ * grounding when the agent needs schema context.
+ *
+ * Each tool's `execute` pulls the per-request
+ * {@link WorkspaceClient} off `ctx.requestContext` (stamped by
+ * `MastraServer` under {@link MASTRA_USER_KEY}) and the per-call
+ * `writer` / `abortSignal` off `ctx`, so the tools are stateless
+ * across requests and the central agent owns the loop.
+ *
+ * The tools talk to Genie directly via `@dbx-tools/genie`
+ * (`genieEventChat`); statement-row fetching is delegated to
+ * {@link fetchStatementData} from `./statement.js`, which wraps
+ * the workspace `statementExecution.getStatement` API. AppKit's
+ * stock `genie` plugin is honored only for its `spaces` config
+ * so existing AppKit-style wiring keeps working without change.
+ *
+ * Suggested orchestration prompt for the central agent lives in
+ * {@link GENIE_INSTRUCTIONS}; compose it into the agent's own
+ * `instructions` when you want the canonical "how to drive the
+ * Genie tools" guidance.
+ *
+ * @module
+ */
+import { CacheManager, ConfigurationError, ExecutionError, genie, ValidationError, } from "@databricks/appkit";
+import { plugin } from "@dbx-tools/appkit";
+import { chat, space as genieSpace } from "@dbx-tools/genie";
+import { error, log, string } from "@dbx-tools/shared-core";
+import { genieModel } from "@dbx-tools/shared-genie";
+import { wire } from "@dbx-tools/shared-mastra";
+import { MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { chartPlannerRequestSchema, prepareChart } from "./chart.js";
+import { MASTRA_USER_KEY, resolveUserKey } from "./config.js";
+import { fetchStatementData } from "./statement.js";
+import { safeWrite } from "./writer.js";
+const logger = log.logger("mastra/genie");
+/** Default alias used when a single unnamed Genie space is wired up. */
+export const DEFAULT_GENIE_ALIAS = "default";
+/**
+ * Pull the per-request {@link WorkspaceClient} off the active
+ * `RequestContext`. The Mastra plugin's server middleware stamps
+ * a {@link User} on the context under {@link MASTRA_USER_KEY}
+ * for every request; tools fail loudly when it's missing because
+ * that means the Mastra plugin isn't running (e.g. a tool was
+ * invoked outside the chat route).
+ */
+function requireClient(ctx, toolId) {
+    const requestContext = ctx?.requestContext;
+    if (!requestContext) {
+        throw ConfigurationError.resourceNotFound(`${toolId} request context`, "Invoke the tool from an agent turn served by the mastra plugin.");
+    }
+    const user = requestContext.get(MASTRA_USER_KEY);
+    if (!user) {
+        throw ConfigurationError.resourceNotFound(`${toolId} user context`, "Invoke the tool from an agent turn served by the mastra plugin, which stamps the AppKit user on the Mastra request context.");
+    }
+    return { client: user.executionContext.client, requestContext };
+}
+/**
+ * Lowercased placeholder strings we reject at the `ask_genie`
+ * boundary so the LLM doesn't spend a Genie round-trip on a
+ * non-question. Genie politely answers any of these with "Your
+ * request '...' does not relate to..." which is pure UI noise.
+ * Kept narrow on purpose - real questions sometimes start with
+ * one of these tokens, so we only match the FULL trimmed string.
+ */
+const PLACEHOLDER_QUESTIONS = new Set([
+    "noop",
+    "no-op",
+    "skip",
+    "none",
+    "n/a",
+    "na",
+    "null",
+    "undefined",
+    "test",
+    "placeholder",
+]);
+/* ----------------------- conversation state ----------------------- */
+/**
+ * Estimated Genie conversation lifetime in seconds. Databricks
+ * publishes no official TTL on the conversation resource itself;
+ * community projects (e.g. the open-source Databricks Genie Bot)
+ * converge on 4 hours of inactivity as a safe operating window.
+ * Treat this as an estimate that gets *extended on every use* by
+ * re-setting the cache entry after each successful turn (sliding
+ * TTL via re-`set`). When the estimate ends up wrong (conversation
+ * deleted, expired upstream, cross-space referenced), `ask_genie`
+ * catches the SDK's `RESOURCE_DOES_NOT_EXIST`/404 and transparently
+ * starts a fresh conversation.
+ */
+const CONVERSATION_TTL_SEC = 4 * 60 * 60;
+/** Cache namespace prefix so coexisting Mastra caches don't collide. */
+const CONVERSATION_CACHE_NAMESPACE = "mastra:genie:conversation";
+/**
+ * Build the per-request {@link RequestContext} key the active
+ * Genie `conversation_id` lives under for `spaceId`. Scoped by
+ * space so an app calling two Genie spaces in one request keeps
+ * each conversation distinct (Genie conversation ids are
+ * space-scoped on the wire). The same `RequestContext` instance
+ * flows from the central agent through to every `ask_genie`
+ * invocation, so writes on one call are visible on the next
+ * without an explicit shared ref.
+ */
+const conversationContextKey = (spaceId) => `mastra__genie_conversation__${spaceId}`;
+/**
+ * Read the active Genie `conversation_id` for `spaceId` off the
+ * per-request {@link RequestContext}. Returns `undefined` when no
+ * conversation has been started yet this request.
+ */
+function readContextConversationId(requestContext, spaceId) {
+    return requestContext.get(conversationContextKey(spaceId));
+}
+/**
+ * Write the active Genie `conversation_id` for `spaceId` onto the
+ * per-request {@link RequestContext}. Subsequent `ask_genie` calls
+ * in this request will reuse it.
+ */
+function writeContextConversationId(requestContext, spaceId, conversationId) {
+    requestContext.set(conversationContextKey(spaceId), conversationId);
+}
+/**
+ * Build the canonical cache key for a `(spaceId, threadId)` pair, owned by
+ * `userKey`. Returns `undefined` when `threadId` is missing - callers should
+ * skip caching entirely in that case (no Mastra memory wired up).
+ *
+ * The identity is part of the key because a client picks its own `threadId`
+ * (the thread-selection header / `?threadId=`), so the id alone does not
+ * establish who owns the Genie conversation behind it.
+ */
+async function conversationCacheKey(spaceId, threadId, userKey) {
+    if (!threadId)
+        return undefined;
+    return (await CacheManager.getInstance()).generateKey([CONVERSATION_CACHE_NAMESPACE, spaceId, threadId], userKey);
+}
+/**
+ * Read the cached Genie conversation id for `(spaceId, threadId)`.
+ * Returns `undefined` on miss, on expiry, or when the cache layer
+ * is unhealthy - never throws. The TTL is renewed via re-`set`
+ * after each successful turn (see {@link saveCachedConversationId}).
+ */
+async function readCachedConversationId(cacheKey) {
+    if (!cacheKey)
+        return undefined;
+    try {
+        const v = await CacheManager.getInstanceSync().get(cacheKey);
+        return v ?? undefined;
+    }
+    catch (err) {
+        logger.warn("conversation-cache:read-error", {
+            error: error.errorMessage(err),
+        });
+        return undefined;
+    }
+}
+/**
+ * Persist the active conversation id under `cacheKey`, refreshing
+ * its TTL. Idempotent; no-op when `cacheKey` or `conversationId`
+ * is missing. Re-setting the same key acts as a sliding TTL: every
+ * turn that uses the conversation extends the window by another
+ * {@link CONVERSATION_TTL_SEC} seconds.
+ */
+async function saveCachedConversationId(cacheKey, conversationId) {
+    if (!cacheKey || !conversationId)
+        return;
+    try {
+        await CacheManager.getInstanceSync().set(cacheKey, conversationId, {
+            ttl: CONVERSATION_TTL_SEC,
+        });
+    }
+    catch (err) {
+        logger.warn("conversation-cache:write-error", {
+            error: error.errorMessage(err),
+        });
+    }
+}
+/** Force-evict a cached conversation id. Used on the stale-id recovery path. */
+async function evictCachedConversationId(cacheKey) {
+    if (!cacheKey)
+        return;
+    try {
+        await CacheManager.getInstanceSync().delete(cacheKey);
+    }
+    catch (err) {
+        logger.warn("conversation-cache:delete-error", {
+            error: error.errorMessage(err),
+        });
+    }
+}
+/**
+ * Lazy-seed the active Genie `conversation_id` for `spaceId` from
+ * the cross-request cache onto the per-request `RequestContext`.
+ * No-op when the slot is already populated (subsequent
+ * `ask_genie` calls in the same turn) so we hit the cache at most
+ * once per request per space.
+ */
+async function ensureConversationSeeded(requestContext, spaceId, cacheKey) {
+    if (readContextConversationId(requestContext, spaceId))
+        return;
+    const cached = await readCachedConversationId(cacheKey);
+    if (cached)
+        writeContextConversationId(requestContext, spaceId, cached);
+}
+/* ------------------------ prepare_chart input ------------------------ */
+/**
+ * Agent-facing `prepare_chart` input schema. Reuses
+ * {@link chartPlannerRequestSchema} (the dataset-driven planner
+ * contract) but swaps the inline `data` field for a Genie
+ * `statement_id` the tool resolves into rows server-side.
+ * `title` is loosened to optional - the planner falls back to a
+ * generic placeholder when the agent doesn't supply one.
+ *
+ * Shaped to match Genie's wire form - `statement_id` (snake)
+ * mirrors `query_result.statement_id` and the `get_statement`
+ * tool's input field name, so the LLM only ever sees one
+ * spelling for the same identifier.
+ */
+const prepareChartRequestSchema = chartPlannerRequestSchema
+    .omit({ data: true, title: true })
+    .extend({
+    statement_id: z
+        .string()
+        .min(1, "statement_id is required")
+        .describe(string.toDescription(`
+          Genie \`statement_id\` to chart. Read from
+          \`message.query_result.statement_id\` or
+          \`message.attachments[*].query.statement_id\` returned by
+          \`ask_genie\`.
+        `)),
+    title: chartPlannerRequestSchema.shape.title.optional(),
+});
+/* ----------------------------- tool ids ----------------------------- */
+/**
+ * Suffix appended to per-space tool ids when the alias isn't the
+ * well-known `default`. Single-space deployments get the bare
+ * names (`ask_genie`, `get_space_description`, ...); multi-space
+ * deployments get `ask_genie_<alias>` etc. so each space's tools
+ * stay disambiguated in the central agent's tool registry.
+ */
+function aliasSuffix(alias) {
+    if (alias === DEFAULT_GENIE_ALIAS)
+        return "";
+    const slug = string.toIdentifier(alias);
+    return slug ? `_${slug}` : "";
+}
+/* --------------------------- per-space tools --------------------------- */
+/**
+ * Drop `suggested_questions` attachments from a {@link GenieMessage}
+ * before handing it to the central LLM. Those entries already
+ * surface in the UI as one-tap pills via the writer's
+ * `suggested_questions` events (see `collectSuggestions` on the
+ * client); if we let them ride back in the tool result the LLM
+ * tends to quote them inline in its prose, double-showing the
+ * same questions and stepping on the dedicated suggestion UI.
+ * Query / text / row attachments are preserved so the model can
+ * still read `statement_id`, SQL, and the answer text.
+ */
+function stripSuggestedQuestions(message) {
+    const attachments = message.attachments;
+    if (!attachments || attachments.length === 0)
+        return message;
+    const filtered = attachments.filter((att) => !att.suggested_questions);
+    if (filtered.length === attachments.length)
+        return message;
+    return { ...message, attachments: filtered };
+}
+function buildAskGenieTool(opts) {
+    const { spaceId, alias, hint } = opts;
+    const toolId = `ask_genie${aliasSuffix(alias)}`;
+    const hintLine = hint ? ` (${hint})` : "";
+    return createTool({
+        id: toolId,
+        description: string.toDescription(`
+      Ask the Genie space "${alias}"${hintLine} ONE focused
+      natural-language sub-question and wait for the turn to
+      complete. Genie answers best when each call covers a
+      single metric / dimension / time window, so expect to
+      call this tool MULTIPLE TIMES per user turn (typically
+      two to six) and let the results from earlier calls inform
+      later ones - that's the normal pattern, not the exception.
+      Do NOT try to cram a multi-part question into a single
+      call; decompose first, then ask each piece.
+
+      Returns the final \`GenieMessage\`. Rows are NOT included -
+      the Genie wire response carries the \`statement_id\` for any
+      SQL that ran (at \`message.query_result.statement_id\` or the
+      first attachment's \`query.statement_id\`); call
+      \`get_statement\` with that id only when you need to read
+      the underlying values to reason about them. If you just
+      want to display the rows to the user, embed a
+      \`[data:<statement_id>]\` marker in your prose instead -
+      the host UI fetches and renders the rows on its own. Wire
+      events (status, thinking, sql) stream to the user
+      automatically while the call is in flight.
+    `),
+        inputSchema: z.object({
+            question: z
+                .string()
+                .min(1, "question is required")
+                .describe(string.toDescription(`
+            ONE focused natural-language question about the data in this
+            space, covering a single metric / dimension / time window
+            (e.g. "What was Q3 revenue by region?"). Decompose a
+            multi-part ask into separate calls rather than combining it
+            here.
+          `)),
+        }),
+        outputSchema: z.object({
+            message: genieModel.GenieMessageSchema,
+        }),
+        execute: async ({ question }, ctxRaw) => {
+            const ctx = ctxRaw;
+            const { client, requestContext } = requireClient(ctx, toolId);
+            const writer = ctx?.writer;
+            const signal = ctx?.abortSignal;
+            const threadId = requestContext.get(MASTRA_THREAD_ID_KEY);
+            // Bounce placeholder / no-op questions BEFORE spending a Genie
+            // round-trip on them. Genie answers any of these with "Your
+            // request 'noop' does not relate to..." - useless noise that
+            // shows up in the UI and eats one of the workspace's 5
+            // questions/minute. Returning a clear error here surfaces the
+            // issue to the agent loop so the model corrects course instead
+            // of wasting a turn.
+            const trimmed = question.trim();
+            if (trimmed.length === 0 || PLACEHOLDER_QUESTIONS.has(trimmed.toLowerCase())) {
+                throw ValidationError.invalidValue(`${toolId}.question`, question, "a real natural-language question, not a placeholder; skip the call instead");
+            }
+            // Seed the active Genie `conversation_id` onto `RequestContext`
+            // from the cross-request cache when a Mastra `threadId` is
+            // present so multi-turn chats reuse the same Genie conversation
+            // (and Genie's accumulated context) across separate user turns.
+            // The same `RequestContext` is reused across every `ask_genie`
+            // call within one user turn, so `ensureConversationSeeded`
+            // hits the cache at most once per request per space.
+            const cacheKey = await conversationCacheKey(spaceId, threadId, resolveUserKey(requestContext));
+            await ensureConversationSeeded(requestContext, spaceId, cacheKey);
+            // Fire the lifecycle `started` event before any LLM /
+            // network round-trip so the host UI can pop a "Thinking..."
+            // pill the instant the model decides to delegate.
+            const startedEvent = {
+                type: "started",
+                spaceId,
+                content: question,
+            };
+            await safeWrite(logger, writer, startedEvent);
+            // Single turn of `genieEventChat`. Hoisted into a closure so
+            // we can re-run it after evicting a stale `conversation_id`
+            // without duplicating the event-loop body.
+            const runTurn = async () => {
+                const seedConversationId = readContextConversationId(requestContext, spaceId);
+                let finalMessage;
+                for await (const event of chat.genieEventChat(spaceId, question, {
+                    workspaceClient: client,
+                    ...(seedConversationId ? { conversationId: seedConversationId } : {}),
+                    ...(signal ? { context: signal } : {}),
+                })) {
+                    if (event.type !== "message") {
+                        await safeWrite(logger, writer, event);
+                    }
+                    const eventConversationId = event.conversation_id;
+                    if (eventConversationId) {
+                        writeContextConversationId(requestContext, spaceId, eventConversationId);
+                    }
+                    if (event.type === "result") {
+                        finalMessage = event.message;
+                    }
+                }
+                if (!finalMessage) {
+                    throw ExecutionError.missingData("Genie result event");
+                }
+                return finalMessage;
+            };
+            let finalMessage;
+            try {
+                finalMessage = await runTurn();
+            }
+            catch (err) {
+                // The seeded `conversation_id` was rejected by Genie - most
+                // commonly because it was deleted upstream, expired past
+                // Databricks' (undocumented) lifetime, or was minted in a
+                // different space. Drop both the cached id AND the
+                // per-request value so the retry calls `startConversation`,
+                // and try once more. Only retry when we *had* a seeded id -
+                // a fresh call that 404s shouldn't loop.
+                const seeded = readContextConversationId(requestContext, spaceId);
+                if (seeded && error.errorContext(err).notAccessible) {
+                    logger.warn("conversation-cache:stale, resetting", {
+                        spaceId,
+                        conversationId: seeded,
+                        error: error.errorMessage(err),
+                    });
+                    await evictCachedConversationId(cacheKey);
+                    writeContextConversationId(requestContext, spaceId, undefined);
+                    finalMessage = await runTurn();
+                }
+                else {
+                    throw err;
+                }
+            }
+            // Refresh the cache entry on every successful turn. Re-setting
+            // the same key both persists newly-minted ids (cache miss path)
+            // and extends the TTL on active conversations (sliding window).
+            await saveCachedConversationId(cacheKey, readContextConversationId(requestContext, spaceId));
+            return { message: stripSuggestedQuestions(finalMessage) };
+        },
+    });
+}
+function buildSpaceDescriptionTool(opts) {
+    const { spaceId, alias } = opts;
+    const toolId = `get_space_description${aliasSuffix(alias)}`;
+    return createTool({
+        id: toolId,
+        description: string.toDescription(`
+      Return the Genie space "${alias}"'s title, description, and
+      warehouse id. Cheap (single REST call, no LLM round-trip).
+      Call this FIRST on any user turn that's going to touch
+      \`ask_genie\`, unless the same description already landed
+      earlier in this conversation - the title + description tell
+      you what tables, metrics, and time windows the space
+      actually covers, which is what lets you decompose the
+      user's question into the right \`ask_genie\` sub-questions.
+    `),
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+            spaceId: z.string(),
+            title: z.string().optional(),
+            description: z.string().optional(),
+            warehouseId: z.string().optional(),
+        }),
+        execute: async (_input, ctxRaw) => {
+            const ctx = ctxRaw;
+            const { client } = requireClient(ctx, toolId);
+            const signal = ctx?.abortSignal;
+            // Route through the package's central Genie space fetch. The
+            // description surface (title / description / warehouse id) lives
+            // on the directory-listing shape, so skip the larger
+            // `serialized_space` payload here.
+            const space = await genieSpace.getGenieSpace(spaceId, {
+                workspaceClient: client,
+                serialized: false,
+                ...(signal ? { context: signal } : {}),
+            });
+            return {
+                spaceId,
+                ...(space.title ? { title: space.title } : {}),
+                ...(space.description ? { description: space.description } : {}),
+                ...(space.warehouse_id ? { warehouseId: space.warehouse_id } : {}),
+            };
+        },
+    });
+}
+function buildSpaceSerializedTool(opts) {
+    const { spaceId, alias } = opts;
+    const toolId = `get_space_serialized${aliasSuffix(alias)}`;
+    return createTool({
+        id: toolId,
+        description: string.toDescription(`
+      Return the full \`GenieSpace\` JSON for the "${alias}" space.
+      Use only when you need exact column / table identifiers
+      \`get_space_description\` doesn't expose. Larger payload, so
+      prefer the description tool when it's enough.
+    `),
+        inputSchema: z.object({}),
+        outputSchema: z.object({ space: z.unknown() }),
+        execute: async (_input, ctxRaw) => {
+            const ctx = ctxRaw;
+            const { client } = requireClient(ctx, toolId);
+            const signal = ctx?.abortSignal;
+            // Central Genie space fetch with the opt-in `serialized_space`
+            // blob (catalogs, tables, sample questions, prompts) that the
+            // typed SDK `getSpace` omits - the whole point of this tool.
+            const space = await genieSpace.getGenieSpace(spaceId, {
+                workspaceClient: client,
+                ...(signal ? { context: signal } : {}),
+            });
+            return { space };
+        },
+    });
+}
+/* --------------------------- shared tools --------------------------- */
+/**
+ * Default row cap for {@link buildGetStatementTool} when the agent
+ * doesn't supply a `limit`. Sized to keep result sets out of the
+ * model context unless the agent explicitly opts into more rows -
+ * the cheap shape (column names + a handful of representative
+ * rows) is usually enough to reason about a query.
+ */
+const DEFAULT_STATEMENT_LIMIT = 50;
+function buildGetStatementTool() {
+    const toolId = "get_statement";
+    return createTool({
+        id: toolId,
+        description: string.toDescription(`
+      Fetch the rows of a Genie statement by its \`statement_id\` (the
+      value at \`message.query_result.statement_id\` or
+      \`message.attachments[*].query.statement_id\` returned from
+      \`ask_genie\`). Use this ONLY when you need to read the underlying
+      values to reason about them in your reply - e.g. naming the
+      largest row, computing a delta the visualization wouldn't already
+      convey, or filtering down to a specific record. If you'd just be
+      reciting numbers the user will see anyway, skip the call and
+      embed a \`[data:<statement_id>]\` marker in your prose instead;
+      the host UI fetches and renders the rows on its own. \`limit\`
+      caps the number of rows returned (defaults to
+      ${DEFAULT_STATEMENT_LIMIT}). \`rowCount\` reflects the full
+      upstream total - compare to \`rows.length\` to detect truncation.
+    `),
+        inputSchema: z.object({
+            statement_id: z
+                .string()
+                .min(1, "statement_id is required")
+                .describe(string.toDescription(`
+            Genie \`statement_id\` whose rows to read. Take it from
+            \`message.query_result.statement_id\` or
+            \`message.attachments[*].query.statement_id\` on an
+            \`ask_genie\` result; it is never a value you construct.
+          `)),
+            limit: z
+                .number()
+                .int()
+                .nonnegative()
+                .optional()
+                .describe("Max rows to return. Defaults to a small sample; raise only when more rows are genuinely needed."),
+        }),
+        outputSchema: z.object({
+            columns: z.array(z.string()),
+            rows: z.array(z.record(z.string(), z.unknown())),
+            rowCount: z.number(),
+            truncated: z.boolean(),
+        }),
+        execute: async ({ statement_id, limit }, ctxRaw) => {
+            const ctx = ctxRaw;
+            const { client } = requireClient(ctx, toolId);
+            const signal = ctx?.abortSignal;
+            const effectiveLimit = limit ?? DEFAULT_STATEMENT_LIMIT;
+            const data = await fetchStatementData(client, statement_id, {
+                limit: effectiveLimit,
+                ...(signal ? { signal } : {}),
+            });
+            return {
+                columns: data.columns,
+                rows: data.rows,
+                rowCount: data.rowCount,
+                truncated: data.rows.length < data.rowCount,
+            };
+        },
+    });
+}
+/**
+ * `prepare_chart` Mastra tool. Thin wrapper over
+ * {@link prepareChart} that resolves the dataset by fetching the
+ * Genie statement's rows on demand. The tool mints a `chartId`
+ * synchronously, caches an empty placeholder, and kicks off the
+ * planner in the background so the agent loop never blocks. The
+ * host UI resolves `[chart:<chartId>]` markers by reading the
+ * cached {@link Chart} entry (1h TTL).
+ *
+ * Space-agnostic: a Genie `statement_id` is workspace-scoped, so
+ * one shared `prepare_chart` tool covers every wired Genie space.
+ *
+ * Cancellation: deliberately does NOT forward the per-call
+ * `abortSignal` to {@link prepareChart}. The planner task is
+ * fire-and-forget background work; the tool's own `execute`
+ * resolves the moment the `chartId` is minted, so the per-call
+ * signal aborts the second the tool returns. The 1h cache TTL
+ * caps abandoned entries.
+ */
+function buildPrepareChartTool(opts) {
+    const { config } = opts;
+    const toolId = "prepare_chart";
+    return createTool({
+        id: toolId,
+        description: string.toDescription([
+            `
+        Queue a chart for the rows of a Genie statement. Mints a
+        short \`chartId\` synchronously and kicks off a BACKGROUND
+        task that fetches the statement's rows, runs the
+        chart-planner to pick a chart type and Echarts spec, and
+        caches the result under the \`chartId\` for one hour. The
+        host UI fetches the cached chart on its own once it lands.
+      `,
+            `
+        To display the chart in your reply, embed
+        \`[chart:<chartId>]\` on its own line at the position you
+        want it to appear, using the EXACT \`chartId\` string this
+        call returned. Never construct a chart id yourself (it is
+        not the \`statement_id\` or any variation of it) - only a
+        value returned by this tool resolves to a real chart. The
+        tool returns immediately - do NOT wait or call it again to
+        "check progress"; the chart resolves asynchronously on the
+        host UI's side.
+      `,
+            `
+        Use this only when the data has a story a chart conveys
+        better than a table (trends, rankings, distributions,
+        parts-of-a-whole). For raw rows, embed
+        \`[data:<statement_id>]\` instead and skip this tool.
+      `,
+        ]),
+        inputSchema: prepareChartRequestSchema,
+        outputSchema: wire.ChartSchema.pick({ chartId: true }),
+        execute: async (request, ctxRaw) => {
+            const ctx = ctxRaw;
+            const { client, requestContext } = requireClient(ctx, toolId);
+            return prepareChart({
+                config,
+                userKey: resolveUserKey(requestContext),
+                ...(request.title ? { title: request.title } : {}),
+                ...(request.description ? { description: request.description } : {}),
+                resolveData: (taskSignal) => fetchStatementData(client, request.statement_id, {
+                    ...(taskSignal ? { signal: taskSignal } : {}),
+                }),
+                ...(ctx?.requestContext ? { requestContext: ctx.requestContext } : {}),
+            });
+        },
+    });
+}
+/* --------------------------- orchestration prompt --------------------------- */
+/**
+ * Suggested orchestration prompt for the central agent that owns
+ * the Genie tools. Compose into your agent's `instructions` to
+ * get the canonical "decompose questions, ask Genie focused
+ * sub-questions, place data / chart markers in prose" behavior:
+ *
+ * ```ts
+ * createAgent({
+ *   instructions: `${myAgentInstructions}\n\n${GENIE_INSTRUCTIONS}`,
+ *   tools(plugins) {
+ *     return { ...plugins.genie?.toolkit() };
+ *   },
+ * });
+ * ```
+ *
+ * The prompt references the bare tool names (`ask_genie`,
+ * `get_space_description`, `get_space_serialized`,
+ * `get_statement`, `prepare_chart`) used for the single-space
+ * default alias. Multi-space deployments should write their own
+ * variant that names the suffixed per-space tools
+ * (e.g. `ask_genie_sales`).
+ */
+export const GENIE_INSTRUCTIONS = string.toDescription([
+    "Genie orchestration. For every user question that needs SQL-backed data:",
+    {
+        numbered: [
+            `
+        Start by calling \`get_space_description\` to ground yourself
+        in what the space covers (tables, metrics, time windows),
+        unless you already saw the same description earlier in this
+        conversation. Reach for \`get_space_serialized\` only when you
+        need exact column / table identifiers the description doesn't
+        expose - it's a much larger payload.
+      `,
+            `
+        Decompose the user's question into focused sub-questions
+        BEFORE asking Genie anything. One sub-question per distinct
+        metric, dimension, or time window. Then call \`ask_genie\`
+        once per sub-question - usually two to six calls per turn,
+        and let earlier answers inform what you ask next. Cramming
+        a multi-part question into one \`ask_genie\` call almost
+        always produces a worse answer than asking the pieces
+        separately. Only collapse to a single call when the question
+        is genuinely atomic ("what was Q3 revenue?").
+
+        Worked example: user asks "How did SKU 1234's revenue
+        compare to its category average last quarter, and which
+        regions drove the gap?" Decomposes to: (a) \`ask_genie\`
+        for SKU 1234's Q3 revenue, (b) \`ask_genie\` for the
+        category-average Q3 revenue, (c) \`ask_genie\` for SKU
+        1234's Q3 revenue split by region. Three focused calls,
+        each grounded in the prior results.
+      `,
+            `
+        Each \`ask_genie\` call returns the terminal \`GenieMessage\`.
+        When the turn ran SQL the result has a \`statement_id\` - read
+        it from \`message.query_result.statement_id\` (or the first
+        attachment's \`query.statement_id\`).
+      `,
+            [
+                `
+          To DISPLAY a result set in your reply, embed a marker on its
+          own line where the visualization should appear. Two marker
+          shapes:
+        `,
+                {
+                    bullets: [
+                        `
+              \`[data:<statement_id>]\` - render the rows as a table.
+              Use this when there's no clear visual story (long lists,
+              reference data, single-row results, or the user just
+              wants to see the data). Embed the marker directly; no
+              tool call needed.
+            `,
+                        `
+              \`[chart:<chartId>]\` - render the rows as a chart. To
+              get a \`<chartId>\`, call \`prepare_chart\` with the
+              statement's id (and an optional \`title\` / one-line
+              \`description\` of the insight to surface). The tool
+              returns the \`chartId\` synchronously and prepares the
+              chart spec in the background; embed the returned id as
+              \`[chart:<chartId>]\` on its own line wherever the
+              chart should appear. Use a chart when the data has a
+              story a visual conveys better than a table (trends,
+              rankings, distributions, parts-of-a-whole).
+
+              NEVER invent or hand-build a \`<chartId>\`. A valid
+              \`<chartId>\` is the opaque token a \`prepare_chart\`
+              call returned to you in THIS turn - nothing else. It
+              is NOT a \`statement_id\`, and it is NOT a
+              \`statement_id\` prefix with a label appended (e.g.
+              \`01f1...-region-fill\`). If you have not called
+              \`prepare_chart\` and received an id back, do not write
+              a \`[chart:...]\` marker at all - use \`[data:...]\`
+              instead. A fabricated chart id renders nothing and
+              wastes a request.
+            `,
+                    ],
+                },
+                `
+          The host UI resolves both markers on its own once it sees
+          them - you do NOT need to call \`get_statement\` just to
+          display data, and you do NOT need to wait on
+          \`prepare_chart\` (it returns the id immediately and the
+          host UI fetches the cached chart later). Pick at most one
+          marker per statement; don't chart AND table the same result
+          side by side.
+        `,
+            ],
+            `
+        Call \`get_statement(statement_id, limit?)\` ONLY when you need
+        to read the actual values to reason about them (e.g. naming a
+        specific row, computing a delta the table or chart wouldn't
+        show, or sanity-checking a result before interpreting it). If
+        you'd just be reciting numbers the visualization already shows,
+        skip the call and use a marker instead. \`limit\` defaults to a
+        small sample; raise it only when you genuinely need more rows.
+      `,
+            `
+        Compose your final reply as plain prose. Interleave paragraphs
+        with \`[data:...]\` / \`[chart:...]\` markers wherever a result
+        should render. Don't dump all markers at the end - place each
+        one next to the prose that interprets it. Don't restate every
+        number the visualization already shows; call out deltas,
+        anomalies, takeaways.
+      `,
+        ],
+    },
+]);
+/* --------------------- multi-alias surface --------------------- */
+/**
+ * Normalize the {@link GenieSpacesConfig} record. Bare-string
+ * entries (`{ default: "01ef..." }`) get wrapped as
+ * `{ spaceId: "01ef..." }`; object entries pass through unchanged.
+ *
+ * @throws ConfigurationError when an alias is present but carries no space id
+ *   (`{ default: process.env.DATABRICKS_GENIE_SPACE_ID }` with the variable
+ *   unset). An alias that resolves to nothing is a wiring contradiction: the
+ *   agent would advertise no Genie tool for a space the deployment believes it
+ *   configured, so it fails at construction instead of going quiet.
+ */
+export function normalizeGenieSpaces(spaces) {
+    if (!spaces)
+        return {};
+    const out = {};
+    for (const [alias, value] of Object.entries(spaces)) {
+        const spaceId = typeof value === "string" ? value : value?.spaceId;
+        if (!spaceId)
+            throw missingSpaceId(alias);
+        out[alias] = typeof value === "string" ? { spaceId } : value;
+    }
+    return out;
+}
+/** Config contradiction: an alias present in `genieSpaces` with no space id. */
+function missingSpaceId(alias) {
+    const envHint = alias === DEFAULT_GENIE_ALIAS
+        ? "Set DATABRICKS_GENIE_SPACE_ID, pass the space id inline, or drop the alias."
+        : `Pass the space id inline (DATABRICKS_GENIE_SPACE_ID only backs the "${DEFAULT_GENIE_ALIAS}" alias) or drop the alias.`;
+    return ConfigurationError.resourceNotFound(`genieSpaces.${alias} space id`, envHint);
+}
+/**
+ * Discover Genie space aliases from every supported source and
+ * merge them into a single record. Precedence (highest first):
+ *
+ *   1. {@link MastraPluginConfig.genieSpaces} on the `mastra(...)`
+ *      call. Explicit Mastra wiring always wins so users can
+ *      override AppKit's defaults per-agent.
+ *   2. AppKit `genie({ spaces: { ... } })` plugin instance. Lets
+ *      users keep using the existing AppKit config format
+ *      (`genie({ spaces: { sales: "...", ops: "..." } })`)
+ *      without restating the same record on the Mastra plugin.
+ *      Read off the live plugin instance via a structural cast
+ *      since `Plugin.config` is TS-protected (not runtime-private).
+ *   3. `DATABRICKS_GENIE_SPACE_ID` env var (registered under the
+ *      well-known `default` alias). Matches the AppKit `genie()`
+ *      plugin's fallback behavior so a bare `mastra()` + `genie()`
+ *      pair just works.
+ *
+ * Aliases collide cleanly: a higher-precedence source's value
+ * replaces a lower one's wholesale. A source that contributes zero
+ * aliases is skipped; a source that names an alias without a space
+ * id fails through {@link normalizeGenieSpaces}.
+ */
+export function resolveGenieSpaces(config, context) {
+    const merged = {};
+    // Source 3 (lowest precedence): env var.
+    const envSpaceId = process.env.DATABRICKS_GENIE_SPACE_ID;
+    if (envSpaceId) {
+        merged[DEFAULT_GENIE_ALIAS] = { spaceId: envSpaceId };
+    }
+    // Source 2: AppKit `genie()` plugin instance config. Use a
+    // structural cast - `Plugin.config` is `protected` in TS only,
+    // and the runtime layout is plain object property access.
+    const geniePlugin = plugin.instance(context, genie);
+    if (geniePlugin) {
+        const pluginSpaces = geniePlugin.config?.spaces;
+        if (pluginSpaces) {
+            Object.assign(merged, normalizeGenieSpaces(pluginSpaces));
+        }
+    }
+    // Source 1 (highest precedence): explicit Mastra wiring.
+    if (config.genieSpaces) {
+        Object.assign(merged, normalizeGenieSpaces(config.genieSpaces));
+    }
+    return merged;
+}
+/**
+ * Build the flat Mastra tools record for every configured Genie
+ * space. Two shared, space-agnostic tools (`get_statement`,
+ * `prepare_chart`) are registered once regardless of how many
+ * spaces are wired; the per-space tools (`ask_genie`,
+ * `get_space_description`, `get_space_serialized`) are suffixed
+ * with `_<alias>` for non-default aliases so multi-space
+ * deployments stay disambiguated.
+ *
+ * Returns a record keyed by tool id, ready to spread into the
+ * central `Agent`'s `tools` map (or surfaced via the
+ * `plugins.genie?.toolkit()` callback). Returns an empty record
+ * when `spaces` resolves to zero entries so the caller can spread
+ * safely.
+ */
+export function buildGenieTools(opts) {
+    const normalized = normalizeGenieSpaces(opts.spaces);
+    const tools = {};
+    if (Object.keys(normalized).length === 0)
+        return tools;
+    // Shared, space-agnostic tools.
+    tools.get_statement = buildGetStatementTool();
+    tools.prepare_chart = buildPrepareChartTool({ config: opts.config });
+    for (const [alias, space] of Object.entries(normalized)) {
+        const askTool = buildAskGenieTool({
+            spaceId: space.spaceId,
+            alias,
+            ...(space.hint ? { hint: space.hint } : {}),
+        });
+        const descTool = buildSpaceDescriptionTool({ spaceId: space.spaceId, alias });
+        const serTool = buildSpaceSerializedTool({ spaceId: space.spaceId, alias });
+        tools[askTool.id] = askTool;
+        tools[descTool.id] = descTool;
+        tools[serTool.id] = serTool;
+    }
+    return tools;
+}
+/**
+ * Plugin-toolkit adapter so the `plugins.genie?.toolkit()` lookup
+ * inside an agent's `tools(plugins)` callback returns the
+ * flat Genie tools record instead of throwing on missing plugin.
+ * Mirrors AppKit's `PluginToolkitProvider` shape.
+ */
+export function buildGenieToolkitProvider(opts) {
+    return {
+        toolkit(_opts) {
+            return buildGenieTools(opts);
+        },
+    };
+}
+/* --------------------------- starter suggestions --------------------------- */
+/**
+ * Default cap on starter suggestions surfaced to the chat empty
+ * state. Sample-question lists can run long (10+ on a curated
+ * space); a handful of one-tap prompts reads better than a wall of
+ * buttons.
+ */
+const SUGGESTION_LIMIT = 6;
+/**
+ * How long a space's parsed sample questions stay cached. They're
+ * authored config that changes rarely, and the lookup is an extra
+ * REST round-trip per chat mount, so a few minutes of caching keeps
+ * the empty state instant on reload without going stale for long.
+ */
+const SUGGESTION_CACHE_TTL_MS = 10 * 60_000;
+/** Space-id -> cached sample questions with an absolute expiry. */
+const _suggestionCache = new Map();
+/** Read a space's cached questions, or `undefined` on miss / expiry. */
+function readSuggestionCache(spaceId) {
+    const entry = _suggestionCache.get(spaceId);
+    if (!entry)
+        return undefined;
+    if (entry.expires <= Date.now()) {
+        _suggestionCache.delete(spaceId);
+        return undefined;
+    }
+    return entry.questions;
+}
+/** Cache a space's parsed questions for {@link SUGGESTION_CACHE_TTL_MS}. */
+function writeSuggestionCache(spaceId, questions) {
+    _suggestionCache.set(spaceId, {
+        questions,
+        expires: Date.now() + SUGGESTION_CACHE_TTL_MS,
+    });
+}
+/**
+ * Collect the curated starter questions across every resolved Genie
+ * space, deduped and capped. Each space's `sample_questions` are
+ * fetched once (cached for {@link SUGGESTION_CACHE_TTL_MS}) via
+ * {@link getGenieSpace} + {@link genieSampleQuestions}, then merged in
+ * alias-iteration order so a single-space app surfaces that space's
+ * questions and a multi-space app round-trips breadth-first up to the
+ * cap. A per-space fetch failure degrades to "no questions for that
+ * space" (logged, not thrown) so one unreachable space never blanks
+ * the whole list. Returns `[]` when no spaces are configured.
+ */
+export async function collectSpaceSuggestions(opts) {
+    const limit = opts.limit ?? SUGGESTION_LIMIT;
+    const merged = [];
+    const seen = new Set();
+    for (const { spaceId } of Object.values(opts.spaces)) {
+        let questions = readSuggestionCache(spaceId);
+        if (!questions) {
+            try {
+                const space = await genieSpace.getGenieSpace(spaceId, {
+                    workspaceClient: opts.client,
+                    ...(opts.signal ? { context: opts.signal } : {}),
+                });
+                questions = genieSpace.genieSampleQuestions(space);
+                writeSuggestionCache(spaceId, questions);
+            }
+            catch (err) {
+                logger.warn("suggestions:fetch-error", {
+                    spaceId,
+                    error: error.errorMessage(err),
+                });
+                questions = [];
+            }
+        }
+        for (const question of questions) {
+            if (seen.has(question))
+                continue;
+            seen.add(question);
+            merged.push(question);
+            if (merged.length >= limit)
+                return merged;
+        }
+    }
+    return merged;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"genie.js","sourceRoot":"","sources":["../../src/genie.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Genie tools for Mastra.\n *\n * Surfaces each configured Genie space as a small set of flat Mastra\n * tools the calling agent drives directly - no inner orchestrator\n * agent. The central agent decomposes user questions, picks which\n * space to ask, streams the per-turn wire events (status, thinking,\n * sql, rows) through `ctx.writer`, and composes the final reply.\n * Rows are never fetched eagerly: the agent reads a statement's\n * values only when it needs to reason about them, otherwise it embeds\n * a `[data:<statement_id>]` marker in prose and lets the host UI\n * resolve the data. Charts are minted asynchronously and referenced\n * by `[chart:<chartId>]` markers so prose isn't blocked on chart\n * generation; the host UI fetches the cached spec by id once ready.\n * Space description and serialized-space lookups are available for\n * grounding when the agent needs schema context.\n *\n * Each tool's `execute` pulls the per-request\n * {@link WorkspaceClient} off `ctx.requestContext` (stamped by\n * `MastraServer` under {@link MASTRA_USER_KEY}) and the per-call\n * `writer` / `abortSignal` off `ctx`, so the tools are stateless\n * across requests and the central agent owns the loop.\n *\n * The tools talk to Genie directly via `@dbx-tools/genie`\n * (`genieEventChat`); statement-row fetching is delegated to\n * {@link fetchStatementData} from `./statement.js`, which wraps\n * the workspace `statementExecution.getStatement` API. AppKit's\n * stock `genie` plugin is honored only for its `spaces` config\n * so existing AppKit-style wiring keeps working without change.\n *\n * Suggested orchestration prompt for the central agent lives in\n * {@link GENIE_INSTRUCTIONS}; compose it into the agent's own\n * `instructions` when you want the canonical \"how to drive the\n * Genie tools\" guidance.\n *\n * @module\n */\n\nimport {\n  CacheManager,\n  ConfigurationError,\n  ExecutionError,\n  genie,\n  ValidationError,\n} from \"@databricks/appkit\";\nimport { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { plugin } from \"@dbx-tools/appkit\";\nimport { chat, space as genieSpace } from \"@dbx-tools/genie\";\nimport { error, log, string } from \"@dbx-tools/shared-core\";\nimport { genieModel, type GenieMessage } from \"@dbx-tools/shared-genie\";\nimport { wire, type MastraWriter, type StartedEvent } from \"@dbx-tools/shared-mastra\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport { MASTRA_THREAD_ID_KEY } from \"@mastra/core/request-context\";\nimport { createTool } from \"@mastra/core/tools\";\nimport { z } from \"zod\";\n\nimport type { MastraTools } from \"./agents\";\nimport { chartPlannerRequestSchema, prepareChart } from \"./chart\";\nimport { MASTRA_USER_KEY, resolveUserKey } from \"./config\";\nimport type { MastraPluginConfig, User } from \"./config\";\nimport { fetchStatementData } from \"./statement\";\nimport { safeWrite } from \"./writer\";\n\nconst logger = log.logger(\"mastra/genie\");\n\n/** Default alias used when a single unnamed Genie space is wired up. */\nexport const DEFAULT_GENIE_ALIAS = \"default\";\n\n/* --------------------------- config types --------------------------- */\n\n/** Per-space Genie agent configuration. */\nexport interface GenieSpaceConfig {\n  /** Genie `space_id`. Required; resolves via `client.genie.getSpace`. */\n  spaceId: string;\n  /**\n   * Optional human-readable description appended to the per-space\n   * tool descriptions so the calling LLM has hints about *what\n   * data* this space covers (e.g. \"orders, returns,\n   * fulfillment\"). When omitted, only the space's own\n   * `description` (fetched on first use of `get_space_description`)\n   * is shown.\n   */\n  hint?: string;\n}\n\n/** Map of alias -> space config. Accepts either explicit objects or bare space ids. */\nexport type GenieSpacesConfig = Record<string, GenieSpaceConfig | string>;\n\n/* ------------------------- ctx helpers ------------------------- */\n\n/**\n * Narrow view of the second arg Mastra passes to a tool's\n * `execute(input, ctx)`. Captures the fields the Genie tools\n * actually read - `requestContext` (for user / conversation\n * state), `writer` (for streaming events to the host UI), and\n * `abortSignal` (for per-call cancellation).\n */\ntype ToolExecuteCtx =\n  | {\n      requestContext?: RequestContext;\n      writer?: MastraWriter;\n      abortSignal?: AbortSignal;\n    }\n  | undefined;\n\n/**\n * Pull the per-request {@link WorkspaceClient} off the active\n * `RequestContext`. The Mastra plugin's server middleware stamps\n * a {@link User} on the context under {@link MASTRA_USER_KEY}\n * for every request; tools fail loudly when it's missing because\n * that means the Mastra plugin isn't running (e.g. a tool was\n * invoked outside the chat route).\n */\nfunction requireClient(\n  ctx: ToolExecuteCtx,\n  toolId: string,\n): {\n  client: WorkspaceClient;\n  requestContext: RequestContext;\n} {\n  const requestContext = ctx?.requestContext;\n  if (!requestContext) {\n    throw ConfigurationError.resourceNotFound(\n      `${toolId} request context`,\n      \"Invoke the tool from an agent turn served by the mastra plugin.\",\n    );\n  }\n  const user = requestContext.get(MASTRA_USER_KEY) as User | undefined;\n  if (!user) {\n    throw ConfigurationError.resourceNotFound(\n      `${toolId} user context`,\n      \"Invoke the tool from an agent turn served by the mastra plugin, which stamps the AppKit user on the Mastra request context.\",\n    );\n  }\n  return { client: user.executionContext.client, requestContext };\n}\n\n/**\n * Lowercased placeholder strings we reject at the `ask_genie`\n * boundary so the LLM doesn't spend a Genie round-trip on a\n * non-question. Genie politely answers any of these with \"Your\n * request '...' does not relate to...\" which is pure UI noise.\n * Kept narrow on purpose - real questions sometimes start with\n * one of these tokens, so we only match the FULL trimmed string.\n */\nconst PLACEHOLDER_QUESTIONS = new Set([\n  \"noop\",\n  \"no-op\",\n  \"skip\",\n  \"none\",\n  \"n/a\",\n  \"na\",\n  \"null\",\n  \"undefined\",\n  \"test\",\n  \"placeholder\",\n]);\n\n/* ----------------------- conversation state ----------------------- */\n\n/**\n * Estimated Genie conversation lifetime in seconds. Databricks\n * publishes no official TTL on the conversation resource itself;\n * community projects (e.g. the open-source Databricks Genie Bot)\n * converge on 4 hours of inactivity as a safe operating window.\n * Treat this as an estimate that gets *extended on every use* by\n * re-setting the cache entry after each successful turn (sliding\n * TTL via re-`set`). When the estimate ends up wrong (conversation\n * deleted, expired upstream, cross-space referenced), `ask_genie`\n * catches the SDK's `RESOURCE_DOES_NOT_EXIST`/404 and transparently\n * starts a fresh conversation.\n */\nconst CONVERSATION_TTL_SEC = 4 * 60 * 60;\n\n/** Cache namespace prefix so coexisting Mastra caches don't collide. */\nconst CONVERSATION_CACHE_NAMESPACE = \"mastra:genie:conversation\";\n\n/**\n * Build the per-request {@link RequestContext} key the active\n * Genie `conversation_id` lives under for `spaceId`. Scoped by\n * space so an app calling two Genie spaces in one request keeps\n * each conversation distinct (Genie conversation ids are\n * space-scoped on the wire). The same `RequestContext` instance\n * flows from the central agent through to every `ask_genie`\n * invocation, so writes on one call are visible on the next\n * without an explicit shared ref.\n */\nconst conversationContextKey = (spaceId: string): string =>\n  `mastra__genie_conversation__${spaceId}`;\n\n/**\n * Read the active Genie `conversation_id` for `spaceId` off the\n * per-request {@link RequestContext}. Returns `undefined` when no\n * conversation has been started yet this request.\n */\nfunction readContextConversationId(\n  requestContext: RequestContext,\n  spaceId: string,\n): string | undefined {\n  return requestContext.get(conversationContextKey(spaceId)) as string | undefined;\n}\n\n/**\n * Write the active Genie `conversation_id` for `spaceId` onto the\n * per-request {@link RequestContext}. Subsequent `ask_genie` calls\n * in this request will reuse it.\n */\nfunction writeContextConversationId(\n  requestContext: RequestContext,\n  spaceId: string,\n  conversationId: string | undefined,\n): void {\n  requestContext.set(conversationContextKey(spaceId), conversationId);\n}\n\n/**\n * Build the canonical cache key for a `(spaceId, threadId)` pair, owned by\n * `userKey`. Returns `undefined` when `threadId` is missing - callers should\n * skip caching entirely in that case (no Mastra memory wired up).\n *\n * The identity is part of the key because a client picks its own `threadId`\n * (the thread-selection header / `?threadId=`), so the id alone does not\n * establish who owns the Genie conversation behind it.\n */\nasync function conversationCacheKey(\n  spaceId: string,\n  threadId: string | undefined,\n  userKey: string,\n): Promise<string | undefined> {\n  if (!threadId) return undefined;\n  return (await CacheManager.getInstance()).generateKey(\n    [CONVERSATION_CACHE_NAMESPACE, spaceId, threadId],\n    userKey,\n  );\n}\n\n/**\n * Read the cached Genie conversation id for `(spaceId, threadId)`.\n * Returns `undefined` on miss, on expiry, or when the cache layer\n * is unhealthy - never throws. The TTL is renewed via re-`set`\n * after each successful turn (see {@link saveCachedConversationId}).\n */\nasync function readCachedConversationId(cacheKey: string | undefined): Promise<string | undefined> {\n  if (!cacheKey) return undefined;\n  try {\n    const v = await CacheManager.getInstanceSync().get<string>(cacheKey);\n    return v ?? undefined;\n  } catch (err) {\n    logger.warn(\"conversation-cache:read-error\", {\n      error: error.errorMessage(err),\n    });\n    return undefined;\n  }\n}\n\n/**\n * Persist the active conversation id under `cacheKey`, refreshing\n * its TTL. Idempotent; no-op when `cacheKey` or `conversationId`\n * is missing. Re-setting the same key acts as a sliding TTL: every\n * turn that uses the conversation extends the window by another\n * {@link CONVERSATION_TTL_SEC} seconds.\n */\nasync function saveCachedConversationId(\n  cacheKey: string | undefined,\n  conversationId: string | undefined,\n): Promise<void> {\n  if (!cacheKey || !conversationId) return;\n  try {\n    await CacheManager.getInstanceSync().set(cacheKey, conversationId, {\n      ttl: CONVERSATION_TTL_SEC,\n    });\n  } catch (err) {\n    logger.warn(\"conversation-cache:write-error\", {\n      error: error.errorMessage(err),\n    });\n  }\n}\n\n/** Force-evict a cached conversation id. Used on the stale-id recovery path. */\nasync function evictCachedConversationId(cacheKey: string | undefined): Promise<void> {\n  if (!cacheKey) return;\n  try {\n    await CacheManager.getInstanceSync().delete(cacheKey);\n  } catch (err) {\n    logger.warn(\"conversation-cache:delete-error\", {\n      error: error.errorMessage(err),\n    });\n  }\n}\n\n/**\n * Lazy-seed the active Genie `conversation_id` for `spaceId` from\n * the cross-request cache onto the per-request `RequestContext`.\n * No-op when the slot is already populated (subsequent\n * `ask_genie` calls in the same turn) so we hit the cache at most\n * once per request per space.\n */\nasync function ensureConversationSeeded(\n  requestContext: RequestContext,\n  spaceId: string,\n  cacheKey: string | undefined,\n): Promise<void> {\n  if (readContextConversationId(requestContext, spaceId)) return;\n  const cached = await readCachedConversationId(cacheKey);\n  if (cached) writeContextConversationId(requestContext, spaceId, cached);\n}\n\n/* ------------------------ prepare_chart input ------------------------ */\n\n/**\n * Agent-facing `prepare_chart` input schema. Reuses\n * {@link chartPlannerRequestSchema} (the dataset-driven planner\n * contract) but swaps the inline `data` field for a Genie\n * `statement_id` the tool resolves into rows server-side.\n * `title` is loosened to optional - the planner falls back to a\n * generic placeholder when the agent doesn't supply one.\n *\n * Shaped to match Genie's wire form - `statement_id` (snake)\n * mirrors `query_result.statement_id` and the `get_statement`\n * tool's input field name, so the LLM only ever sees one\n * spelling for the same identifier.\n */\nconst prepareChartRequestSchema = chartPlannerRequestSchema\n  .omit({ data: true, title: true })\n  .extend({\n    statement_id: z\n      .string()\n      .min(1, \"statement_id is required\")\n      .describe(\n        string.toDescription(`\n          Genie \\`statement_id\\` to chart. Read from\n          \\`message.query_result.statement_id\\` or\n          \\`message.attachments[*].query.statement_id\\` returned by\n          \\`ask_genie\\`.\n        `),\n      ),\n    title: chartPlannerRequestSchema.shape.title.optional(),\n  });\n\n/* ----------------------------- tool ids ----------------------------- */\n\n/**\n * Suffix appended to per-space tool ids when the alias isn't the\n * well-known `default`. Single-space deployments get the bare\n * names (`ask_genie`, `get_space_description`, ...); multi-space\n * deployments get `ask_genie_<alias>` etc. so each space's tools\n * stay disambiguated in the central agent's tool registry.\n */\nfunction aliasSuffix(alias: string): string {\n  if (alias === DEFAULT_GENIE_ALIAS) return \"\";\n  const slug = string.toIdentifier(alias);\n  return slug ? `_${slug}` : \"\";\n}\n\n/* --------------------------- per-space tools --------------------------- */\n\n/**\n * Drop `suggested_questions` attachments from a {@link GenieMessage}\n * before handing it to the central LLM. Those entries already\n * surface in the UI as one-tap pills via the writer's\n * `suggested_questions` events (see `collectSuggestions` on the\n * client); if we let them ride back in the tool result the LLM\n * tends to quote them inline in its prose, double-showing the\n * same questions and stepping on the dedicated suggestion UI.\n * Query / text / row attachments are preserved so the model can\n * still read `statement_id`, SQL, and the answer text.\n */\nfunction stripSuggestedQuestions(message: GenieMessage): GenieMessage {\n  const attachments = message.attachments;\n  if (!attachments || attachments.length === 0) return message;\n  const filtered = attachments.filter((att) => !att.suggested_questions);\n  if (filtered.length === attachments.length) return message;\n  return { ...message, attachments: filtered };\n}\n\nfunction buildAskGenieTool(opts: { spaceId: string; alias: string; hint?: string }) {\n  const { spaceId, alias, hint } = opts;\n  const toolId = `ask_genie${aliasSuffix(alias)}`;\n  const hintLine = hint ? ` (${hint})` : \"\";\n  return createTool({\n    id: toolId,\n    description: string.toDescription(`\n      Ask the Genie space \"${alias}\"${hintLine} ONE focused\n      natural-language sub-question and wait for the turn to\n      complete. Genie answers best when each call covers a\n      single metric / dimension / time window, so expect to\n      call this tool MULTIPLE TIMES per user turn (typically\n      two to six) and let the results from earlier calls inform\n      later ones - that's the normal pattern, not the exception.\n      Do NOT try to cram a multi-part question into a single\n      call; decompose first, then ask each piece.\n\n      Returns the final \\`GenieMessage\\`. Rows are NOT included -\n      the Genie wire response carries the \\`statement_id\\` for any\n      SQL that ran (at \\`message.query_result.statement_id\\` or the\n      first attachment's \\`query.statement_id\\`); call\n      \\`get_statement\\` with that id only when you need to read\n      the underlying values to reason about them. If you just\n      want to display the rows to the user, embed a\n      \\`[data:<statement_id>]\\` marker in your prose instead -\n      the host UI fetches and renders the rows on its own. Wire\n      events (status, thinking, sql) stream to the user\n      automatically while the call is in flight.\n    `),\n    inputSchema: z.object({\n      question: z\n        .string()\n        .min(1, \"question is required\")\n        .describe(\n          string.toDescription(`\n            ONE focused natural-language question about the data in this\n            space, covering a single metric / dimension / time window\n            (e.g. \"What was Q3 revenue by region?\"). Decompose a\n            multi-part ask into separate calls rather than combining it\n            here.\n          `),\n        ),\n    }),\n    outputSchema: z.object({\n      message: genieModel.GenieMessageSchema,\n    }),\n    execute: async ({ question }, ctxRaw) => {\n      const ctx = ctxRaw as ToolExecuteCtx;\n      const { client, requestContext } = requireClient(ctx, toolId);\n      const writer = ctx?.writer;\n      const signal = ctx?.abortSignal;\n      const threadId = requestContext.get(MASTRA_THREAD_ID_KEY) as string | undefined;\n\n      // Bounce placeholder / no-op questions BEFORE spending a Genie\n      // round-trip on them. Genie answers any of these with \"Your\n      // request 'noop' does not relate to...\" - useless noise that\n      // shows up in the UI and eats one of the workspace's 5\n      // questions/minute. Returning a clear error here surfaces the\n      // issue to the agent loop so the model corrects course instead\n      // of wasting a turn.\n      const trimmed = question.trim();\n      if (trimmed.length === 0 || PLACEHOLDER_QUESTIONS.has(trimmed.toLowerCase())) {\n        throw ValidationError.invalidValue(\n          `${toolId}.question`,\n          question,\n          \"a real natural-language question, not a placeholder; skip the call instead\",\n        );\n      }\n\n      // Seed the active Genie `conversation_id` onto `RequestContext`\n      // from the cross-request cache when a Mastra `threadId` is\n      // present so multi-turn chats reuse the same Genie conversation\n      // (and Genie's accumulated context) across separate user turns.\n      // The same `RequestContext` is reused across every `ask_genie`\n      // call within one user turn, so `ensureConversationSeeded`\n      // hits the cache at most once per request per space.\n      const cacheKey = await conversationCacheKey(\n        spaceId,\n        threadId,\n        resolveUserKey(requestContext),\n      );\n      await ensureConversationSeeded(requestContext, spaceId, cacheKey);\n\n      // Fire the lifecycle `started` event before any LLM /\n      // network round-trip so the host UI can pop a \"Thinking...\"\n      // pill the instant the model decides to delegate.\n      const startedEvent: StartedEvent = {\n        type: \"started\",\n        spaceId,\n        content: question,\n      };\n      await safeWrite(logger, writer, startedEvent);\n\n      // Single turn of `genieEventChat`. Hoisted into a closure so\n      // we can re-run it after evicting a stale `conversation_id`\n      // without duplicating the event-loop body.\n      const runTurn = async (): Promise<GenieMessage> => {\n        const seedConversationId = readContextConversationId(requestContext, spaceId);\n        let finalMessage: GenieMessage | undefined;\n        for await (const event of chat.genieEventChat(spaceId, question, {\n          workspaceClient: client,\n          ...(seedConversationId ? { conversationId: seedConversationId } : {}),\n          ...(signal ? { context: signal } : {}),\n        })) {\n          if (event.type !== \"message\") {\n            await safeWrite(logger, writer, event);\n          }\n          const eventConversationId = event.conversation_id;\n          if (eventConversationId) {\n            writeContextConversationId(requestContext, spaceId, eventConversationId);\n          }\n          if (event.type === \"result\") {\n            finalMessage = event.message;\n          }\n        }\n        if (!finalMessage) {\n          throw ExecutionError.missingData(\"Genie result event\");\n        }\n        return finalMessage;\n      };\n\n      let finalMessage: GenieMessage;\n      try {\n        finalMessage = await runTurn();\n      } catch (err) {\n        // The seeded `conversation_id` was rejected by Genie - most\n        // commonly because it was deleted upstream, expired past\n        // Databricks' (undocumented) lifetime, or was minted in a\n        // different space. Drop both the cached id AND the\n        // per-request value so the retry calls `startConversation`,\n        // and try once more. Only retry when we *had* a seeded id -\n        // a fresh call that 404s shouldn't loop.\n        const seeded = readContextConversationId(requestContext, spaceId);\n        if (seeded && error.errorContext(err).notAccessible) {\n          logger.warn(\"conversation-cache:stale, resetting\", {\n            spaceId,\n            conversationId: seeded,\n            error: error.errorMessage(err),\n          });\n          await evictCachedConversationId(cacheKey);\n          writeContextConversationId(requestContext, spaceId, undefined);\n          finalMessage = await runTurn();\n        } else {\n          throw err;\n        }\n      }\n\n      // Refresh the cache entry on every successful turn. Re-setting\n      // the same key both persists newly-minted ids (cache miss path)\n      // and extends the TTL on active conversations (sliding window).\n      await saveCachedConversationId(cacheKey, readContextConversationId(requestContext, spaceId));\n\n      return { message: stripSuggestedQuestions(finalMessage) };\n    },\n  });\n}\n\nfunction buildSpaceDescriptionTool(opts: { spaceId: string; alias: string }) {\n  const { spaceId, alias } = opts;\n  const toolId = `get_space_description${aliasSuffix(alias)}`;\n  return createTool({\n    id: toolId,\n    description: string.toDescription(`\n      Return the Genie space \"${alias}\"'s title, description, and\n      warehouse id. Cheap (single REST call, no LLM round-trip).\n      Call this FIRST on any user turn that's going to touch\n      \\`ask_genie\\`, unless the same description already landed\n      earlier in this conversation - the title + description tell\n      you what tables, metrics, and time windows the space\n      actually covers, which is what lets you decompose the\n      user's question into the right \\`ask_genie\\` sub-questions.\n    `),\n    inputSchema: z.object({}),\n    outputSchema: z.object({\n      spaceId: z.string(),\n      title: z.string().optional(),\n      description: z.string().optional(),\n      warehouseId: z.string().optional(),\n    }),\n    execute: async (_input, ctxRaw) => {\n      const ctx = ctxRaw as ToolExecuteCtx;\n      const { client } = requireClient(ctx, toolId);\n      const signal = ctx?.abortSignal;\n      // Route through the package's central Genie space fetch. The\n      // description surface (title / description / warehouse id) lives\n      // on the directory-listing shape, so skip the larger\n      // `serialized_space` payload here.\n      const space = await genieSpace.getGenieSpace(spaceId, {\n        workspaceClient: client,\n        serialized: false,\n        ...(signal ? { context: signal } : {}),\n      });\n      return {\n        spaceId,\n        ...(space.title ? { title: space.title } : {}),\n        ...(space.description ? { description: space.description } : {}),\n        ...(space.warehouse_id ? { warehouseId: space.warehouse_id } : {}),\n      };\n    },\n  });\n}\n\nfunction buildSpaceSerializedTool(opts: { spaceId: string; alias: string }) {\n  const { spaceId, alias } = opts;\n  const toolId = `get_space_serialized${aliasSuffix(alias)}`;\n  return createTool({\n    id: toolId,\n    description: string.toDescription(`\n      Return the full \\`GenieSpace\\` JSON for the \"${alias}\" space.\n      Use only when you need exact column / table identifiers\n      \\`get_space_description\\` doesn't expose. Larger payload, so\n      prefer the description tool when it's enough.\n    `),\n    inputSchema: z.object({}),\n    outputSchema: z.object({ space: z.unknown() }),\n    execute: async (_input, ctxRaw) => {\n      const ctx = ctxRaw as ToolExecuteCtx;\n      const { client } = requireClient(ctx, toolId);\n      const signal = ctx?.abortSignal;\n      // Central Genie space fetch with the opt-in `serialized_space`\n      // blob (catalogs, tables, sample questions, prompts) that the\n      // typed SDK `getSpace` omits - the whole point of this tool.\n      const space = await genieSpace.getGenieSpace(spaceId, {\n        workspaceClient: client,\n        ...(signal ? { context: signal } : {}),\n      });\n      return { space };\n    },\n  });\n}\n\n/* --------------------------- shared tools --------------------------- */\n\n/**\n * Default row cap for {@link buildGetStatementTool} when the agent\n * doesn't supply a `limit`. Sized to keep result sets out of the\n * model context unless the agent explicitly opts into more rows -\n * the cheap shape (column names + a handful of representative\n * rows) is usually enough to reason about a query.\n */\nconst DEFAULT_STATEMENT_LIMIT = 50;\n\nfunction buildGetStatementTool() {\n  const toolId = \"get_statement\";\n  return createTool({\n    id: toolId,\n    description: string.toDescription(`\n      Fetch the rows of a Genie statement by its \\`statement_id\\` (the\n      value at \\`message.query_result.statement_id\\` or\n      \\`message.attachments[*].query.statement_id\\` returned from\n      \\`ask_genie\\`). Use this ONLY when you need to read the underlying\n      values to reason about them in your reply - e.g. naming the\n      largest row, computing a delta the visualization wouldn't already\n      convey, or filtering down to a specific record. If you'd just be\n      reciting numbers the user will see anyway, skip the call and\n      embed a \\`[data:<statement_id>]\\` marker in your prose instead;\n      the host UI fetches and renders the rows on its own. \\`limit\\`\n      caps the number of rows returned (defaults to\n      ${DEFAULT_STATEMENT_LIMIT}). \\`rowCount\\` reflects the full\n      upstream total - compare to \\`rows.length\\` to detect truncation.\n    `),\n    inputSchema: z.object({\n      statement_id: z\n        .string()\n        .min(1, \"statement_id is required\")\n        .describe(\n          string.toDescription(`\n            Genie \\`statement_id\\` whose rows to read. Take it from\n            \\`message.query_result.statement_id\\` or\n            \\`message.attachments[*].query.statement_id\\` on an\n            \\`ask_genie\\` result; it is never a value you construct.\n          `),\n        ),\n      limit: z\n        .number()\n        .int()\n        .nonnegative()\n        .optional()\n        .describe(\n          \"Max rows to return. Defaults to a small sample; raise only when more rows are genuinely needed.\",\n        ),\n    }),\n    outputSchema: z.object({\n      columns: z.array(z.string()),\n      rows: z.array(z.record(z.string(), z.unknown())),\n      rowCount: z.number(),\n      truncated: z.boolean(),\n    }),\n    execute: async ({ statement_id, limit }, ctxRaw) => {\n      const ctx = ctxRaw as ToolExecuteCtx;\n      const { client } = requireClient(ctx, toolId);\n      const signal = ctx?.abortSignal;\n      const effectiveLimit = limit ?? DEFAULT_STATEMENT_LIMIT;\n      const data = await fetchStatementData(client, statement_id, {\n        limit: effectiveLimit,\n        ...(signal ? { signal } : {}),\n      });\n      return {\n        columns: data.columns,\n        rows: data.rows,\n        rowCount: data.rowCount,\n        truncated: data.rows.length < data.rowCount,\n      };\n    },\n  });\n}\n\n/**\n * `prepare_chart` Mastra tool. Thin wrapper over\n * {@link prepareChart} that resolves the dataset by fetching the\n * Genie statement's rows on demand. The tool mints a `chartId`\n * synchronously, caches an empty placeholder, and kicks off the\n * planner in the background so the agent loop never blocks. The\n * host UI resolves `[chart:<chartId>]` markers by reading the\n * cached {@link Chart} entry (1h TTL).\n *\n * Space-agnostic: a Genie `statement_id` is workspace-scoped, so\n * one shared `prepare_chart` tool covers every wired Genie space.\n *\n * Cancellation: deliberately does NOT forward the per-call\n * `abortSignal` to {@link prepareChart}. The planner task is\n * fire-and-forget background work; the tool's own `execute`\n * resolves the moment the `chartId` is minted, so the per-call\n * signal aborts the second the tool returns. The 1h cache TTL\n * caps abandoned entries.\n */\nfunction buildPrepareChartTool(opts: { config: MastraPluginConfig }) {\n  const { config } = opts;\n  const toolId = \"prepare_chart\";\n  return createTool({\n    id: toolId,\n    description: string.toDescription([\n      `\n        Queue a chart for the rows of a Genie statement. Mints a\n        short \\`chartId\\` synchronously and kicks off a BACKGROUND\n        task that fetches the statement's rows, runs the\n        chart-planner to pick a chart type and Echarts spec, and\n        caches the result under the \\`chartId\\` for one hour. The\n        host UI fetches the cached chart on its own once it lands.\n      `,\n      `\n        To display the chart in your reply, embed\n        \\`[chart:<chartId>]\\` on its own line at the position you\n        want it to appear, using the EXACT \\`chartId\\` string this\n        call returned. Never construct a chart id yourself (it is\n        not the \\`statement_id\\` or any variation of it) - only a\n        value returned by this tool resolves to a real chart. The\n        tool returns immediately - do NOT wait or call it again to\n        \"check progress\"; the chart resolves asynchronously on the\n        host UI's side.\n      `,\n      `\n        Use this only when the data has a story a chart conveys\n        better than a table (trends, rankings, distributions,\n        parts-of-a-whole). For raw rows, embed\n        \\`[data:<statement_id>]\\` instead and skip this tool.\n      `,\n    ]),\n    inputSchema: prepareChartRequestSchema,\n    outputSchema: wire.ChartSchema.pick({ chartId: true }),\n    execute: async (request, ctxRaw) => {\n      const ctx = ctxRaw as ToolExecuteCtx;\n      const { client, requestContext } = requireClient(ctx, toolId);\n      return prepareChart({\n        config,\n        userKey: resolveUserKey(requestContext),\n        ...(request.title ? { title: request.title } : {}),\n        ...(request.description ? { description: request.description } : {}),\n        resolveData: (taskSignal) =>\n          fetchStatementData(client, request.statement_id, {\n            ...(taskSignal ? { signal: taskSignal } : {}),\n          }),\n        ...(ctx?.requestContext ? { requestContext: ctx.requestContext } : {}),\n      });\n    },\n  });\n}\n\n/* --------------------------- orchestration prompt --------------------------- */\n\n/**\n * Suggested orchestration prompt for the central agent that owns\n * the Genie tools. Compose into your agent's `instructions` to\n * get the canonical \"decompose questions, ask Genie focused\n * sub-questions, place data / chart markers in prose\" behavior:\n *\n * ```ts\n * createAgent({\n *   instructions: `${myAgentInstructions}\\n\\n${GENIE_INSTRUCTIONS}`,\n *   tools(plugins) {\n *     return { ...plugins.genie?.toolkit() };\n *   },\n * });\n * ```\n *\n * The prompt references the bare tool names (`ask_genie`,\n * `get_space_description`, `get_space_serialized`,\n * `get_statement`, `prepare_chart`) used for the single-space\n * default alias. Multi-space deployments should write their own\n * variant that names the suffixed per-space tools\n * (e.g. `ask_genie_sales`).\n */\nexport const GENIE_INSTRUCTIONS = string.toDescription([\n  \"Genie orchestration. For every user question that needs SQL-backed data:\",\n  {\n    numbered: [\n      `\n        Start by calling \\`get_space_description\\` to ground yourself\n        in what the space covers (tables, metrics, time windows),\n        unless you already saw the same description earlier in this\n        conversation. Reach for \\`get_space_serialized\\` only when you\n        need exact column / table identifiers the description doesn't\n        expose - it's a much larger payload.\n      `,\n      `\n        Decompose the user's question into focused sub-questions\n        BEFORE asking Genie anything. One sub-question per distinct\n        metric, dimension, or time window. Then call \\`ask_genie\\`\n        once per sub-question - usually two to six calls per turn,\n        and let earlier answers inform what you ask next. Cramming\n        a multi-part question into one \\`ask_genie\\` call almost\n        always produces a worse answer than asking the pieces\n        separately. Only collapse to a single call when the question\n        is genuinely atomic (\"what was Q3 revenue?\").\n\n        Worked example: user asks \"How did SKU 1234's revenue\n        compare to its category average last quarter, and which\n        regions drove the gap?\" Decomposes to: (a) \\`ask_genie\\`\n        for SKU 1234's Q3 revenue, (b) \\`ask_genie\\` for the\n        category-average Q3 revenue, (c) \\`ask_genie\\` for SKU\n        1234's Q3 revenue split by region. Three focused calls,\n        each grounded in the prior results.\n      `,\n      `\n        Each \\`ask_genie\\` call returns the terminal \\`GenieMessage\\`.\n        When the turn ran SQL the result has a \\`statement_id\\` - read\n        it from \\`message.query_result.statement_id\\` (or the first\n        attachment's \\`query.statement_id\\`).\n      `,\n      [\n        `\n          To DISPLAY a result set in your reply, embed a marker on its\n          own line where the visualization should appear. Two marker\n          shapes:\n        `,\n        {\n          bullets: [\n            `\n              \\`[data:<statement_id>]\\` - render the rows as a table.\n              Use this when there's no clear visual story (long lists,\n              reference data, single-row results, or the user just\n              wants to see the data). Embed the marker directly; no\n              tool call needed.\n            `,\n            `\n              \\`[chart:<chartId>]\\` - render the rows as a chart. To\n              get a \\`<chartId>\\`, call \\`prepare_chart\\` with the\n              statement's id (and an optional \\`title\\` / one-line\n              \\`description\\` of the insight to surface). The tool\n              returns the \\`chartId\\` synchronously and prepares the\n              chart spec in the background; embed the returned id as\n              \\`[chart:<chartId>]\\` on its own line wherever the\n              chart should appear. Use a chart when the data has a\n              story a visual conveys better than a table (trends,\n              rankings, distributions, parts-of-a-whole).\n\n              NEVER invent or hand-build a \\`<chartId>\\`. A valid\n              \\`<chartId>\\` is the opaque token a \\`prepare_chart\\`\n              call returned to you in THIS turn - nothing else. It\n              is NOT a \\`statement_id\\`, and it is NOT a\n              \\`statement_id\\` prefix with a label appended (e.g.\n              \\`01f1...-region-fill\\`). If you have not called\n              \\`prepare_chart\\` and received an id back, do not write\n              a \\`[chart:...]\\` marker at all - use \\`[data:...]\\`\n              instead. A fabricated chart id renders nothing and\n              wastes a request.\n            `,\n          ],\n        },\n        `\n          The host UI resolves both markers on its own once it sees\n          them - you do NOT need to call \\`get_statement\\` just to\n          display data, and you do NOT need to wait on\n          \\`prepare_chart\\` (it returns the id immediately and the\n          host UI fetches the cached chart later). Pick at most one\n          marker per statement; don't chart AND table the same result\n          side by side.\n        `,\n      ],\n      `\n        Call \\`get_statement(statement_id, limit?)\\` ONLY when you need\n        to read the actual values to reason about them (e.g. naming a\n        specific row, computing a delta the table or chart wouldn't\n        show, or sanity-checking a result before interpreting it). If\n        you'd just be reciting numbers the visualization already shows,\n        skip the call and use a marker instead. \\`limit\\` defaults to a\n        small sample; raise it only when you genuinely need more rows.\n      `,\n      `\n        Compose your final reply as plain prose. Interleave paragraphs\n        with \\`[data:...]\\` / \\`[chart:...]\\` markers wherever a result\n        should render. Don't dump all markers at the end - place each\n        one next to the prose that interprets it. Don't restate every\n        number the visualization already shows; call out deltas,\n        anomalies, takeaways.\n      `,\n    ],\n  },\n]);\n\n/* --------------------- multi-alias surface --------------------- */\n\n/**\n * Normalize the {@link GenieSpacesConfig} record. Bare-string\n * entries (`{ default: \"01ef...\" }`) get wrapped as\n * `{ spaceId: \"01ef...\" }`; object entries pass through unchanged.\n *\n * @throws ConfigurationError when an alias is present but carries no space id\n *   (`{ default: process.env.DATABRICKS_GENIE_SPACE_ID }` with the variable\n *   unset). An alias that resolves to nothing is a wiring contradiction: the\n *   agent would advertise no Genie tool for a space the deployment believes it\n *   configured, so it fails at construction instead of going quiet.\n */\nexport function normalizeGenieSpaces(\n  spaces: GenieSpacesConfig | Record<string, string | GenieSpaceConfig | undefined> | undefined,\n): Record<string, GenieSpaceConfig> {\n  if (!spaces) return {};\n  const out: Record<string, GenieSpaceConfig> = {};\n  for (const [alias, value] of Object.entries(spaces)) {\n    const spaceId = typeof value === \"string\" ? value : value?.spaceId;\n    if (!spaceId) throw missingSpaceId(alias);\n    out[alias] = typeof value === \"string\" ? { spaceId } : value!;\n  }\n  return out;\n}\n\n/** Config contradiction: an alias present in `genieSpaces` with no space id. */\nfunction missingSpaceId(alias: string): ConfigurationError {\n  const envHint =\n    alias === DEFAULT_GENIE_ALIAS\n      ? \"Set DATABRICKS_GENIE_SPACE_ID, pass the space id inline, or drop the alias.\"\n      : `Pass the space id inline (DATABRICKS_GENIE_SPACE_ID only backs the \"${DEFAULT_GENIE_ALIAS}\" alias) or drop the alias.`;\n  return ConfigurationError.resourceNotFound(`genieSpaces.${alias} space id`, envHint);\n}\n\n/**\n * AppKit `genie` plugin's config shape, derived from the factory\n * itself so it stays in lock-step with the upstream type without\n * deep-importing `IGenieConfig` (which the package's top-level\n * barrel doesn't surface). The plugin's `config` field is\n * `protected` in TS only; the runtime layout is plain object\n * property access, so reading off the instance with a structural\n * cast is safe.\n */\ntype AppKitGenieConfig = NonNullable<Parameters<typeof genie>[0]>;\n\n/**\n * Discover Genie space aliases from every supported source and\n * merge them into a single record. Precedence (highest first):\n *\n *   1. {@link MastraPluginConfig.genieSpaces} on the `mastra(...)`\n *      call. Explicit Mastra wiring always wins so users can\n *      override AppKit's defaults per-agent.\n *   2. AppKit `genie({ spaces: { ... } })` plugin instance. Lets\n *      users keep using the existing AppKit config format\n *      (`genie({ spaces: { sales: \"...\", ops: \"...\" } })`)\n *      without restating the same record on the Mastra plugin.\n *      Read off the live plugin instance via a structural cast\n *      since `Plugin.config` is TS-protected (not runtime-private).\n *   3. `DATABRICKS_GENIE_SPACE_ID` env var (registered under the\n *      well-known `default` alias). Matches the AppKit `genie()`\n *      plugin's fallback behavior so a bare `mastra()` + `genie()`\n *      pair just works.\n *\n * Aliases collide cleanly: a higher-precedence source's value\n * replaces a lower one's wholesale. A source that contributes zero\n * aliases is skipped; a source that names an alias without a space\n * id fails through {@link normalizeGenieSpaces}.\n */\nexport function resolveGenieSpaces(\n  config: MastraPluginConfig,\n  context: plugin.PluginContextLike | undefined,\n): Record<string, GenieSpaceConfig> {\n  const merged: Record<string, GenieSpaceConfig> = {};\n\n  // Source 3 (lowest precedence): env var.\n  const envSpaceId = process.env.DATABRICKS_GENIE_SPACE_ID;\n  if (envSpaceId) {\n    merged[DEFAULT_GENIE_ALIAS] = { spaceId: envSpaceId };\n  }\n\n  // Source 2: AppKit `genie()` plugin instance config. Use a\n  // structural cast - `Plugin.config` is `protected` in TS only,\n  // and the runtime layout is plain object property access.\n  const geniePlugin = plugin.instance(context, genie);\n  if (geniePlugin) {\n    const pluginSpaces = (geniePlugin as unknown as { config?: AppKitGenieConfig }).config?.spaces;\n    if (pluginSpaces) {\n      Object.assign(merged, normalizeGenieSpaces(pluginSpaces));\n    }\n  }\n\n  // Source 1 (highest precedence): explicit Mastra wiring.\n  if (config.genieSpaces) {\n    Object.assign(merged, normalizeGenieSpaces(config.genieSpaces));\n  }\n\n  return merged;\n}\n\n/**\n * Build the flat Mastra tools record for every configured Genie\n * space. Two shared, space-agnostic tools (`get_statement`,\n * `prepare_chart`) are registered once regardless of how many\n * spaces are wired; the per-space tools (`ask_genie`,\n * `get_space_description`, `get_space_serialized`) are suffixed\n * with `_<alias>` for non-default aliases so multi-space\n * deployments stay disambiguated.\n *\n * Returns a record keyed by tool id, ready to spread into the\n * central `Agent`'s `tools` map (or surfaced via the\n * `plugins.genie?.toolkit()` callback). Returns an empty record\n * when `spaces` resolves to zero entries so the caller can spread\n * safely.\n */\nexport function buildGenieTools(opts: {\n  spaces: GenieSpacesConfig | Record<string, GenieSpaceConfig>;\n  config: MastraPluginConfig;\n}): MastraTools {\n  const normalized = normalizeGenieSpaces(opts.spaces);\n  const tools: Record<string, ReturnType<typeof createTool>> = {};\n  if (Object.keys(normalized).length === 0) return tools;\n\n  // Shared, space-agnostic tools.\n  tools.get_statement = buildGetStatementTool();\n  tools.prepare_chart = buildPrepareChartTool({ config: opts.config });\n\n  for (const [alias, space] of Object.entries(normalized)) {\n    const askTool = buildAskGenieTool({\n      spaceId: space.spaceId,\n      alias,\n      ...(space.hint ? { hint: space.hint } : {}),\n    });\n    const descTool = buildSpaceDescriptionTool({ spaceId: space.spaceId, alias });\n    const serTool = buildSpaceSerializedTool({ spaceId: space.spaceId, alias });\n    tools[askTool.id] = askTool;\n    tools[descTool.id] = descTool;\n    tools[serTool.id] = serTool;\n  }\n  return tools;\n}\n\n/**\n * Plugin-toolkit adapter so the `plugins.genie?.toolkit()` lookup\n * inside an agent's `tools(plugins)` callback returns the\n * flat Genie tools record instead of throwing on missing plugin.\n * Mirrors AppKit's `PluginToolkitProvider` shape.\n */\nexport function buildGenieToolkitProvider(opts: {\n  spaces: GenieSpacesConfig | Record<string, GenieSpaceConfig>;\n  config: MastraPluginConfig;\n}): {\n  toolkit(opts?: unknown): MastraTools;\n} {\n  return {\n    toolkit(_opts?: unknown) {\n      return buildGenieTools(opts);\n    },\n  };\n}\n\n/* --------------------------- starter suggestions --------------------------- */\n\n/**\n * Default cap on starter suggestions surfaced to the chat empty\n * state. Sample-question lists can run long (10+ on a curated\n * space); a handful of one-tap prompts reads better than a wall of\n * buttons.\n */\nconst SUGGESTION_LIMIT = 6;\n\n/**\n * How long a space's parsed sample questions stay cached. They're\n * authored config that changes rarely, and the lookup is an extra\n * REST round-trip per chat mount, so a few minutes of caching keeps\n * the empty state instant on reload without going stale for long.\n */\nconst SUGGESTION_CACHE_TTL_MS = 10 * 60_000;\n\n/** Space-id -> cached sample questions with an absolute expiry. */\nconst _suggestionCache = new Map<string, { questions: string[]; expires: number }>();\n\n/** Read a space's cached questions, or `undefined` on miss / expiry. */\nfunction readSuggestionCache(spaceId: string): string[] | undefined {\n  const entry = _suggestionCache.get(spaceId);\n  if (!entry) return undefined;\n  if (entry.expires <= Date.now()) {\n    _suggestionCache.delete(spaceId);\n    return undefined;\n  }\n  return entry.questions;\n}\n\n/** Cache a space's parsed questions for {@link SUGGESTION_CACHE_TTL_MS}. */\nfunction writeSuggestionCache(spaceId: string, questions: string[]): void {\n  _suggestionCache.set(spaceId, {\n    questions,\n    expires: Date.now() + SUGGESTION_CACHE_TTL_MS,\n  });\n}\n\n/**\n * Collect the curated starter questions across every resolved Genie\n * space, deduped and capped. Each space's `sample_questions` are\n * fetched once (cached for {@link SUGGESTION_CACHE_TTL_MS}) via\n * {@link getGenieSpace} + {@link genieSampleQuestions}, then merged in\n * alias-iteration order so a single-space app surfaces that space's\n * questions and a multi-space app round-trips breadth-first up to the\n * cap. A per-space fetch failure degrades to \"no questions for that\n * space\" (logged, not thrown) so one unreachable space never blanks\n * the whole list. Returns `[]` when no spaces are configured.\n */\nexport async function collectSpaceSuggestions(opts: {\n  spaces: Record<string, GenieSpaceConfig>;\n  client: WorkspaceClient;\n  signal?: AbortSignal;\n  limit?: number;\n}): Promise<string[]> {\n  const limit = opts.limit ?? SUGGESTION_LIMIT;\n  const merged: string[] = [];\n  const seen = new Set<string>();\n\n  for (const { spaceId } of Object.values(opts.spaces)) {\n    let questions = readSuggestionCache(spaceId);\n    if (!questions) {\n      try {\n        const space = await genieSpace.getGenieSpace(spaceId, {\n          workspaceClient: opts.client,\n          ...(opts.signal ? { context: opts.signal } : {}),\n        });\n        questions = genieSpace.genieSampleQuestions(space);\n        writeSuggestionCache(spaceId, questions);\n      } catch (err) {\n        logger.warn(\"suggestions:fetch-error\", {\n          spaceId,\n          error: error.errorMessage(err),\n        });\n        questions = [];\n      }\n    }\n    for (const question of questions) {\n      if (seen.has(question)) continue;\n      seen.add(question);\n      merged.push(question);\n      if (merged.length >= limit) return merged;\n    }\n  }\n  return merged;\n}\n"]}