@dbx-tools/shared-mastra 0.9.5 → 0.9.7

package/README.md

@@ -67,10 +67,10 @@ conversation and model.
 ## Parse Embed Markers
 
 ```ts
-import { marker } from "@dbx-tools/shared-mastra";
+import { markers } from "@dbx-tools/shared-mastra";
 
-const parts = marker.parseMarkers("Here is the chart:\n[chart:abc123]");
-const safeText = marker.stripIncompleteMarkerTail(streamingText);
+const parts = markers.parseMarkers("Here is the chart:\n[chart:abc123]");
+const safeText = markers.stripIncompleteMarkerTail(streamingText);
 ```
 
 Markers let an agent mention large or delayed artifacts by id, such as

package/index.ts

@@ -3,16 +3,16 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/shared-mastra";
-export const PACKAGE_VERSION = "0.9.5";
+export const PACKAGE_VERSION = "0.9.7";
 export * as feedback from "./src/feedback.ts";
-export * as marker from "./src/marker.ts";
+export * as markers from "./src/markers.ts";
 export * as override from "./src/override.ts";
 export * as routes from "./src/routes.ts";
 export * as thread from "./src/thread.ts";
 export * as wire from "./src/wire.ts";
 export { MLFLOW_TRACE_ID_HEADER, DEFAULT_FEEDBACK_NAME, DEFAULT_COMMENT_NAME, MastraFeedbackValueSchema, MastraFeedbackRequestSchema, MastraFeedbackResponseSchema } from "./src/feedback.ts";
 export type { MastraFeedbackValue, MastraFeedbackRequest, MastraFeedbackResponse } from "./src/feedback.ts";
-export type { MarkerType, ParsedMarker } from "./src/marker.ts";
+export type { MarkerType, ParsedMarker } from "./src/markers.ts";
 export { MODEL_OVERRIDE_HEADER, MODEL_OVERRIDE_QUERY, MODEL_OVERRIDE_BODY_FIELDS } from "./src/override.ts";
 export { MASTRA_ROUTES } from "./src/routes.ts";
 export { THREAD_ID_HEADER, THREAD_ID_QUERY } from "./src/thread.ts";

package/lib/index.d.ts

@@ -1,14 +1,14 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/shared-mastra";
-export declare const PACKAGE_VERSION = "0.9.5";
+export declare const PACKAGE_VERSION = "0.9.7";
 export * as feedback from "./src/feedback.ts";
-export * as marker from "./src/marker.ts";
+export * as markers from "./src/markers.ts";
 export * as override from "./src/override.ts";
 export * as routes from "./src/routes.ts";
 export * as thread from "./src/thread.ts";
 export * as wire from "./src/wire.ts";
 export { MLFLOW_TRACE_ID_HEADER, DEFAULT_FEEDBACK_NAME, DEFAULT_COMMENT_NAME, MastraFeedbackValueSchema, MastraFeedbackRequestSchema, MastraFeedbackResponseSchema } from "./src/feedback.ts";
 export type { MastraFeedbackValue, MastraFeedbackRequest, MastraFeedbackResponse } from "./src/feedback.ts";
-export type { MarkerType, ParsedMarker } from "./src/marker.ts";
+export type { MarkerType, ParsedMarker } from "./src/markers.ts";
 export { MODEL_OVERRIDE_HEADER, MODEL_OVERRIDE_QUERY, MODEL_OVERRIDE_BODY_FIELDS } from "./src/override.ts";
 export { MASTRA_ROUTES } from "./src/routes.ts";
 export { THREAD_ID_HEADER, THREAD_ID_QUERY } from "./src/thread.ts";

package/lib/index.js

@@ -2,9 +2,9 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/shared-mastra";
-export const PACKAGE_VERSION = "0.9.5";
+export const PACKAGE_VERSION = "0.9.7";
 export * as feedback from "./src/feedback.js";
-export * as marker from "./src/marker.js";
+export * as markers from "./src/markers.js";
 export * as override from "./src/override.js";
 export * as routes from "./src/routes.js";
 export * as thread from "./src/thread.js";
@@ -14,4 +14,4 @@ export { MODEL_OVERRIDE_HEADER, MODEL_OVERRIDE_QUERY, MODEL_OVERRIDE_BODY_FIELDS
 export { MASTRA_ROUTES } from "./src/routes.js";
 export { THREAD_ID_HEADER, THREAD_ID_QUERY } from "./src/thread.js";
 export { MastraClientConfigSchema, DefaultModelResponseSchema, ServingEndpointsResponseSchema, MastraSuggestionsResponseSchema, ChartTypeSchema, ChartResultSchema, ChartSchema, StatementDataSchema, StartedEventSchema, AskGenieDoneEventSchema, MastraGenieErrorEventSchema, SummaryEventSchema, GenieAgentEventSchema, GenieWriterEventSchema, GENIE_PROGRESS_PART_TYPE, GenieProgressPartDataSchema, GenieDatasetDataSchema, GenieDatasetChartSchema, GenieDatasetSchema, GenieSummaryItemSchema, GenieAgentResultSchema } from "./src/wire.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/markers.js

@@ -0,0 +1,133 @@
+/**
+ * Agent-prose embed marker grammar.
+ *
+ * The Mastra agent is instructed to defer visualizations to the host
+ * UI by embedding markers in its markdown reply; the UI parses them
+ * out and swaps in the matching slot. This module is the single
+ * source of truth for that grammar so every consumer parses markers
+ * the same way and can't drift from the shapes documented on
+ * {@link ChartSchema} / {@link StatementDataSchema} in `protocol.ts`
+ * and the instructions the server hands the model.
+ *
+ * One grammar, open-ended type. A marker is `[<type>:<id>]`. The
+ * `<type>` is an opaque token that names the embed kind; the host
+ * resolves it against the generic `/embed/<type>/<id>` route, which
+ * 404s any type the server doesn't register. The grammar does NOT
+ * hard-code the known types - new embed kinds work end to end
+ * without touching this regex. Today the server registers:
+ *
+ *   - `[chart:<chartId>]` - the `<chartId>` is a v4 UUID minted by
+ *     the chart subsystem (`prepare_chart` / `render_data`) and
+ *     resolves to a cached Echarts spec.
+ *   - `[data:<statementId>]` - the `<statementId>` is a Databricks
+ *     statement id (a time-ordered UUID) and resolves to the
+ *     statement's rows.
+ *
+ * The `<id>` of a real embed is UUID-shaped (`8-4-4-4-12` hex): both
+ * id kinds above are UUIDs, just different versions (chart = v4,
+ * statement = v7-style). The grammar deliberately captures ANY
+ * non-bracket id token, not just UUID-shaped ones, so a fabricated
+ * marker the model glued together from a label
+ * (e.g. `[chart:placeholder]` or
+ * `[chart:01f163b6-1eac-region-fill-oos]`) still parses as a marker.
+ * Matching it - rather than letting the broad regex miss it - is what
+ * lets the host UI consume and obscure the bogus marker instead of
+ * leaking the literal `[chart:...]` text into the rendered prose.
+ * Whether an id is a genuine embed is a separate {@link isUuid}
+ * check the caller runs on {@link ParsedMarker.id}.
+ *
+ * Parse everything through {@link parseMarkers}, validate the id with
+ * {@link isUuid}, and branch on the returned {@link ParsedMarker.type}.
+ *
+ * @module
+ */
+/**
+ * Single matcher for ANY embed marker, regardless of type. Matches
+ * `[<type>:<id>]`. Capture group 1 is the marker type token (e.g.
+ * `chart`, `data`); group 2 is the id - any run of non-bracket,
+ * non-whitespace characters, NOT constrained to a UUID shape.
+ *
+ * Neither the type nor the id shape is enumerated here. The type is
+ * left open because the server's resolver registry decides which
+ * types are real and 404s the rest, so a new embed kind needs no
+ * grammar change. The id is left broad on purpose: a fabricated
+ * marker the model emits from a label (e.g. `[chart:placeholder]`)
+ * MUST still match so the host UI can consume and obscure it rather
+ * than leak the literal `[chart:...]` text into the prose. The id is
+ * then validated with {@link isUuid} downstream; non-UUID ids resolve
+ * to no embed.
+ *
+ * Safe to share as a `/g` constant: it's only ever consumed via
+ * {@link String.prototype.matchAll}, which clones the regex and
+ * never advances this object's `lastIndex`. (A `.exec()`/`.test()`
+ * loop would need a fresh regex each time, but we don't do that.)
+ */
+const MARKER_RE = /\[([A-Za-z][A-Za-z0-9_-]*):([^\]\s]+)\]/g;
+/**
+ * UUID matcher (`8-4-4-4-12` hex, any version) anchored to the whole
+ * string. Covers v4 chart ids and time-ordered (v7-style) statement
+ * ids alike. Used by {@link isUuid} to tell a genuine embed id apart
+ * from a label the model fabricated into a marker.
+ */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Whether `id` is a UUID-shaped embed id. The marker grammar
+ * ({@link MARKER_RE}) matches any non-bracket id token so fabricated
+ * markers don't leak as literal prose; this is the guard callers run
+ * to decide whether an id is a real embed (render the slot) or a
+ * bogus label to obscure (drop the marker entirely).
+ */
+export function isUuid(id) {
+    return UUID_RE.test(id);
+}
+/**
+ * Build the exact embed marker the agent should place in prose.
+ *
+ * Tool results return this complete value so the model copies one opaque token
+ * rather than reconstructing it from `type` plus `id`. Reconstruction is where
+ * valid-looking but never-minted UUIDs enter transcripts and produce a 404.
+ */
+export function formatMarker(type, id) {
+    return `[${type}:${id}]`;
+}
+/**
+ * Parse every embed marker out of `text`, in source order. A single
+ * regex pass means matches never overlap, so callers can splice the
+ * spans directly without a sort/dedupe step. This is the one entry
+ * point for marker parsing: type branching runs on the returned
+ * markers. The grammar ({@link MARKER_RE}) matches any non-bracket id
+ * token, so a returned {@link ParsedMarker.id} is NOT guaranteed to
+ * be a real embed id - run it through {@link isUuid} to tell a
+ * genuine embed apart from a fabricated label, which the caller then
+ * obscures rather than rendering.
+ */
+export function parseMarkers(text) {
+    const out = [];
+    for (const match of text.matchAll(MARKER_RE)) {
+        const start = match.index ?? 0;
+        out.push({
+            // Group 1 is the `<type>` token; the server's embed registry
+            // (not this parser) decides whether it's supported.
+            type: match[1] ?? "",
+            id: match[2] ?? "",
+            start,
+            end: start + match[0].length,
+        });
+    }
+    return out;
+}
+/**
+ * Strip a trailing partial marker (`[chart`, `[data:01f1`, ...) that
+ * hasn't received its closing `]` yet. While the model streams
+ * text-deltas a marker arrives across several chunks, and rendering
+ * each interim state would briefly flash the literal `[chart:abc-`
+ * prefix before the closing bracket swaps it for a slot. Hiding any
+ * trailing `[<non-whitespace-non-bracket>...` suffix keeps the prose
+ * stable until either a `]` (full marker) or whitespace (definitely
+ * not a marker) lands. Persisted transcripts never end mid-marker,
+ * so this is a no-op on reload.
+ */
+export function stripIncompleteMarkerTail(text) {
+    return text.replace(/\[[^\s[\]]*$/, "");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markers.js","sourceRoot":"","sources":["../../src/markers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAYH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,SAAS,GAAG,0CAA0C,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,OAAO,GAAG,iEAAiE,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CAAC,EAAU;IAC/B,OAAO,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAgB,EAAE,EAAU;IACvD,OAAO,IAAI,IAAI,IAAI,EAAE,GAAG,CAAC;AAC3B,CAAC;AAcD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QAC/B,GAAG,CAAC,IAAI,CAAC;YACP,6DAA6D;YAC7D,oDAAoD;YACpD,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;YAClB,KAAK;YACL,GAAG,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM;SAC7B,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,yBAAyB,CAAC,IAAY;IACpD,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["/**\n * Agent-prose embed marker grammar.\n *\n * The Mastra agent is instructed to defer visualizations to the host\n * UI by embedding markers in its markdown reply; the UI parses them\n * out and swaps in the matching slot. This module is the single\n * source of truth for that grammar so every consumer parses markers\n * the same way and can't drift from the shapes documented on\n * {@link ChartSchema} / {@link StatementDataSchema} in `protocol.ts`\n * and the instructions the server hands the model.\n *\n * One grammar, open-ended type. A marker is `[<type>:<id>]`. The\n * `<type>` is an opaque token that names the embed kind; the host\n * resolves it against the generic `/embed/<type>/<id>` route, which\n * 404s any type the server doesn't register. The grammar does NOT\n * hard-code the known types - new embed kinds work end to end\n * without touching this regex. Today the server registers:\n *\n *   - `[chart:<chartId>]` - the `<chartId>` is a v4 UUID minted by\n *     the chart subsystem (`prepare_chart` / `render_data`) and\n *     resolves to a cached Echarts spec.\n *   - `[data:<statementId>]` - the `<statementId>` is a Databricks\n *     statement id (a time-ordered UUID) and resolves to the\n *     statement's rows.\n *\n * The `<id>` of a real embed is UUID-shaped (`8-4-4-4-12` hex): both\n * id kinds above are UUIDs, just different versions (chart = v4,\n * statement = v7-style). The grammar deliberately captures ANY\n * non-bracket id token, not just UUID-shaped ones, so a fabricated\n * marker the model glued together from a label\n * (e.g. `[chart:placeholder]` or\n * `[chart:01f163b6-1eac-region-fill-oos]`) still parses as a marker.\n * Matching it - rather than letting the broad regex miss it - is what\n * lets the host UI consume and obscure the bogus marker instead of\n * leaking the literal `[chart:...]` text into the rendered prose.\n * Whether an id is a genuine embed is a separate {@link isUuid}\n * check the caller runs on {@link ParsedMarker.id}.\n *\n * Parse everything through {@link parseMarkers}, validate the id with\n * {@link isUuid}, and branch on the returned {@link ParsedMarker.type}.\n *\n * @module\n */\n\n/**\n * The embed kind named by a marker's `<type>` segment. Left as an\n * open `string` (not a closed union) so the grammar stays generic:\n * the authoritative set of supported types lives in the server's\n * `/embed/:type/:id` resolver registry, and an unknown type simply\n * 404s. The two types the server ships today are `\"chart\"` and\n * `\"data\"`.\n */\nexport type MarkerType = string;\n\n/**\n * Single matcher for ANY embed marker, regardless of type. Matches\n * `[<type>:<id>]`. Capture group 1 is the marker type token (e.g.\n * `chart`, `data`); group 2 is the id - any run of non-bracket,\n * non-whitespace characters, NOT constrained to a UUID shape.\n *\n * Neither the type nor the id shape is enumerated here. The type is\n * left open because the server's resolver registry decides which\n * types are real and 404s the rest, so a new embed kind needs no\n * grammar change. The id is left broad on purpose: a fabricated\n * marker the model emits from a label (e.g. `[chart:placeholder]`)\n * MUST still match so the host UI can consume and obscure it rather\n * than leak the literal `[chart:...]` text into the prose. The id is\n * then validated with {@link isUuid} downstream; non-UUID ids resolve\n * to no embed.\n *\n * Safe to share as a `/g` constant: it's only ever consumed via\n * {@link String.prototype.matchAll}, which clones the regex and\n * never advances this object's `lastIndex`. (A `.exec()`/`.test()`\n * loop would need a fresh regex each time, but we don't do that.)\n */\nconst MARKER_RE = /\\[([A-Za-z][A-Za-z0-9_-]*):([^\\]\\s]+)\\]/g;\n\n/**\n * UUID matcher (`8-4-4-4-12` hex, any version) anchored to the whole\n * string. Covers v4 chart ids and time-ordered (v7-style) statement\n * ids alike. Used by {@link isUuid} to tell a genuine embed id apart\n * from a label the model fabricated into a marker.\n */\nconst UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * Whether `id` is a UUID-shaped embed id. The marker grammar\n * ({@link MARKER_RE}) matches any non-bracket id token so fabricated\n * markers don't leak as literal prose; this is the guard callers run\n * to decide whether an id is a real embed (render the slot) or a\n * bogus label to obscure (drop the marker entirely).\n */\nexport function isUuid(id: string): boolean {\n  return UUID_RE.test(id);\n}\n\n/**\n * Build the exact embed marker the agent should place in prose.\n *\n * Tool results return this complete value so the model copies one opaque token\n * rather than reconstructing it from `type` plus `id`. Reconstruction is where\n * valid-looking but never-minted UUIDs enter transcripts and produce a 404.\n */\nexport function formatMarker(type: MarkerType, id: string): string {\n  return `[${type}:${id}]`;\n}\n\n/** One marker found in agent prose, with its source span. */\nexport interface ParsedMarker {\n  /** Marker kind token (e.g. `chart`, `data`); see {@link MarkerType}. */\n  type: MarkerType;\n  /** Raw id captured from the marker (chart id or statement id). */\n  id: string;\n  /** Index of the marker's first character in the source text. */\n  start: number;\n  /** Index one past the marker's last character. */\n  end: number;\n}\n\n/**\n * Parse every embed marker out of `text`, in source order. A single\n * regex pass means matches never overlap, so callers can splice the\n * spans directly without a sort/dedupe step. This is the one entry\n * point for marker parsing: type branching runs on the returned\n * markers. The grammar ({@link MARKER_RE}) matches any non-bracket id\n * token, so a returned {@link ParsedMarker.id} is NOT guaranteed to\n * be a real embed id - run it through {@link isUuid} to tell a\n * genuine embed apart from a fabricated label, which the caller then\n * obscures rather than rendering.\n */\nexport function parseMarkers(text: string): ParsedMarker[] {\n  const out: ParsedMarker[] = [];\n  for (const match of text.matchAll(MARKER_RE)) {\n    const start = match.index ?? 0;\n    out.push({\n      // Group 1 is the `<type>` token; the server's embed registry\n      // (not this parser) decides whether it's supported.\n      type: match[1] ?? \"\",\n      id: match[2] ?? \"\",\n      start,\n      end: start + match[0].length,\n    });\n  }\n  return out;\n}\n\n/**\n * Strip a trailing partial marker (`[chart`, `[data:01f1`, ...) that\n * hasn't received its closing `]` yet. While the model streams\n * text-deltas a marker arrives across several chunks, and rendering\n * each interim state would briefly flash the literal `[chart:abc-`\n * prefix before the closing bracket swaps it for a slot. Hiding any\n * trailing `[<non-whitespace-non-bracket>...` suffix keeps the prose\n * stable until either a `]` (full marker) or whitespace (definitely\n * not a marker) lands. Persisted transcripts never end mid-marker,\n * so this is a no-op on reload.\n */\nexport function stripIncompleteMarkerTail(text: string): string {\n  return text.replace(/\\[[^\\s[\\]]*$/, \"\");\n}\n"]}

package/lib/src/wire.d.ts

@@ -23,7 +23,7 @@
  *      ({@link GenieAgentResult} and its summary / dataset items).
  *
  * The route segments live in the sibling `routes.ts`
- * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `marker.ts`,
+ * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `markers.ts`,
  * so this file stays purely declarative (schemas + inferred types).
  * The browser client that drives these routes (`MastraPluginClient`)
  * ships from `@dbx-tools/ui-mastra`.
@@ -31,7 +31,6 @@
  * @module
  */
 import { genieModel } from "@dbx-tools/shared-genie";
-import { model } from "@dbx-tools/shared-model";
 import { z } from "zod";
 /**
  * JSON-safe descriptor published by the Mastra plugin's
@@ -112,10 +111,10 @@ export declare const ServingEndpointsResponseSchema: z.ZodObject<{
             speed: z.ZodOptional<z.ZodNumber>;
             cost: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
-        class: z.ZodOptional<z.ZodEnum<typeof model.ModelClass>>;
+        class: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chat-thinking">, z.ZodLiteral<"chat-balanced">, z.ZodLiteral<"chat-fast">, z.ZodLiteral<"embedding">]>>;
         serviceNames: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         modelServiceName: z.ZodOptional<z.ZodString>;
-        reasoningEfforts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        reasoningEfforts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"minimal">, z.ZodLiteral<"low">, z.ZodLiteral<"medium">, z.ZodLiteral<"high">, z.ZodLiteral<"xhigh">, z.ZodLiteral<"max">]>>>;
         status: z.ZodOptional<z.ZodObject<{
             deprecated: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;

package/lib/src/wire.js

@@ -23,7 +23,7 @@
  *      ({@link GenieAgentResult} and its summary / dataset items).
  *
  * The route segments live in the sibling `routes.ts`
- * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `marker.ts`,
+ * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `markers.ts`,
  * so this file stays purely declarative (schemas + inferred types).
  * The browser client that drives these routes (`MastraPluginClient`)
  * ships from `@dbx-tools/ui-mastra`.
@@ -451,4 +451,4 @@ export const GenieAgentResultSchema = z.object({
     summary: z.array(GenieSummaryItemSchema),
     error: z.string().optional(),
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wire.js","sourceRoot":"","sources":["../../src/wire.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Wire-format contract for `@dbx-tools/appkit-mastra`: the\n * dependency-free zod schemas + inferred types every consumer (the\n * React client, browser bundles, the server plugin) shares.\n *\n * Kept free of `pg`, `fastembed`, and the Mastra runtime so the\n * client can import these schemas without dragging in server-only\n * dependencies. Three layers live here:\n *\n *   1. The descriptor published by `MastraPlugin.clientConfig()`\n *      plus the REST payloads its routes return (models, history,\n *      suggestions, chart embeds, statement data). The server\n *      derives every path from the plugin mount and publishes the\n *      resolved paths so the client composes URLs without\n *      hard-coding `/api/mastra` - rename the plugin and the client\n *      keeps working.\n *   2. The `ctx.writer` event vocabulary: the wire-derived\n *      {@link GenieChatEvent}s from `@dbx-tools/genie-shared` plus\n *      the Mastra-only agent lifecycle events, unified as\n *      {@link GenieWriterEvent} so subscribers narrow both halves\n *      with a single `switch (event.type)`.\n *   3. The Genie agent's workflow output shapes\n *      ({@link GenieAgentResult} and its summary / dataset items).\n *\n * The route segments live in the sibling `routes.ts`\n * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `marker.ts`,\n * so this file stays purely declarative (schemas + inferred types).\n * The browser client that drives these routes (`MastraPluginClient`)\n * ships from `@dbx-tools/ui-mastra`.\n *\n * @module\n */\n\nimport { genieModel, type GenieChatEvent, type MessageStatus } from \"@dbx-tools/shared-genie\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport { z } from \"zod\";\n\n/* ---------------------------- client config ---------------------------- */\n\n/**\n * JSON-safe descriptor published by the Mastra plugin's\n * `clientConfig()`.\n *\n * Only the irreducible data lives here: `basePath` (the one path the\n * client can't otherwise know, since it encodes the plugin's mount\n * name) plus the runtime agent roster. Every concrete endpoint URL is\n * derived from `basePath` by the browser client\n * (`MastraPluginClient`) using the shared {@link MASTRA_ROUTES}\n * segments, so there's nothing to publish per-route.\n *\n * Fields:\n *   - `basePath`: plugin mount path. Always `/api/<pluginName>`. Feed\n *     it to `new MastraPluginClient(config)` (from\n *     `@dbx-tools/ui-mastra`) to get a typed client over every\n *     route plus the standard agent stream.\n *   - `defaultAgent`: agent id the client converses with when it\n *     doesn't name one.\n *   - `agents`: every registered agent id in registration order.\n *   - `feedbackEnabled`: whether the server can log user feedback to\n *     MLflow (MLflow tracing is configured). Drives whether the chat UI\n *     surfaces thumbs / comment controls. Defaults to `false` so a\n *     config published by an older server (without the field) parses\n *     cleanly to \"off\".\n *   - `chatAlwaysAvailable`: whether the agents' Databricks calls run as the\n *     app service principal rather than on-behalf-of the signed-in user. When\n *     `true` the chat works for any caller who can open the app, so a UI that\n *     hides chat when the OBO token is absent should show it anyway. Defaults\n *     to `false` (the OBO / `\"user\"` identity mode), so an older server without\n *     the field keeps the OBO-gated behavior.\n */\nexport const MastraClientConfigSchema = z.object({\n  basePath: z.string(),\n  defaultAgent: z.string(),\n  agents: z.array(z.string()),\n  feedbackEnabled: z.boolean().default(false),\n  chatAlwaysAvailable: z.boolean().default(false),\n});\n/** Browser-safe Mastra plugin descriptor used to construct route and stream clients. */\nexport type MastraClientConfig = z.infer<typeof MastraClientConfigSchema>;\n\n/**\n * JSON payload returned by `GET ${basePath}/default-model[?agentId=]`. The\n * static default model the agent resolves to when the client pins no model,\n * as both the raw serving-endpoint `model` id and a `displayName` (the\n * humanized label the picker shows). Both are `null` when the agent decides\n * its model dynamically at call time (nothing static to advertise). Lets the\n * picker label its default option WITHOUT waiting on the `/models` catalogue,\n * so it never flashes a raw id on load. Kept off the static bootstrap\n * `clientConfig` on purpose: it is per-agent and can be dynamic, so it is\n * fetched like `/models`.\n */\nexport const DefaultModelResponseSchema = z.object({\n  agentId: z.string(),\n  model: z.string().nullable(),\n  displayName: z.string().nullable(),\n});\n/** Response identifying the model currently selected as the plugin default. */\nexport type DefaultModelResponse = z.infer<typeof DefaultModelResponseSchema>;\n\n/* ---------------------------- model catalogue ---------------------------- */\n\n/**\n * JSON payload returned by `GET ${basePath}/models`. Wraps the shared\n * {@link model.ServingEndpointSummarySchema} (re-exported from\n * `@dbx-tools/shared-model`) so the catalogue\n * descriptor has a single definition the client, server, and the\n * standalone `@dbx-tools/model` toolkit all agree on.\n */\nexport const ServingEndpointsResponseSchema = z.object({\n  endpoints: z.array(model.ServingEndpointSummarySchema),\n});\n/** Available Databricks serving endpoints returned by the Mastra model route. */\nexport type ServingEndpointsResponse = z.infer<typeof ServingEndpointsResponseSchema>;\n\n/* ------------------------------ suggestions ------------------------------ */\n\n/**\n * JSON payload returned by `GET ${basePath}/suggestions`.\n *\n * Carries the curated starter questions for an agent's Genie space -\n * the `sample_questions` an author configured on the space, surfaced\n * as one-tap prompts on the chat's empty state. `questions` is empty\n * when the agent has no Genie space (or the space defines none), so\n * the client renders nothing in that case rather than falling back to\n * built-in example prompts.\n */\nexport const MastraSuggestionsResponseSchema = z.object({\n  questions: z.array(z.string()),\n});\n/** Follow-up prompts suggested for the current agent and thread context. */\nexport type MastraSuggestionsResponse = z.infer<typeof MastraSuggestionsResponseSchema>;\n\n/* --------------------------------- charts --------------------------------- */\n\n/**\n * Allowed chart types the planner can pick. Defined as a\n * discriminated literal union so each variant carries its own\n * `.describe()` clause - the server-side planner's prompt\n * formatter walks `.options` to inline the descriptions into the\n * model instructions, keeping the prompt in lock-step with the\n * schema by construction. The runtime type is the plain string\n * union (`\"bar\" | \"line\" | ...`), so consumers that just need a\n * discriminator value behave the same as if it were a\n * `z.enum([...])`.\n */\nexport const ChartTypeSchema = z\n  .union([\n    z\n      .literal(\"bar\")\n      .describe(\n        \"comparing a numeric value across a small/medium set of discrete categories (top-N, ranking, group-by)\",\n      ),\n    z\n      .literal(\"horizontalBar\")\n      .describe(\n        \"same as bar but categories on the y-axis - prefer when category labels are long or there are many categories\",\n      ),\n    z\n      .literal(\"line\")\n      .describe(\n        \"ordered-axis trend (time series, sequence, rank) where the x-axis has natural order\",\n      ),\n    z.literal(\"area\").describe(\"stacked-trend emphasis - cumulative or composition over time\"),\n    z\n      .literal(\"combo\")\n      .describe(\n        \"mixed bar + line (or area) series on shared categories - e.g. volume bars with a rate/trend line; set each series' `type`\",\n      ),\n    z\n      .literal(\"waterfall\")\n      .describe(\n        \"bridge / running-total of signed step values (start -> deltas -> end) across ordered categories\",\n      ),\n    z\n      .literal(\"scatter\")\n      .describe(\"two-numeric-axis correlations between fields (e.g. price vs. quantity)\"),\n    z\n      .literal(\"heatmap\")\n      .describe(\n        \"matrix intensity across two category axes - x labels in `categories`, one series per matrix row holding that row's values\",\n      ),\n    z\n      .literal(\"radar\")\n      .describe(\n        \"multi-dimension comparison across a fixed set of axes (one indicator per category, one or more series of values)\",\n      ),\n    z.literal(\"pie\").describe(\"parts-of-a-whole when 2-7 categories sum to a meaningful total\"),\n    z\n      .literal(\"funnel\")\n      .describe(\n        \"ordered stages that shrink (conversion, pipeline, attrition) - `{name, value}` slices\",\n      ),\n    z\n      .literal(\"treemap\")\n      .describe(\n        \"parts-of-a-whole as nested rectangles when there are more than ~7 categories or a flat hierarchy of `{name, value}` slices\",\n      ),\n    z\n      .literal(\"custom\")\n      .describe(\n        \"escape hatch for a chart none of the above can express (sankey, boxplot, candlestick, sunburst, gauge, network graph, calendar, parallel, ...) - hand-write the complete Echarts option instead of a plan\",\n      ),\n  ])\n  .describe(\"The chart shape that best matches the data and intent.\");\n/** Supported chart family selected by the server-side chart planner. */\nexport type ChartType = z.infer<typeof ChartTypeSchema>;\n\n/**\n * Resolved chart plan a settled chart entry carries on its\n * `result` field. `option` is the full Echarts spec; pass\n * straight into `<ReactECharts option={...}>`.\n */\nexport const ChartResultSchema = z.object({\n  chartType: ChartTypeSchema,\n  option: z\n    .record(z.string(), z.unknown())\n    .describe(\n      \"Fully-resolved Echarts `EChartsOption` JSON for this chart - drop directly into an Echarts instance (or `<ReactECharts option={...} />`) without further processing. Includes title / tooltip / legend / grid / axis / series defaults already merged in.\",\n    ),\n});\n/** Render-ready chart plan stored behind a chart embed identifier. */\nexport type ChartResult = z.infer<typeof ChartResultSchema>;\n\n/**\n * Wire-format AND server-side cache shape for a chart entry.\n * Three lifecycle states inferred from the two optional fields\n * (no discriminator needed):\n *\n *   - `result` set                    -> chart is ready to render\n *   - `error` set                     -> planner / data fetch failed\n *   - both `result` and `error` unset -> still processing\n *\n * `option` is typed as a generic record so this package stays\n * dependency-free of `echarts`. The server (`chart.ts`) imports\n * this schema directly; the demo client polls the\n * `/embed/chart/:id` route and parses responses against it.\n */\nexport const ChartSchema = z.object({\n  chartId: z\n    .string()\n    .describe(\n      \"Opaque id minted by the chart subsystem. Embed verbatim as `[chart:<chartId>]` in agent prose; the host UI resolves it against this cache entry.\",\n    ),\n  error: z\n    .string()\n    .optional()\n    .describe(\n      \"Error message when the chart failed (data fetch error, planner error, empty dataset). Mutually exclusive with `result`; absent on success and while processing.\",\n    ),\n  result: ChartResultSchema.optional().describe(\n    \"Resolved chart plan. Absent while processing and when the run errored.\",\n  ),\n});\n/** Pollable chart-cache entry representing pending, successful, or failed planning. */\nexport type Chart = z.infer<typeof ChartSchema>;\n\n/* ------------------------------- statements ------------------------------- */\n\n/**\n * Wire-format payload returned by `GET ${basePath}/embed/data/:id`.\n *\n * Mirrors the agent-side `get_statement` tool's output so the\n * host UI and the LLM see the exact same shape for the same\n * statement; the route is what resolves `[data:<statement_id>]`\n * markers the agent embeds in prose.\n *\n * Fields:\n *   - `columns`: column names in declaration order.\n *   - `rows`: row records keyed by column name. Cell values are\n *     either coerced numbers or the original strings (Genie /\n *     Statement Execution returns every cell as `string | null`;\n *     numeric-looking cells are coerced server-side so the UI\n *     can format with `tabular-nums` without re-parsing).\n *   - `rowCount`: total row count upstream (independent of the\n *     `limit` cap). Compare against `rows.length` to detect\n *     truncation - `truncated` is the precomputed flag.\n *   - `truncated`: `true` when the server clipped rows to honor\n *     the route's row cap; the UI should surface a \"showing N of\n *     M rows\" affordance in that case.\n */\nexport const StatementDataSchema = 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/** Tabular statement payload resolved from a `[data:<statement_id>]` embed marker. */\nexport type StatementData = z.infer<typeof StatementDataSchema>;\n\n/* ---------------- mastra-only genie-agent events ---------------- */\n\n/**\n * Mastra-only lifecycle event: the Genie tool invocation started.\n * Emitted immediately when the calling agent invokes the Genie\n * tool, before any inner agent / wire activity, so the UI can\n * pop a \"Thinking...\" pill the instant the model decides to\n * delegate. `conversationId` / `messageId` are absent on this\n * first emit (no Genie round-trip yet). Field names are\n * camelCase (vs the snake_case wire events) to mirror the\n * Genie agent's own internal data plumbing.\n */\nexport const StartedEventSchema = z.object({\n  type: z.literal(\"started\"),\n  spaceId: z.string(),\n  /**\n   * Genie conversation id, populated only when this `started`\n   * event corresponds to a follow-up turn on an existing\n   * conversation. Absent on the first turn.\n   */\n  conversationId: z.string().optional(),\n  /**\n   * Genie message id, populated only after the first wire\n   * `message` event lands. Absent on the immediate-on-invoke\n   * emit.\n   */\n  messageId: z.string().optional(),\n  /** Question the Genie agent sent to Genie. */\n  content: z.string(),\n});\n/** Immediate lifecycle event emitted when an `ask_genie` invocation begins. */\nexport type StartedEvent = z.infer<typeof StartedEventSchema>;\n\n/**\n * Mastra-only lifecycle event: one `ask_genie` invocation\n * finished. Carries the hydrated `statementIds` (rows are fetched\n * via `getStatement` separately) and Genie's final prose answer\n * so the UI can move from \"thinking\" to \"answered\" without\n * waiting for the Genie agent's whole reasoning loop to end.\n */\nexport const AskGenieDoneEventSchema = z.object({\n  type: z.literal(\"ask_genie_done\"),\n  spaceId: z.string(),\n  conversationId: z.string().optional(),\n  messageId: z.string().optional(),\n  /** Genie's natural-language answer for the turn, if any. */\n  answer: z.string().optional(),\n  /** Statement ids for any non-empty result sets this turn produced. */\n  statementIds: z.array(z.string()),\n  /**\n   * Terminal wire status (`COMPLETED` / `FAILED` / `CANCELLED`).\n   * Mirrors the source `result` event's status so subscribers\n   * can react to ask-level completion without re-walking history.\n   * Treated as `z.custom<MessageStatus>` because the SDK is the\n   * source of truth for the enum values.\n   */\n  status: z.custom<MessageStatus>((v) => typeof v === \"string\"),\n});\n/** Completion event for one `ask_genie` invocation, including its terminal status. */\nexport type AskGenieDoneEvent = z.infer<typeof AskGenieDoneEventSchema>;\n\n/**\n * Mastra-only error event: terminal Genie agent / transport\n * error. Genie's own `FAILED` / `CANCELLED` come through the\n * wire's `result` event - this variant is for failures the wire\n * can't represent (network, Genie agent crash, planner error,\n * etc.) plus a UI-friendly mirror of `result` when the status is\n * non-`COMPLETED`.\n */\nexport const MastraGenieErrorEventSchema = z.object({\n  type: z.literal(\"error\"),\n  spaceId: z.string().optional(),\n  conversationId: z.string().optional(),\n  messageId: z.string().optional(),\n  error: z.string(),\n});\n/** Mastra-side failure event for errors outside Genie's normal terminal result. */\nexport type MastraGenieErrorEvent = z.infer<typeof MastraGenieErrorEventSchema>;\n\n/**\n * Mastra-only lifecycle event: the inner Genie agent's\n * structured-output coercion has landed. Fires once per Genie\n * tool invocation, AFTER `agent.generate(...)` completes (i.e.\n * the inner loop + Mastra's structuring pass have both\n * finished) and BEFORE the wrapper hydrates each `data` item\n * with a chart. Signals to the host UI that the agent has\n * stopped reasoning and is moving into chart generation.\n *\n * The structuring pass itself is opaque (it runs inside\n * Mastra's `agent.generate(...)` together with the tool loop)\n * so this is the earliest hook we can offer; we can't fire a\n * \"summary started\" event the way we fire `started`.\n */\nexport const SummaryEventSchema = z.object({\n  type: z.literal(\"summary\"),\n  spaceId: z.string(),\n  /** Total number of items in the agent's structured summary. */\n  items: z.number().int().nonnegative(),\n  /** Count of `text` / prose items in the summary. */\n  textItems: z.number().int().nonnegative(),\n  /**\n   * Count of `data` items the wrapper will hydrate into charts.\n   * The host UI can use this to seed N chart skeletons before\n   * the per-chart events arrive.\n   */\n  dataItems: z.number().int().nonnegative(),\n});\n/** Lifecycle event emitted before summary data items are hydrated into charts. */\nexport type SummaryEvent = z.infer<typeof SummaryEventSchema>;\n\n/**\n * Mastra-only event union. Each variant uses the same flat\n * `{type, ...fields}` shape as {@link GenieChatEvent} so\n * subscribers union both with a single `switch (event.type)`.\n */\nexport const GenieAgentEventSchema = z.discriminatedUnion(\"type\", [\n  StartedEventSchema,\n  AskGenieDoneEventSchema,\n  MastraGenieErrorEventSchema,\n  SummaryEventSchema,\n]);\n/** Mastra-owned lifecycle events layered on top of Genie's wire event stream. */\nexport type GenieAgentEvent = z.infer<typeof GenieAgentEventSchema>;\n\n/**\n * The unified writer-event vocabulary subscribers see on\n * `ctx.writer`: the wire-derived {@link GenieChatEvent} union\n * **plus** Mastra-only events from {@link GenieAgentEvent}. Each\n * variant is a flat `{type, ...fields}` object; consumers narrow\n * on `type` and read fields inline - there is no payload wrapper\n * and no writer-boundary translator.\n *\n * Composed via `z.union` (not `z.discriminatedUnion`) because\n * both halves are themselves discriminated unions on the same\n * `type` key.\n */\nexport const GenieWriterEventSchema = z.union([\n  genieModel.GenieChatEventSchema,\n  GenieAgentEventSchema,\n]);\n/** Complete event vocabulary written by the Mastra Genie integration. */\nexport type GenieWriterEvent = z.infer<typeof GenieWriterEventSchema>;\n\n/** Discriminator type for {@link GenieWriterEvent}. */\nexport type GenieWriterEventType = GenieWriterEvent[\"type\"];\n\n/** Native AI SDK custom data-part type carrying one Genie progress event. */\nexport const GENIE_PROGRESS_PART_TYPE = \"data-genie-progress\" as const;\n\n/**\n * Data attached to {@link GENIE_PROGRESS_PART_TYPE}. `toolCallId` associates\n * progress with the native tool part that owns the request and result.\n */\nexport const GenieProgressPartDataSchema = z.object({\n  toolCallId: z.string(),\n  event: GenieWriterEventSchema,\n});\n/** Validated payload carried by a native Genie progress data part. */\nexport type GenieProgressPartData = z.infer<typeof GenieProgressPartDataSchema>;\n\n/* ------------------------- summary + dataset ------------------------ */\n\n/**\n * Tabular payload embedded in every {@link GenieSummaryItem}\n * `visualize` dataset. Always present: hydrated by the workflow's\n * agent step before the finalize step runs, so consumers can render\n * a table fallback regardless of chart-planner outcome.\n *\n * Fields:\n *   - `columns`: column names in display order.\n *   - `rows`: tabular rows keyed by column name.\n *   - `rowCount`: total row count Genie reported (may exceed\n *     `rows.length` when the statement was truncated).\n */\nexport const GenieDatasetDataSchema = z.object({\n  columns: z.array(z.string()),\n  rows: z.array(z.record(z.string(), z.unknown())),\n  rowCount: z.number(),\n});\n/** Hydrated tabular data that always backs a Genie visualization item. */\nexport type GenieDatasetData = z.infer<typeof GenieDatasetDataSchema>;\n\n/**\n * Slim chart reference attached to a visualize dataset. Only\n * present when planning succeeded.\n *\n * `option` is intentionally NOT included. The resolved Echarts\n * spec lives off-band in the chart cache: the host UI fetches it\n * by `chartId` from the plugin's embed route (derived from\n * `basePath` + {@link MASTRA_ROUTES}.embed, i.e. `/embed/chart/:id`;\n * see {@link Chart}). Embedding the full spec inline would\n * inflate every dataset by several KB per chart and round-trip\n * through the LLM context for zero benefit (the model only needs\n * the `chartId` to place a `[chart:<chartId>]` marker in its\n * reply).\n */\nexport const GenieDatasetChartSchema = z.object({\n  chartId: z.string(),\n  chartType: ChartTypeSchema,\n});\n/** Lightweight reference to a chart plan stored in the Mastra chart cache. */\nexport type GenieDatasetChart = z.infer<typeof GenieDatasetChartSchema>;\n\n/**\n * Dataset bundle attached to a {@link GenieSummaryItem} `visualize`\n * item. `data` is always populated; `chart` is best-effort and\n * absent when the workflow's chart-planner failed (timeout,\n * malformed plan, abort) so the host UI can still render the\n * underlying table.\n */\nexport const GenieDatasetSchema = z.object({\n  data: GenieDatasetDataSchema,\n  chart: GenieDatasetChartSchema.optional(),\n});\n/** Visualization dataset with required table data and an optional planned chart. */\nexport type GenieDataset = z.infer<typeof GenieDatasetSchema>;\n\n/**\n * One item inside the Genie workflow's final summary. The\n * workflow produces a mixed sequence of:\n *\n *   - `string`: a markdown paragraph (interpretation, callouts,\n *     transitions between data blocks).\n *   - `visualize`: a request from the agent step to visualize a\n *     specific Genie statement at this position in the prose.\n *     The finalize step hydrates `dataset.data` (rows from the\n *     matching `statementId`) and attaches `dataset.chart` after\n *     running the chart-planner. The agent NEVER picks the chart\n *     type - it only marks where a visualization belongs.\n *\n * The host UI walks the array in display order to compose the\n * final assistant message.\n */\nexport const GenieSummaryItemSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(\"string\"),\n    text: z.string(),\n  }),\n  z.object({\n    type: z.literal(\"visualize\"),\n    statementId: z.string(),\n    title: z.string().optional(),\n    description: z.string().optional(),\n    dataset: GenieDatasetSchema,\n  }),\n]);\n/** Ordered prose or visualization item in the Genie agent's final summary. */\nexport type GenieSummaryItem = z.infer<typeof GenieSummaryItemSchema>;\n\n/** Discriminator type for {@link GenieSummaryItem}. */\nexport type GenieSummaryItemType = GenieSummaryItem[\"type\"];\n\n/**\n * The Genie agent's final output shape - what the calling agent's\n * Genie tool returns to the calling LLM. The `summary` array is\n * the user-facing renderable; `conversationId` lets the calling\n * agent (or the UI) follow up in the same Genie thread on the\n * next turn.\n */\nexport const GenieAgentResultSchema = z.object({\n  spaceId: z.string(),\n  conversationId: z.string().optional(),\n  summary: z.array(GenieSummaryItemSchema),\n  error: z.string().optional(),\n});\n/** Final renderable output returned by the Genie agent tool to its caller. */\nexport type GenieAgentResult = z.infer<typeof GenieAgentResultSchema>;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wire.js","sourceRoot":"","sources":["../../src/wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,UAAU,EAA2C,MAAM,yBAAyB,CAAC;AAC9F,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,6EAA6E;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3B,eAAe,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IAC3C,mBAAmB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;CAChD,CAAC,CAAC;AAIH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACnC,CAAC,CAAC;AAIH,+EAA+E;AAE/E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAAC;IACrD,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,4BAA4B,CAAC;CACvD,CAAC,CAAC;AAIH,+EAA+E;AAE/E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IACtD,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CAC/B,CAAC,CAAC;AAIH,gFAAgF;AAEhF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC;KAC7B,KAAK,CAAC;IACL,CAAC;SACE,OAAO,CAAC,KAAK,CAAC;SACd,QAAQ,CACP,uGAAuG,CACxG;IACH,CAAC;SACE,OAAO,CAAC,eAAe,CAAC;SACxB,QAAQ,CACP,8GAA8G,CAC/G;IACH,CAAC;SACE,OAAO,CAAC,MAAM,CAAC;SACf,QAAQ,CACP,qFAAqF,CACtF;IACH,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,8DAA8D,CAAC;IAC1F,CAAC;SACE,OAAO,CAAC,OAAO,CAAC;SAChB,QAAQ,CACP,2HAA2H,CAC5H;IACH,CAAC;SACE,OAAO,CAAC,WAAW,CAAC;SACpB,QAAQ,CACP,iGAAiG,CAClG;IACH,CAAC;SACE,OAAO,CAAC,SAAS,CAAC;SAClB,QAAQ,CAAC,wEAAwE,CAAC;IACrF,CAAC;SACE,OAAO,CAAC,SAAS,CAAC;SAClB,QAAQ,CACP,2HAA2H,CAC5H;IACH,CAAC;SACE,OAAO,CAAC,OAAO,CAAC;SAChB,QAAQ,CACP,kHAAkH,CACnH;IACH,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,gEAAgE,CAAC;IAC3F,CAAC;SACE,OAAO,CAAC,QAAQ,CAAC;SACjB,QAAQ,CACP,uFAAuF,CACxF;IACH,CAAC;SACE,OAAO,CAAC,SAAS,CAAC;SAClB,QAAQ,CACP,4HAA4H,CAC7H;IACH,CAAC;SACE,OAAO,CAAC,QAAQ,CAAC;SACjB,QAAQ,CACP,2MAA2M,CAC5M;CACJ,CAAC;KACD,QAAQ,CAAC,wDAAwD,CAAC,CAAC;AAItE;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,SAAS,EAAE,eAAe;IAC1B,MAAM,EAAE,CAAC;SACN,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;SAC/B,QAAQ,CACP,2PAA2P,CAC5P;CACJ,CAAC,CAAC;AAIH;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,OAAO,EAAE,CAAC;SACP,MAAM,EAAE;SACR,QAAQ,CACP,kJAAkJ,CACnJ;IACH,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,iKAAiK,CAClK;IACH,MAAM,EAAE,iBAAiB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC3C,wEAAwE,CACzE;CACF,CAAC,CAAC;AAIH,gFAAgF;AAEhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC5B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAChD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;CACvB,CAAC,CAAC;AAIH,sEAAsE;AAEtE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB;;;;OAIG;IACH,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC;;;;OAIG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,8CAA8C;IAC9C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;CACpB,CAAC,CAAC;AAIH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;IACjC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,4DAA4D;IAC5D,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,sEAAsE;IACtE,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACjC;;;;;;OAMG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,CAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC;CAC9D,CAAC,CAAC;AAIH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IACxB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;CAClB,CAAC,CAAC;AAIH;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,+DAA+D;IAC/D,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACrC,oDAAoD;IACpD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACzC;;;;OAIG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;CAC1C,CAAC,CAAC;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAChE,kBAAkB;IAClB,uBAAuB;IACvB,2BAA2B;IAC3B,kBAAkB;CACnB,CAAC,CAAC;AAIH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC5C,UAAU,CAAC,oBAAoB;IAC/B,qBAAqB;CACtB,CAAC,CAAC;AAOH,6EAA6E;AAC7E,MAAM,CAAC,MAAM,wBAAwB,GAAG,qBAA8B,CAAC;AAEvE;;;GAGG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,KAAK,EAAE,sBAAsB;CAC9B,CAAC,CAAC;AAIH,0EAA0E;AAE1E;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC5B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAChD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;CACrB,CAAC,CAAC;AAIH;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,SAAS,EAAE,eAAe;CAC3B,CAAC,CAAC;AAIH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,IAAI,EAAE,sBAAsB;IAC5B,KAAK,EAAE,uBAAuB,CAAC,QAAQ,EAAE;CAC1C,CAAC,CAAC;AAIH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IACjE,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;QACzB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;KACjB,CAAC;IACF,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;QAC5B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;QACvB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC5B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAClC,OAAO,EAAE,kBAAkB;KAC5B,CAAC;CACH,CAAC,CAAC;AAOH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC;IACxC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC7B,CAAC,CAAC","sourcesContent":["/**\n * Wire-format contract for `@dbx-tools/appkit-mastra`: the\n * dependency-free zod schemas + inferred types every consumer (the\n * React client, browser bundles, the server plugin) shares.\n *\n * Kept free of `pg`, `fastembed`, and the Mastra runtime so the\n * client can import these schemas without dragging in server-only\n * dependencies. Three layers live here:\n *\n *   1. The descriptor published by `MastraPlugin.clientConfig()`\n *      plus the REST payloads its routes return (models, history,\n *      suggestions, chart embeds, statement data). The server\n *      derives every path from the plugin mount and publishes the\n *      resolved paths so the client composes URLs without\n *      hard-coding `/api/mastra` - rename the plugin and the client\n *      keeps working.\n *   2. The `ctx.writer` event vocabulary: the wire-derived\n *      {@link GenieChatEvent}s from `@dbx-tools/genie-shared` plus\n *      the Mastra-only agent lifecycle events, unified as\n *      {@link GenieWriterEvent} so subscribers narrow both halves\n *      with a single `switch (event.type)`.\n *   3. The Genie agent's workflow output shapes\n *      ({@link GenieAgentResult} and its summary / dataset items).\n *\n * The route segments live in the sibling `routes.ts`\n * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `markers.ts`,\n * so this file stays purely declarative (schemas + inferred types).\n * The browser client that drives these routes (`MastraPluginClient`)\n * ships from `@dbx-tools/ui-mastra`.\n *\n * @module\n */\n\nimport { genieModel, type GenieChatEvent, type MessageStatus } from \"@dbx-tools/shared-genie\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport { z } from \"zod\";\n\n/* ---------------------------- client config ---------------------------- */\n\n/**\n * JSON-safe descriptor published by the Mastra plugin's\n * `clientConfig()`.\n *\n * Only the irreducible data lives here: `basePath` (the one path the\n * client can't otherwise know, since it encodes the plugin's mount\n * name) plus the runtime agent roster. Every concrete endpoint URL is\n * derived from `basePath` by the browser client\n * (`MastraPluginClient`) using the shared {@link MASTRA_ROUTES}\n * segments, so there's nothing to publish per-route.\n *\n * Fields:\n *   - `basePath`: plugin mount path. Always `/api/<pluginName>`. Feed\n *     it to `new MastraPluginClient(config)` (from\n *     `@dbx-tools/ui-mastra`) to get a typed client over every\n *     route plus the standard agent stream.\n *   - `defaultAgent`: agent id the client converses with when it\n *     doesn't name one.\n *   - `agents`: every registered agent id in registration order.\n *   - `feedbackEnabled`: whether the server can log user feedback to\n *     MLflow (MLflow tracing is configured). Drives whether the chat UI\n *     surfaces thumbs / comment controls. Defaults to `false` so a\n *     config published by an older server (without the field) parses\n *     cleanly to \"off\".\n *   - `chatAlwaysAvailable`: whether the agents' Databricks calls run as the\n *     app service principal rather than on-behalf-of the signed-in user. When\n *     `true` the chat works for any caller who can open the app, so a UI that\n *     hides chat when the OBO token is absent should show it anyway. Defaults\n *     to `false` (the OBO / `\"user\"` identity mode), so an older server without\n *     the field keeps the OBO-gated behavior.\n */\nexport const MastraClientConfigSchema = z.object({\n  basePath: z.string(),\n  defaultAgent: z.string(),\n  agents: z.array(z.string()),\n  feedbackEnabled: z.boolean().default(false),\n  chatAlwaysAvailable: z.boolean().default(false),\n});\n/** Browser-safe Mastra plugin descriptor used to construct route and stream clients. */\nexport type MastraClientConfig = z.infer<typeof MastraClientConfigSchema>;\n\n/**\n * JSON payload returned by `GET ${basePath}/default-model[?agentId=]`. The\n * static default model the agent resolves to when the client pins no model,\n * as both the raw serving-endpoint `model` id and a `displayName` (the\n * humanized label the picker shows). Both are `null` when the agent decides\n * its model dynamically at call time (nothing static to advertise). Lets the\n * picker label its default option WITHOUT waiting on the `/models` catalogue,\n * so it never flashes a raw id on load. Kept off the static bootstrap\n * `clientConfig` on purpose: it is per-agent and can be dynamic, so it is\n * fetched like `/models`.\n */\nexport const DefaultModelResponseSchema = z.object({\n  agentId: z.string(),\n  model: z.string().nullable(),\n  displayName: z.string().nullable(),\n});\n/** Response identifying the model currently selected as the plugin default. */\nexport type DefaultModelResponse = z.infer<typeof DefaultModelResponseSchema>;\n\n/* ---------------------------- model catalogue ---------------------------- */\n\n/**\n * JSON payload returned by `GET ${basePath}/models`. Wraps the shared\n * {@link model.ServingEndpointSummarySchema} (re-exported from\n * `@dbx-tools/shared-model`) so the catalogue\n * descriptor has a single definition the client, server, and the\n * standalone `@dbx-tools/model` toolkit all agree on.\n */\nexport const ServingEndpointsResponseSchema = z.object({\n  endpoints: z.array(model.ServingEndpointSummarySchema),\n});\n/** Available Databricks serving endpoints returned by the Mastra model route. */\nexport type ServingEndpointsResponse = z.infer<typeof ServingEndpointsResponseSchema>;\n\n/* ------------------------------ suggestions ------------------------------ */\n\n/**\n * JSON payload returned by `GET ${basePath}/suggestions`.\n *\n * Carries the curated starter questions for an agent's Genie space -\n * the `sample_questions` an author configured on the space, surfaced\n * as one-tap prompts on the chat's empty state. `questions` is empty\n * when the agent has no Genie space (or the space defines none), so\n * the client renders nothing in that case rather than falling back to\n * built-in example prompts.\n */\nexport const MastraSuggestionsResponseSchema = z.object({\n  questions: z.array(z.string()),\n});\n/** Follow-up prompts suggested for the current agent and thread context. */\nexport type MastraSuggestionsResponse = z.infer<typeof MastraSuggestionsResponseSchema>;\n\n/* --------------------------------- charts --------------------------------- */\n\n/**\n * Allowed chart types the planner can pick. Defined as a\n * discriminated literal union so each variant carries its own\n * `.describe()` clause - the server-side planner's prompt\n * formatter walks `.options` to inline the descriptions into the\n * model instructions, keeping the prompt in lock-step with the\n * schema by construction. The runtime type is the plain string\n * union (`\"bar\" | \"line\" | ...`), so consumers that just need a\n * discriminator value behave the same as if it were a\n * `z.enum([...])`.\n */\nexport const ChartTypeSchema = z\n  .union([\n    z\n      .literal(\"bar\")\n      .describe(\n        \"comparing a numeric value across a small/medium set of discrete categories (top-N, ranking, group-by)\",\n      ),\n    z\n      .literal(\"horizontalBar\")\n      .describe(\n        \"same as bar but categories on the y-axis - prefer when category labels are long or there are many categories\",\n      ),\n    z\n      .literal(\"line\")\n      .describe(\n        \"ordered-axis trend (time series, sequence, rank) where the x-axis has natural order\",\n      ),\n    z.literal(\"area\").describe(\"stacked-trend emphasis - cumulative or composition over time\"),\n    z\n      .literal(\"combo\")\n      .describe(\n        \"mixed bar + line (or area) series on shared categories - e.g. volume bars with a rate/trend line; set each series' `type`\",\n      ),\n    z\n      .literal(\"waterfall\")\n      .describe(\n        \"bridge / running-total of signed step values (start -> deltas -> end) across ordered categories\",\n      ),\n    z\n      .literal(\"scatter\")\n      .describe(\"two-numeric-axis correlations between fields (e.g. price vs. quantity)\"),\n    z\n      .literal(\"heatmap\")\n      .describe(\n        \"matrix intensity across two category axes - x labels in `categories`, one series per matrix row holding that row's values\",\n      ),\n    z\n      .literal(\"radar\")\n      .describe(\n        \"multi-dimension comparison across a fixed set of axes (one indicator per category, one or more series of values)\",\n      ),\n    z.literal(\"pie\").describe(\"parts-of-a-whole when 2-7 categories sum to a meaningful total\"),\n    z\n      .literal(\"funnel\")\n      .describe(\n        \"ordered stages that shrink (conversion, pipeline, attrition) - `{name, value}` slices\",\n      ),\n    z\n      .literal(\"treemap\")\n      .describe(\n        \"parts-of-a-whole as nested rectangles when there are more than ~7 categories or a flat hierarchy of `{name, value}` slices\",\n      ),\n    z\n      .literal(\"custom\")\n      .describe(\n        \"escape hatch for a chart none of the above can express (sankey, boxplot, candlestick, sunburst, gauge, network graph, calendar, parallel, ...) - hand-write the complete Echarts option instead of a plan\",\n      ),\n  ])\n  .describe(\"The chart shape that best matches the data and intent.\");\n/** Supported chart family selected by the server-side chart planner. */\nexport type ChartType = z.infer<typeof ChartTypeSchema>;\n\n/**\n * Resolved chart plan a settled chart entry carries on its\n * `result` field. `option` is the full Echarts spec; pass\n * straight into `<ReactECharts option={...}>`.\n */\nexport const ChartResultSchema = z.object({\n  chartType: ChartTypeSchema,\n  option: z\n    .record(z.string(), z.unknown())\n    .describe(\n      \"Fully-resolved Echarts `EChartsOption` JSON for this chart - drop directly into an Echarts instance (or `<ReactECharts option={...} />`) without further processing. Includes title / tooltip / legend / grid / axis / series defaults already merged in.\",\n    ),\n});\n/** Render-ready chart plan stored behind a chart embed identifier. */\nexport type ChartResult = z.infer<typeof ChartResultSchema>;\n\n/**\n * Wire-format AND server-side cache shape for a chart entry.\n * Three lifecycle states inferred from the two optional fields\n * (no discriminator needed):\n *\n *   - `result` set                    -> chart is ready to render\n *   - `error` set                     -> planner / data fetch failed\n *   - both `result` and `error` unset -> still processing\n *\n * `option` is typed as a generic record so this package stays\n * dependency-free of `echarts`. The server (`chart.ts`) imports\n * this schema directly; the demo client polls the\n * `/embed/chart/:id` route and parses responses against it.\n */\nexport const ChartSchema = z.object({\n  chartId: z\n    .string()\n    .describe(\n      \"Opaque id minted by the chart subsystem. Embed verbatim as `[chart:<chartId>]` in agent prose; the host UI resolves it against this cache entry.\",\n    ),\n  error: z\n    .string()\n    .optional()\n    .describe(\n      \"Error message when the chart failed (data fetch error, planner error, empty dataset). Mutually exclusive with `result`; absent on success and while processing.\",\n    ),\n  result: ChartResultSchema.optional().describe(\n    \"Resolved chart plan. Absent while processing and when the run errored.\",\n  ),\n});\n/** Pollable chart-cache entry representing pending, successful, or failed planning. */\nexport type Chart = z.infer<typeof ChartSchema>;\n\n/* ------------------------------- statements ------------------------------- */\n\n/**\n * Wire-format payload returned by `GET ${basePath}/embed/data/:id`.\n *\n * Mirrors the agent-side `get_statement` tool's output so the\n * host UI and the LLM see the exact same shape for the same\n * statement; the route is what resolves `[data:<statement_id>]`\n * markers the agent embeds in prose.\n *\n * Fields:\n *   - `columns`: column names in declaration order.\n *   - `rows`: row records keyed by column name. Cell values are\n *     either coerced numbers or the original strings (Genie /\n *     Statement Execution returns every cell as `string | null`;\n *     numeric-looking cells are coerced server-side so the UI\n *     can format with `tabular-nums` without re-parsing).\n *   - `rowCount`: total row count upstream (independent of the\n *     `limit` cap). Compare against `rows.length` to detect\n *     truncation - `truncated` is the precomputed flag.\n *   - `truncated`: `true` when the server clipped rows to honor\n *     the route's row cap; the UI should surface a \"showing N of\n *     M rows\" affordance in that case.\n */\nexport const StatementDataSchema = 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/** Tabular statement payload resolved from a `[data:<statement_id>]` embed marker. */\nexport type StatementData = z.infer<typeof StatementDataSchema>;\n\n/* ---------------- mastra-only genie-agent events ---------------- */\n\n/**\n * Mastra-only lifecycle event: the Genie tool invocation started.\n * Emitted immediately when the calling agent invokes the Genie\n * tool, before any inner agent / wire activity, so the UI can\n * pop a \"Thinking...\" pill the instant the model decides to\n * delegate. `conversationId` / `messageId` are absent on this\n * first emit (no Genie round-trip yet). Field names are\n * camelCase (vs the snake_case wire events) to mirror the\n * Genie agent's own internal data plumbing.\n */\nexport const StartedEventSchema = z.object({\n  type: z.literal(\"started\"),\n  spaceId: z.string(),\n  /**\n   * Genie conversation id, populated only when this `started`\n   * event corresponds to a follow-up turn on an existing\n   * conversation. Absent on the first turn.\n   */\n  conversationId: z.string().optional(),\n  /**\n   * Genie message id, populated only after the first wire\n   * `message` event lands. Absent on the immediate-on-invoke\n   * emit.\n   */\n  messageId: z.string().optional(),\n  /** Question the Genie agent sent to Genie. */\n  content: z.string(),\n});\n/** Immediate lifecycle event emitted when an `ask_genie` invocation begins. */\nexport type StartedEvent = z.infer<typeof StartedEventSchema>;\n\n/**\n * Mastra-only lifecycle event: one `ask_genie` invocation\n * finished. Carries the hydrated `statementIds` (rows are fetched\n * via `getStatement` separately) and Genie's final prose answer\n * so the UI can move from \"thinking\" to \"answered\" without\n * waiting for the Genie agent's whole reasoning loop to end.\n */\nexport const AskGenieDoneEventSchema = z.object({\n  type: z.literal(\"ask_genie_done\"),\n  spaceId: z.string(),\n  conversationId: z.string().optional(),\n  messageId: z.string().optional(),\n  /** Genie's natural-language answer for the turn, if any. */\n  answer: z.string().optional(),\n  /** Statement ids for any non-empty result sets this turn produced. */\n  statementIds: z.array(z.string()),\n  /**\n   * Terminal wire status (`COMPLETED` / `FAILED` / `CANCELLED`).\n   * Mirrors the source `result` event's status so subscribers\n   * can react to ask-level completion without re-walking history.\n   * Treated as `z.custom<MessageStatus>` because the SDK is the\n   * source of truth for the enum values.\n   */\n  status: z.custom<MessageStatus>((v) => typeof v === \"string\"),\n});\n/** Completion event for one `ask_genie` invocation, including its terminal status. */\nexport type AskGenieDoneEvent = z.infer<typeof AskGenieDoneEventSchema>;\n\n/**\n * Mastra-only error event: terminal Genie agent / transport\n * error. Genie's own `FAILED` / `CANCELLED` come through the\n * wire's `result` event - this variant is for failures the wire\n * can't represent (network, Genie agent crash, planner error,\n * etc.) plus a UI-friendly mirror of `result` when the status is\n * non-`COMPLETED`.\n */\nexport const MastraGenieErrorEventSchema = z.object({\n  type: z.literal(\"error\"),\n  spaceId: z.string().optional(),\n  conversationId: z.string().optional(),\n  messageId: z.string().optional(),\n  error: z.string(),\n});\n/** Mastra-side failure event for errors outside Genie's normal terminal result. */\nexport type MastraGenieErrorEvent = z.infer<typeof MastraGenieErrorEventSchema>;\n\n/**\n * Mastra-only lifecycle event: the inner Genie agent's\n * structured-output coercion has landed. Fires once per Genie\n * tool invocation, AFTER `agent.generate(...)` completes (i.e.\n * the inner loop + Mastra's structuring pass have both\n * finished) and BEFORE the wrapper hydrates each `data` item\n * with a chart. Signals to the host UI that the agent has\n * stopped reasoning and is moving into chart generation.\n *\n * The structuring pass itself is opaque (it runs inside\n * Mastra's `agent.generate(...)` together with the tool loop)\n * so this is the earliest hook we can offer; we can't fire a\n * \"summary started\" event the way we fire `started`.\n */\nexport const SummaryEventSchema = z.object({\n  type: z.literal(\"summary\"),\n  spaceId: z.string(),\n  /** Total number of items in the agent's structured summary. */\n  items: z.number().int().nonnegative(),\n  /** Count of `text` / prose items in the summary. */\n  textItems: z.number().int().nonnegative(),\n  /**\n   * Count of `data` items the wrapper will hydrate into charts.\n   * The host UI can use this to seed N chart skeletons before\n   * the per-chart events arrive.\n   */\n  dataItems: z.number().int().nonnegative(),\n});\n/** Lifecycle event emitted before summary data items are hydrated into charts. */\nexport type SummaryEvent = z.infer<typeof SummaryEventSchema>;\n\n/**\n * Mastra-only event union. Each variant uses the same flat\n * `{type, ...fields}` shape as {@link GenieChatEvent} so\n * subscribers union both with a single `switch (event.type)`.\n */\nexport const GenieAgentEventSchema = z.discriminatedUnion(\"type\", [\n  StartedEventSchema,\n  AskGenieDoneEventSchema,\n  MastraGenieErrorEventSchema,\n  SummaryEventSchema,\n]);\n/** Mastra-owned lifecycle events layered on top of Genie's wire event stream. */\nexport type GenieAgentEvent = z.infer<typeof GenieAgentEventSchema>;\n\n/**\n * The unified writer-event vocabulary subscribers see on\n * `ctx.writer`: the wire-derived {@link GenieChatEvent} union\n * **plus** Mastra-only events from {@link GenieAgentEvent}. Each\n * variant is a flat `{type, ...fields}` object; consumers narrow\n * on `type` and read fields inline - there is no payload wrapper\n * and no writer-boundary translator.\n *\n * Composed via `z.union` (not `z.discriminatedUnion`) because\n * both halves are themselves discriminated unions on the same\n * `type` key.\n */\nexport const GenieWriterEventSchema = z.union([\n  genieModel.GenieChatEventSchema,\n  GenieAgentEventSchema,\n]);\n/** Complete event vocabulary written by the Mastra Genie integration. */\nexport type GenieWriterEvent = z.infer<typeof GenieWriterEventSchema>;\n\n/** Discriminator type for {@link GenieWriterEvent}. */\nexport type GenieWriterEventType = GenieWriterEvent[\"type\"];\n\n/** Native AI SDK custom data-part type carrying one Genie progress event. */\nexport const GENIE_PROGRESS_PART_TYPE = \"data-genie-progress\" as const;\n\n/**\n * Data attached to {@link GENIE_PROGRESS_PART_TYPE}. `toolCallId` associates\n * progress with the native tool part that owns the request and result.\n */\nexport const GenieProgressPartDataSchema = z.object({\n  toolCallId: z.string(),\n  event: GenieWriterEventSchema,\n});\n/** Validated payload carried by a native Genie progress data part. */\nexport type GenieProgressPartData = z.infer<typeof GenieProgressPartDataSchema>;\n\n/* ------------------------- summary + dataset ------------------------ */\n\n/**\n * Tabular payload embedded in every {@link GenieSummaryItem}\n * `visualize` dataset. Always present: hydrated by the workflow's\n * agent step before the finalize step runs, so consumers can render\n * a table fallback regardless of chart-planner outcome.\n *\n * Fields:\n *   - `columns`: column names in display order.\n *   - `rows`: tabular rows keyed by column name.\n *   - `rowCount`: total row count Genie reported (may exceed\n *     `rows.length` when the statement was truncated).\n */\nexport const GenieDatasetDataSchema = z.object({\n  columns: z.array(z.string()),\n  rows: z.array(z.record(z.string(), z.unknown())),\n  rowCount: z.number(),\n});\n/** Hydrated tabular data that always backs a Genie visualization item. */\nexport type GenieDatasetData = z.infer<typeof GenieDatasetDataSchema>;\n\n/**\n * Slim chart reference attached to a visualize dataset. Only\n * present when planning succeeded.\n *\n * `option` is intentionally NOT included. The resolved Echarts\n * spec lives off-band in the chart cache: the host UI fetches it\n * by `chartId` from the plugin's embed route (derived from\n * `basePath` + {@link MASTRA_ROUTES}.embed, i.e. `/embed/chart/:id`;\n * see {@link Chart}). Embedding the full spec inline would\n * inflate every dataset by several KB per chart and round-trip\n * through the LLM context for zero benefit (the model only needs\n * the `chartId` to place a `[chart:<chartId>]` marker in its\n * reply).\n */\nexport const GenieDatasetChartSchema = z.object({\n  chartId: z.string(),\n  chartType: ChartTypeSchema,\n});\n/** Lightweight reference to a chart plan stored in the Mastra chart cache. */\nexport type GenieDatasetChart = z.infer<typeof GenieDatasetChartSchema>;\n\n/**\n * Dataset bundle attached to a {@link GenieSummaryItem} `visualize`\n * item. `data` is always populated; `chart` is best-effort and\n * absent when the workflow's chart-planner failed (timeout,\n * malformed plan, abort) so the host UI can still render the\n * underlying table.\n */\nexport const GenieDatasetSchema = z.object({\n  data: GenieDatasetDataSchema,\n  chart: GenieDatasetChartSchema.optional(),\n});\n/** Visualization dataset with required table data and an optional planned chart. */\nexport type GenieDataset = z.infer<typeof GenieDatasetSchema>;\n\n/**\n * One item inside the Genie workflow's final summary. The\n * workflow produces a mixed sequence of:\n *\n *   - `string`: a markdown paragraph (interpretation, callouts,\n *     transitions between data blocks).\n *   - `visualize`: a request from the agent step to visualize a\n *     specific Genie statement at this position in the prose.\n *     The finalize step hydrates `dataset.data` (rows from the\n *     matching `statementId`) and attaches `dataset.chart` after\n *     running the chart-planner. The agent NEVER picks the chart\n *     type - it only marks where a visualization belongs.\n *\n * The host UI walks the array in display order to compose the\n * final assistant message.\n */\nexport const GenieSummaryItemSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(\"string\"),\n    text: z.string(),\n  }),\n  z.object({\n    type: z.literal(\"visualize\"),\n    statementId: z.string(),\n    title: z.string().optional(),\n    description: z.string().optional(),\n    dataset: GenieDatasetSchema,\n  }),\n]);\n/** Ordered prose or visualization item in the Genie agent's final summary. */\nexport type GenieSummaryItem = z.infer<typeof GenieSummaryItemSchema>;\n\n/** Discriminator type for {@link GenieSummaryItem}. */\nexport type GenieSummaryItemType = GenieSummaryItem[\"type\"];\n\n/**\n * The Genie agent's final output shape - what the calling agent's\n * Genie tool returns to the calling LLM. The `summary` array is\n * the user-facing renderable; `conversationId` lets the calling\n * agent (or the UI) follow up in the same Genie thread on the\n * next turn.\n */\nexport const GenieAgentResultSchema = z.object({\n  spaceId: z.string(),\n  conversationId: z.string().optional(),\n  summary: z.array(GenieSummaryItemSchema),\n  error: z.string().optional(),\n});\n/** Final renderable output returned by the Genie agent tool to its caller. */\nexport type GenieAgentResult = z.infer<typeof GenieAgentResultSchema>;\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/feedback.ts","../src/marker.ts","../src/override.ts","../src/routes.ts","../src/thread.ts","../src/wire.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/feedback.ts","../src/markers.ts","../src/override.ts","../src/routes.ts","../src/thread.ts","../src/wire.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -24,8 +24,8 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-genie": "^0.9.5",
-    "@dbx-tools/shared-model": "^0.9.5",
+    "@dbx-tools/shared-genie": "^0.9.7",
+    "@dbx-tools/shared-model": "^0.9.7",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -42,7 +42,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.5",
+  "version": "0.9.7",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/wire.ts

@@ -23,7 +23,7 @@
  *      ({@link GenieAgentResult} and its summary / dataset items).
  *
  * The route segments live in the sibling `routes.ts`
- * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `marker.ts`,
+ * ({@link MASTRA_ROUTES}) and the embed-marker grammar in `markers.ts`,
  * so this file stays purely declarative (schemas + inferred types).
  * The browser client that drives these routes (`MastraPluginClient`)
  * ships from `@dbx-tools/ui-mastra`.

package/lib/src/marker.js

@@ -1,133 +0,0 @@
-/**
- * Agent-prose embed marker grammar.
- *
- * The Mastra agent is instructed to defer visualizations to the host
- * UI by embedding markers in its markdown reply; the UI parses them
- * out and swaps in the matching slot. This module is the single
- * source of truth for that grammar so every consumer parses markers
- * the same way and can't drift from the shapes documented on
- * {@link ChartSchema} / {@link StatementDataSchema} in `protocol.ts`
- * and the instructions the server hands the model.
- *
- * One grammar, open-ended type. A marker is `[<type>:<id>]`. The
- * `<type>` is an opaque token that names the embed kind; the host
- * resolves it against the generic `/embed/<type>/<id>` route, which
- * 404s any type the server doesn't register. The grammar does NOT
- * hard-code the known types - new embed kinds work end to end
- * without touching this regex. Today the server registers:
- *
- *   - `[chart:<chartId>]` - the `<chartId>` is a v4 UUID minted by
- *     the chart subsystem (`prepare_chart` / `render_data`) and
- *     resolves to a cached Echarts spec.
- *   - `[data:<statementId>]` - the `<statementId>` is a Databricks
- *     statement id (a time-ordered UUID) and resolves to the
- *     statement's rows.
- *
- * The `<id>` of a real embed is UUID-shaped (`8-4-4-4-12` hex): both
- * id kinds above are UUIDs, just different versions (chart = v4,
- * statement = v7-style). The grammar deliberately captures ANY
- * non-bracket id token, not just UUID-shaped ones, so a fabricated
- * marker the model glued together from a label
- * (e.g. `[chart:placeholder]` or
- * `[chart:01f163b6-1eac-region-fill-oos]`) still parses as a marker.
- * Matching it - rather than letting the broad regex miss it - is what
- * lets the host UI consume and obscure the bogus marker instead of
- * leaking the literal `[chart:...]` text into the rendered prose.
- * Whether an id is a genuine embed is a separate {@link isUuid}
- * check the caller runs on {@link ParsedMarker.id}.
- *
- * Parse everything through {@link parseMarkers}, validate the id with
- * {@link isUuid}, and branch on the returned {@link ParsedMarker.type}.
- *
- * @module
- */
-/**
- * Single matcher for ANY embed marker, regardless of type. Matches
- * `[<type>:<id>]`. Capture group 1 is the marker type token (e.g.
- * `chart`, `data`); group 2 is the id - any run of non-bracket,
- * non-whitespace characters, NOT constrained to a UUID shape.
- *
- * Neither the type nor the id shape is enumerated here. The type is
- * left open because the server's resolver registry decides which
- * types are real and 404s the rest, so a new embed kind needs no
- * grammar change. The id is left broad on purpose: a fabricated
- * marker the model emits from a label (e.g. `[chart:placeholder]`)
- * MUST still match so the host UI can consume and obscure it rather
- * than leak the literal `[chart:...]` text into the prose. The id is
- * then validated with {@link isUuid} downstream; non-UUID ids resolve
- * to no embed.
- *
- * Safe to share as a `/g` constant: it's only ever consumed via
- * {@link String.prototype.matchAll}, which clones the regex and
- * never advances this object's `lastIndex`. (A `.exec()`/`.test()`
- * loop would need a fresh regex each time, but we don't do that.)
- */
-const MARKER_RE = /\[([A-Za-z][A-Za-z0-9_-]*):([^\]\s]+)\]/g;
-/**
- * UUID matcher (`8-4-4-4-12` hex, any version) anchored to the whole
- * string. Covers v4 chart ids and time-ordered (v7-style) statement
- * ids alike. Used by {@link isUuid} to tell a genuine embed id apart
- * from a label the model fabricated into a marker.
- */
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
- * Whether `id` is a UUID-shaped embed id. The marker grammar
- * ({@link MARKER_RE}) matches any non-bracket id token so fabricated
- * markers don't leak as literal prose; this is the guard callers run
- * to decide whether an id is a real embed (render the slot) or a
- * bogus label to obscure (drop the marker entirely).
- */
-export function isUuid(id) {
-    return UUID_RE.test(id);
-}
-/**
- * Build the exact embed marker the agent should place in prose.
- *
- * Tool results return this complete value so the model copies one opaque token
- * rather than reconstructing it from `type` plus `id`. Reconstruction is where
- * valid-looking but never-minted UUIDs enter transcripts and produce a 404.
- */
-export function formatMarker(type, id) {
-    return `[${type}:${id}]`;
-}
-/**
- * Parse every embed marker out of `text`, in source order. A single
- * regex pass means matches never overlap, so callers can splice the
- * spans directly without a sort/dedupe step. This is the one entry
- * point for marker parsing: type branching runs on the returned
- * markers. The grammar ({@link MARKER_RE}) matches any non-bracket id
- * token, so a returned {@link ParsedMarker.id} is NOT guaranteed to
- * be a real embed id - run it through {@link isUuid} to tell a
- * genuine embed apart from a fabricated label, which the caller then
- * obscures rather than rendering.
- */
-export function parseMarkers(text) {
-    const out = [];
-    for (const match of text.matchAll(MARKER_RE)) {
-        const start = match.index ?? 0;
-        out.push({
-            // Group 1 is the `<type>` token; the server's embed registry
-            // (not this parser) decides whether it's supported.
-            type: match[1] ?? "",
-            id: match[2] ?? "",
-            start,
-            end: start + match[0].length,
-        });
-    }
-    return out;
-}
-/**
- * Strip a trailing partial marker (`[chart`, `[data:01f1`, ...) that
- * hasn't received its closing `]` yet. While the model streams
- * text-deltas a marker arrives across several chunks, and rendering
- * each interim state would briefly flash the literal `[chart:abc-`
- * prefix before the closing bracket swaps it for a slot. Hiding any
- * trailing `[<non-whitespace-non-bracket>...` suffix keeps the prose
- * stable until either a `]` (full marker) or whitespace (definitely
- * not a marker) lands. Persisted transcripts never end mid-marker,
- * so this is a no-op on reload.
- */
-export function stripIncompleteMarkerTail(text) {
-    return text.replace(/\[[^\s[\]]*$/, "");
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"marker.js","sourceRoot":"","sources":["../../src/marker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAYH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,SAAS,GAAG,0CAA0C,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,OAAO,GAAG,iEAAiE,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CAAC,EAAU;IAC/B,OAAO,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAgB,EAAE,EAAU;IACvD,OAAO,IAAI,IAAI,IAAI,EAAE,GAAG,CAAC;AAC3B,CAAC;AAcD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QAC/B,GAAG,CAAC,IAAI,CAAC;YACP,6DAA6D;YAC7D,oDAAoD;YACpD,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;YACpB,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;YAClB,KAAK;YACL,GAAG,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM;SAC7B,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,yBAAyB,CAAC,IAAY;IACpD,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["/**\n * Agent-prose embed marker grammar.\n *\n * The Mastra agent is instructed to defer visualizations to the host\n * UI by embedding markers in its markdown reply; the UI parses them\n * out and swaps in the matching slot. This module is the single\n * source of truth for that grammar so every consumer parses markers\n * the same way and can't drift from the shapes documented on\n * {@link ChartSchema} / {@link StatementDataSchema} in `protocol.ts`\n * and the instructions the server hands the model.\n *\n * One grammar, open-ended type. A marker is `[<type>:<id>]`. The\n * `<type>` is an opaque token that names the embed kind; the host\n * resolves it against the generic `/embed/<type>/<id>` route, which\n * 404s any type the server doesn't register. The grammar does NOT\n * hard-code the known types - new embed kinds work end to end\n * without touching this regex. Today the server registers:\n *\n *   - `[chart:<chartId>]` - the `<chartId>` is a v4 UUID minted by\n *     the chart subsystem (`prepare_chart` / `render_data`) and\n *     resolves to a cached Echarts spec.\n *   - `[data:<statementId>]` - the `<statementId>` is a Databricks\n *     statement id (a time-ordered UUID) and resolves to the\n *     statement's rows.\n *\n * The `<id>` of a real embed is UUID-shaped (`8-4-4-4-12` hex): both\n * id kinds above are UUIDs, just different versions (chart = v4,\n * statement = v7-style). The grammar deliberately captures ANY\n * non-bracket id token, not just UUID-shaped ones, so a fabricated\n * marker the model glued together from a label\n * (e.g. `[chart:placeholder]` or\n * `[chart:01f163b6-1eac-region-fill-oos]`) still parses as a marker.\n * Matching it - rather than letting the broad regex miss it - is what\n * lets the host UI consume and obscure the bogus marker instead of\n * leaking the literal `[chart:...]` text into the rendered prose.\n * Whether an id is a genuine embed is a separate {@link isUuid}\n * check the caller runs on {@link ParsedMarker.id}.\n *\n * Parse everything through {@link parseMarkers}, validate the id with\n * {@link isUuid}, and branch on the returned {@link ParsedMarker.type}.\n *\n * @module\n */\n\n/**\n * The embed kind named by a marker's `<type>` segment. Left as an\n * open `string` (not a closed union) so the grammar stays generic:\n * the authoritative set of supported types lives in the server's\n * `/embed/:type/:id` resolver registry, and an unknown type simply\n * 404s. The two types the server ships today are `\"chart\"` and\n * `\"data\"`.\n */\nexport type MarkerType = string;\n\n/**\n * Single matcher for ANY embed marker, regardless of type. Matches\n * `[<type>:<id>]`. Capture group 1 is the marker type token (e.g.\n * `chart`, `data`); group 2 is the id - any run of non-bracket,\n * non-whitespace characters, NOT constrained to a UUID shape.\n *\n * Neither the type nor the id shape is enumerated here. The type is\n * left open because the server's resolver registry decides which\n * types are real and 404s the rest, so a new embed kind needs no\n * grammar change. The id is left broad on purpose: a fabricated\n * marker the model emits from a label (e.g. `[chart:placeholder]`)\n * MUST still match so the host UI can consume and obscure it rather\n * than leak the literal `[chart:...]` text into the prose. The id is\n * then validated with {@link isUuid} downstream; non-UUID ids resolve\n * to no embed.\n *\n * Safe to share as a `/g` constant: it's only ever consumed via\n * {@link String.prototype.matchAll}, which clones the regex and\n * never advances this object's `lastIndex`. (A `.exec()`/`.test()`\n * loop would need a fresh regex each time, but we don't do that.)\n */\nconst MARKER_RE = /\\[([A-Za-z][A-Za-z0-9_-]*):([^\\]\\s]+)\\]/g;\n\n/**\n * UUID matcher (`8-4-4-4-12` hex, any version) anchored to the whole\n * string. Covers v4 chart ids and time-ordered (v7-style) statement\n * ids alike. Used by {@link isUuid} to tell a genuine embed id apart\n * from a label the model fabricated into a marker.\n */\nconst UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * Whether `id` is a UUID-shaped embed id. The marker grammar\n * ({@link MARKER_RE}) matches any non-bracket id token so fabricated\n * markers don't leak as literal prose; this is the guard callers run\n * to decide whether an id is a real embed (render the slot) or a\n * bogus label to obscure (drop the marker entirely).\n */\nexport function isUuid(id: string): boolean {\n  return UUID_RE.test(id);\n}\n\n/**\n * Build the exact embed marker the agent should place in prose.\n *\n * Tool results return this complete value so the model copies one opaque token\n * rather than reconstructing it from `type` plus `id`. Reconstruction is where\n * valid-looking but never-minted UUIDs enter transcripts and produce a 404.\n */\nexport function formatMarker(type: MarkerType, id: string): string {\n  return `[${type}:${id}]`;\n}\n\n/** One marker found in agent prose, with its source span. */\nexport interface ParsedMarker {\n  /** Marker kind token (e.g. `chart`, `data`); see {@link MarkerType}. */\n  type: MarkerType;\n  /** Raw id captured from the marker (chart id or statement id). */\n  id: string;\n  /** Index of the marker's first character in the source text. */\n  start: number;\n  /** Index one past the marker's last character. */\n  end: number;\n}\n\n/**\n * Parse every embed marker out of `text`, in source order. A single\n * regex pass means matches never overlap, so callers can splice the\n * spans directly without a sort/dedupe step. This is the one entry\n * point for marker parsing: type branching runs on the returned\n * markers. The grammar ({@link MARKER_RE}) matches any non-bracket id\n * token, so a returned {@link ParsedMarker.id} is NOT guaranteed to\n * be a real embed id - run it through {@link isUuid} to tell a\n * genuine embed apart from a fabricated label, which the caller then\n * obscures rather than rendering.\n */\nexport function parseMarkers(text: string): ParsedMarker[] {\n  const out: ParsedMarker[] = [];\n  for (const match of text.matchAll(MARKER_RE)) {\n    const start = match.index ?? 0;\n    out.push({\n      // Group 1 is the `<type>` token; the server's embed registry\n      // (not this parser) decides whether it's supported.\n      type: match[1] ?? \"\",\n      id: match[2] ?? \"\",\n      start,\n      end: start + match[0].length,\n    });\n  }\n  return out;\n}\n\n/**\n * Strip a trailing partial marker (`[chart`, `[data:01f1`, ...) that\n * hasn't received its closing `]` yet. While the model streams\n * text-deltas a marker arrives across several chunks, and rendering\n * each interim state would briefly flash the literal `[chart:abc-`\n * prefix before the closing bracket swaps it for a slot. Hiding any\n * trailing `[<non-whitespace-non-bracket>...` suffix keeps the prose\n * stable until either a `]` (full marker) or whitespace (definitely\n * not a marker) lands. Persisted transcripts never end mid-marker,\n * so this is a no-op on reload.\n */\nexport function stripIncompleteMarkerTail(text: string): string {\n  return text.replace(/\\[[^\\s[\\]]*$/, \"\");\n}\n"]}