@dbx-tools/shared-mastra 0.3.43 → 0.4.0

package/lib/src/wire.js

@@ -0,0 +1,569 @@
+/**
+ * Wire-format contract for `@dbx-tools/appkit-mastra`: the
+ * dependency-free zod schemas + inferred types every consumer (the
+ * React client, browser bundles, the server plugin) shares.
+ *
+ * Kept free of `pg`, `fastembed`, and the Mastra runtime so the
+ * client can import these schemas without dragging in server-only
+ * dependencies. Three layers live here:
+ *
+ *   1. The descriptor published by `MastraPlugin.clientConfig()`
+ *      plus the REST payloads its routes return (models, history,
+ *      suggestions, chart embeds, statement data). The server
+ *      derives every path from the plugin mount and publishes the
+ *      resolved paths so the client composes URLs without
+ *      hard-coding `/api/mastra` - rename the plugin and the client
+ *      keeps working.
+ *   2. The `ctx.writer` event vocabulary: the wire-derived
+ *      {@link GenieChatEvent}s from `@dbx-tools/genie-shared` plus
+ *      the Mastra-only agent lifecycle events, unified as
+ *      {@link GenieWriterEvent} so subscribers narrow both halves
+ *      with a single `switch (event.type)`.
+ *   3. The Genie agent's workflow output shapes
+ *      ({@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`,
+ * so this file stays purely declarative (schemas + inferred types).
+ * The browser client that drives these routes (`MastraPluginClient`)
+ * ships from `@dbx-tools/appkit-mastra-ui`.
+ *
+ * @module
+ */
+import { genieModel } from "@dbx-tools/shared-genie";
+import { model } from "@dbx-tools/shared-model";
+import { z } from "zod";
+/* ---------------------------- client config ---------------------------- */
+/**
+ * JSON-safe descriptor published by the Mastra plugin's
+ * `clientConfig()`.
+ *
+ * Only the irreducible data lives here: `basePath` (the one path the
+ * client can't otherwise know, since it encodes the plugin's mount
+ * name) plus the runtime agent roster. Every concrete endpoint URL is
+ * derived from `basePath` by the browser client
+ * (`MastraPluginClient`) using the shared {@link MASTRA_ROUTES}
+ * segments, so there's nothing to publish per-route.
+ *
+ * Fields:
+ *   - `basePath`: plugin mount path. Always `/api/<pluginName>`. Feed
+ *     it to `new MastraPluginClient(config)` (from
+ *     `@dbx-tools/appkit-mastra-ui`) to get a typed client over every
+ *     route plus the standard agent stream.
+ *   - `defaultAgent`: agent id the client converses with when it
+ *     doesn't name one.
+ *   - `agents`: every registered agent id in registration order.
+ *   - `feedbackEnabled`: whether the server can log user feedback to
+ *     MLflow (MLflow tracing is configured). Drives whether the chat UI
+ *     surfaces thumbs / comment controls. Defaults to `false` so a
+ *     config published by an older server (without the field) parses
+ *     cleanly to "off".
+ */
+export const MastraClientConfigSchema = z.object({
+    basePath: z.string(),
+    defaultAgent: z.string(),
+    agents: z.array(z.string()),
+    feedbackEnabled: z.boolean().default(false),
+});
+/**
+ * JSON payload returned by `GET ${basePath}/default-model[?agentId=]`. The
+ * static default model the agent resolves to when the client pins no model,
+ * as both the raw serving-endpoint `model` id and a `displayName` (the
+ * humanized label the picker shows). Both are `null` when the agent decides
+ * its model dynamically at call time (nothing static to advertise). Lets the
+ * picker label its default option WITHOUT waiting on the `/models` catalogue,
+ * so it never flashes a raw id on load. Kept off the static bootstrap
+ * `clientConfig` on purpose: it is per-agent and can be dynamic, so it is
+ * fetched like `/models`.
+ */
+export const DefaultModelResponseSchema = z.object({
+    agentId: z.string(),
+    model: z.string().nullable(),
+    displayName: z.string().nullable(),
+});
+/* ---------------------------- model catalogue ---------------------------- */
+/**
+ * JSON payload returned by `GET ${basePath}/models`. Wraps the shared
+ * {@link model.ServingEndpointSummarySchema} (re-exported from
+ * `@dbx-tools/shared-model`) so the catalogue
+ * descriptor has a single definition the client, server, and the
+ * standalone `@dbx-tools/model` toolkit all agree on.
+ */
+export const ServingEndpointsResponseSchema = z.object({
+    endpoints: z.array(model.ServingEndpointSummarySchema),
+});
+/* ----------------------------- chat history ----------------------------- */
+/**
+ * Structural shape for an AI SDK V5 `UIMessage`. Defined locally
+ * so the shared types package stays dependency-free (no `ai`
+ * import). The runtime values returned by the `/history` endpoint
+ * are produced by `toAISdkV5Messages` and are 1:1 compatible with
+ * `UIMessage` from the `ai` package; clients can safely cast when
+ * needed.
+ */
+export const MastraHistoryUIMessageSchema = z.object({
+    id: z.string(),
+    role: z.enum(["system", "user", "assistant"]),
+    parts: z.array(z.unknown()).readonly(),
+    metadata: z.unknown().optional(),
+});
+/**
+ * JSON payload returned by `GET ${basePath}/history`.
+ *
+ * Fields:
+ *   - `uiMessages`: page of UI-formatted messages, oldest -> newest.
+ *     Always chronological regardless of the underlying pagination
+ *     order so the client can prepend the array to the live
+ *     transcript without sorting.
+ *   - `page`: zero-indexed page that produced this response.
+ *   - `perPage`: number of items requested per page.
+ *   - `total`: total number of messages in the thread.
+ *   - `hasMore`: true when at least one older page is still
+ *     available.
+ */
+export const MastraHistoryResponseSchema = z.object({
+    uiMessages: z.array(MastraHistoryUIMessageSchema),
+    page: z.number(),
+    perPage: z.number(),
+    total: z.number(),
+    hasMore: z.boolean(),
+});
+/**
+ * JSON payload returned by `DELETE ${basePath}/history`. Deletes
+ * every persisted message + workflow snapshot tied to the caller's
+ * thread, so the next chat turn starts from a clean slate. The
+ * session cookie that anchors the thread id is preserved so the
+ * caller doesn't lose its identity - only the contents go away.
+ *
+ * `ok` is always `true` on success; the response object is kept
+ * as a struct (vs a bare 204) so future fields (e.g. `deletedAt`,
+ * `messages`) can be added without bumping the contract.
+ *
+ * Fields:
+ *   - `ok`: literal `true` on success.
+ *   - `agentId`: agent whose history was cleared.
+ *   - `threadId`: thread id that was wiped.
+ *   - `cleared`: number of messages the thread held before
+ *     deletion. Useful for client-side "cleared 12 messages"
+ *     toasts; `0` is reported when the thread was already empty
+ *     (call is idempotent).
+ */
+export const MastraClearHistoryResponseSchema = z.object({
+    ok: z.literal(true),
+    agentId: z.string(),
+    threadId: z.string(),
+    cleared: z.number(),
+});
+/* -------------------------------- threads -------------------------------- */
+/**
+ * A single conversation thread the resource (authenticated user) owns,
+ * as returned by `GET ${basePath}/threads`. Mirrors Mastra's
+ * `StorageThreadType` but with JSON-safe ISO-8601 timestamps (the wire
+ * can't carry `Date`).
+ *
+ * Fields:
+ *   - `id`: thread id. Pass it back as the thread-selection header
+ *     (`THREAD_ID_HEADER`) on a stream / history / delete call to act
+ *     on this conversation.
+ *   - `title`: human-readable title. Present once the agent's memory
+ *     has auto-generated one (after the first turn); absent on a
+ *     brand-new thread, so the UI falls back to a placeholder.
+ *   - `resourceId`: owning resource (the user id). Always the caller's
+ *     own resource - the list route filters by it server-side.
+ *   - `createdAt` / `updatedAt`: ISO-8601 timestamps. `updatedAt` is
+ *     the natural sort key for "most recent conversations first".
+ *   - `metadata`: opaque thread metadata, passed through untouched.
+ */
+export const MastraThreadSchema = z.object({
+    id: z.string(),
+    title: z.string().optional(),
+    resourceId: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    metadata: z.unknown().optional(),
+});
+/**
+ * JSON payload returned by `GET ${basePath}/threads`. One page of the
+ * caller's conversation threads, newest (`updatedAt` DESC) first.
+ *
+ * Fields:
+ *   - `threads`: page of threads for the caller's resource.
+ *   - `page`: zero-indexed page that produced this response.
+ *   - `perPage`: number of items requested per page.
+ *   - `total`: total number of threads the resource owns.
+ *   - `hasMore`: true when at least one more page is available.
+ */
+export const MastraThreadsResponseSchema = z.object({
+    threads: z.array(MastraThreadSchema),
+    page: z.number(),
+    perPage: z.number(),
+    total: z.number(),
+    hasMore: z.boolean(),
+});
+/**
+ * JSON payload returned by `DELETE ${basePath}/threads` (thread id
+ * supplied via the thread-selection header / `threadId` query). Wipes
+ * the named thread and every message on it.
+ *
+ * Fields:
+ *   - `ok`: literal `true` on success.
+ *   - `agentId`: agent whose thread was deleted.
+ *   - `threadId`: thread id that was removed.
+ *   - `deleted`: `true` when a thread row existed and was removed,
+ *     `false` when it was already gone (call is idempotent).
+ */
+export const MastraDeleteThreadResponseSchema = z.object({
+    ok: z.literal(true),
+    agentId: z.string(),
+    threadId: z.string(),
+    deleted: z.boolean(),
+});
+/** Longest thread title the rename route accepts (trimmed server-side). */
+export const MASTRA_THREAD_TITLE_MAX = 200;
+/**
+ * JSON body for `PATCH ${basePath}/threads` (thread id supplied via the
+ * thread-selection header / `threadId` query). Renames a single
+ * conversation.
+ *
+ * Fields:
+ *   - `title`: the new human-readable title. Trimmed and capped at
+ *     {@link MASTRA_THREAD_TITLE_MAX} characters server-side; must be
+ *     non-empty after trimming.
+ */
+export const MastraUpdateThreadRequestSchema = z.object({
+    title: z.string().trim().min(1).max(MASTRA_THREAD_TITLE_MAX),
+});
+/**
+ * JSON payload returned by `PATCH ${basePath}/threads`. Echoes the
+ * renamed thread in its post-update wire shape so the client can reflect
+ * the new title without a re-fetch.
+ *
+ * Fields:
+ *   - `ok`: literal `true` on success.
+ *   - `agentId`: agent whose thread was renamed.
+ *   - `thread`: the updated thread (carries the new `title`).
+ */
+export const MastraUpdateThreadResponseSchema = z.object({
+    ok: z.literal(true),
+    agentId: z.string(),
+    thread: MastraThreadSchema,
+});
+/* ------------------------------ suggestions ------------------------------ */
+/**
+ * JSON payload returned by `GET ${basePath}/suggestions`.
+ *
+ * Carries the curated starter questions for an agent's Genie space -
+ * the `sample_questions` an author configured on the space, surfaced
+ * as one-tap prompts on the chat's empty state. `questions` is empty
+ * when the agent has no Genie space (or the space defines none), so
+ * the client renders nothing in that case rather than falling back to
+ * built-in example prompts.
+ */
+export const MastraSuggestionsResponseSchema = z.object({
+    questions: z.array(z.string()),
+});
+/* --------------------------------- charts --------------------------------- */
+/**
+ * Allowed chart types the planner can pick. Defined as a
+ * discriminated literal union so each variant carries its own
+ * `.describe()` clause - the server-side planner's prompt
+ * formatter walks `.options` to inline the descriptions into the
+ * model instructions, keeping the prompt in lock-step with the
+ * schema by construction. The runtime type is the plain string
+ * union (`"bar" | "line" | ...`), so consumers that just need a
+ * discriminator value behave the same as if it were a
+ * `z.enum([...])`.
+ */
+export const ChartTypeSchema = z
+    .union([
+    z
+        .literal("bar")
+        .describe("comparing a numeric value across a small/medium set of discrete categories (top-N, ranking, group-by)"),
+    z
+        .literal("line")
+        .describe("ordered-axis trend (time series, sequence, rank) where the x-axis has natural order"),
+    z.literal("area").describe("stacked-trend emphasis - cumulative or composition over time"),
+    z
+        .literal("scatter")
+        .describe("two-numeric-axis correlations between fields (e.g. price vs. quantity)"),
+    z.literal("pie").describe("parts-of-a-whole when 2-7 categories sum to a meaningful total"),
+])
+    .describe("The chart shape that best matches the data and intent.");
+/**
+ * Resolved chart plan a settled chart entry carries on its
+ * `result` field. `option` is the full Echarts spec; pass
+ * straight into `<ReactECharts option={...}>`.
+ */
+export const ChartResultSchema = z.object({
+    chartType: ChartTypeSchema,
+    option: z
+        .record(z.string(), z.unknown())
+        .describe("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."),
+});
+/**
+ * Wire-format AND server-side cache shape for a chart entry.
+ * Three lifecycle states inferred from the two optional fields
+ * (no discriminator needed):
+ *
+ *   - `result` set                    -> chart is ready to render
+ *   - `error` set                     -> planner / data fetch failed
+ *   - both `result` and `error` unset -> still processing
+ *
+ * `option` is typed as a generic record so this package stays
+ * dependency-free of `echarts`. The server (`chart.ts`) imports
+ * this schema directly; the demo client polls the
+ * `/embed/chart/:id` route and parses responses against it.
+ */
+export const ChartSchema = z.object({
+    chartId: z
+        .string()
+        .describe("Opaque id minted by the chart subsystem. Embed verbatim as `[chart:<chartId>]` in agent prose; the host UI resolves it against this cache entry."),
+    error: z
+        .string()
+        .optional()
+        .describe("Error message when the chart failed (data fetch error, planner error, empty dataset). Mutually exclusive with `result`; absent on success and while processing."),
+    result: ChartResultSchema.optional().describe("Resolved chart plan. Absent while processing and when the run errored."),
+});
+/* ------------------------------- statements ------------------------------- */
+/**
+ * Wire-format payload returned by `GET ${basePath}/embed/data/:id`.
+ *
+ * Mirrors the agent-side `get_statement` tool's output so the
+ * host UI and the LLM see the exact same shape for the same
+ * statement; the route is what resolves `[data:<statement_id>]`
+ * markers the agent embeds in prose.
+ *
+ * Fields:
+ *   - `columns`: column names in declaration order.
+ *   - `rows`: row records keyed by column name. Cell values are
+ *     either coerced numbers or the original strings (Genie /
+ *     Statement Execution returns every cell as `string | null`;
+ *     numeric-looking cells are coerced server-side so the UI
+ *     can format with `tabular-nums` without re-parsing).
+ *   - `rowCount`: total row count upstream (independent of the
+ *     `limit` cap). Compare against `rows.length` to detect
+ *     truncation - `truncated` is the precomputed flag.
+ *   - `truncated`: `true` when the server clipped rows to honor
+ *     the route's row cap; the UI should surface a "showing N of
+ *     M rows" affordance in that case.
+ */
+export const StatementDataSchema = z.object({
+    columns: z.array(z.string()),
+    rows: z.array(z.record(z.string(), z.unknown())),
+    rowCount: z.number(),
+    truncated: z.boolean(),
+});
+/* ---------------- mastra-only genie-agent events ---------------- */
+/**
+ * Mastra-only lifecycle event: the Genie tool invocation started.
+ * Emitted immediately when the calling agent invokes the Genie
+ * tool, before any inner agent / wire activity, so the UI can
+ * pop a "Thinking..." pill the instant the model decides to
+ * delegate. `conversationId` / `messageId` are absent on this
+ * first emit (no Genie round-trip yet). Field names are
+ * camelCase (vs the snake_case wire events) to mirror the
+ * Genie agent's own internal data plumbing.
+ */
+export const StartedEventSchema = z.object({
+    type: z.literal("started"),
+    spaceId: z.string(),
+    /**
+     * Genie conversation id, populated only when this `started`
+     * event corresponds to a follow-up turn on an existing
+     * conversation. Absent on the first turn.
+     */
+    conversationId: z.string().optional(),
+    /**
+     * Genie message id, populated only after the first wire
+     * `message` event lands. Absent on the immediate-on-invoke
+     * emit.
+     */
+    messageId: z.string().optional(),
+    /** Question the Genie agent sent to Genie. */
+    content: z.string(),
+});
+/**
+ * Mastra-only lifecycle event: one `ask_genie` invocation
+ * finished. Carries the hydrated `statementIds` (rows are fetched
+ * via `getStatement` separately) and Genie's final prose answer
+ * so the UI can move from "thinking" to "answered" without
+ * waiting for the Genie agent's whole reasoning loop to end.
+ */
+export const AskGenieDoneEventSchema = z.object({
+    type: z.literal("ask_genie_done"),
+    spaceId: z.string(),
+    conversationId: z.string().optional(),
+    messageId: z.string().optional(),
+    /** Genie's natural-language answer for the turn, if any. */
+    answer: z.string().optional(),
+    /** Statement ids for any non-empty result sets this turn produced. */
+    statementIds: z.array(z.string()),
+    /**
+     * Terminal wire status (`COMPLETED` / `FAILED` / `CANCELLED`).
+     * Mirrors the source `result` event's status so subscribers
+     * can react to ask-level completion without re-walking history.
+     * Treated as `z.custom<MessageStatus>` because the SDK is the
+     * source of truth for the enum values.
+     */
+    status: z.custom((v) => typeof v === "string"),
+});
+/**
+ * Mastra-only error event: terminal Genie agent / transport
+ * error. Genie's own `FAILED` / `CANCELLED` come through the
+ * wire's `result` event - this variant is for failures the wire
+ * can't represent (network, Genie agent crash, planner error,
+ * etc.) plus a UI-friendly mirror of `result` when the status is
+ * non-`COMPLETED`.
+ */
+export const MastraGenieErrorEventSchema = z.object({
+    type: z.literal("error"),
+    spaceId: z.string().optional(),
+    conversationId: z.string().optional(),
+    messageId: z.string().optional(),
+    error: z.string(),
+});
+/**
+ * Mastra-only lifecycle event: the inner Genie agent's
+ * structured-output coercion has landed. Fires once per Genie
+ * tool invocation, AFTER `agent.generate(...)` completes (i.e.
+ * the inner loop + Mastra's structuring pass have both
+ * finished) and BEFORE the wrapper hydrates each `data` item
+ * with a chart. Signals to the host UI that the agent has
+ * stopped reasoning and is moving into chart generation.
+ *
+ * The structuring pass itself is opaque (it runs inside
+ * Mastra's `agent.generate(...)` together with the tool loop)
+ * so this is the earliest hook we can offer; we can't fire a
+ * "summary started" event the way we fire `started`.
+ */
+export const SummaryEventSchema = z.object({
+    type: z.literal("summary"),
+    spaceId: z.string(),
+    /** Total number of items in the agent's structured summary. */
+    items: z.number().int().nonnegative(),
+    /** Count of `text` / prose items in the summary. */
+    textItems: z.number().int().nonnegative(),
+    /**
+     * Count of `data` items the wrapper will hydrate into charts.
+     * The host UI can use this to seed N chart skeletons before
+     * the per-chart events arrive.
+     */
+    dataItems: z.number().int().nonnegative(),
+});
+/**
+ * Mastra-only event union. Each variant uses the same flat
+ * `{type, ...fields}` shape as {@link GenieChatEvent} so
+ * subscribers union both with a single `switch (event.type)`.
+ */
+export const GenieAgentEventSchema = z.discriminatedUnion("type", [
+    StartedEventSchema,
+    AskGenieDoneEventSchema,
+    MastraGenieErrorEventSchema,
+    SummaryEventSchema,
+]);
+/**
+ * The unified writer-event vocabulary subscribers see on
+ * `ctx.writer`: the wire-derived {@link GenieChatEvent} union
+ * **plus** Mastra-only events from {@link GenieAgentEvent}. Each
+ * variant is a flat `{type, ...fields}` object; consumers narrow
+ * on `type` and read fields inline - there is no payload wrapper
+ * and no writer-boundary translator.
+ *
+ * Composed via `z.union` (not `z.discriminatedUnion`) because
+ * both halves are themselves discriminated unions on the same
+ * `type` key.
+ */
+export const GenieWriterEventSchema = z.union([
+    genieModel.GenieChatEventSchema,
+    GenieAgentEventSchema,
+]);
+/* ------------------------- summary + dataset ------------------------ */
+/**
+ * Tabular payload embedded in every {@link GenieSummaryItem}
+ * `visualize` dataset. Always present: hydrated by the workflow's
+ * agent step before the finalize step runs, so consumers can render
+ * a table fallback regardless of chart-planner outcome.
+ *
+ * Fields:
+ *   - `columns`: column names in display order.
+ *   - `rows`: tabular rows keyed by column name.
+ *   - `rowCount`: total row count Genie reported (may exceed
+ *     `rows.length` when the statement was truncated).
+ */
+export const GenieDatasetDataSchema = z.object({
+    columns: z.array(z.string()),
+    rows: z.array(z.record(z.string(), z.unknown())),
+    rowCount: z.number(),
+});
+/**
+ * Slim chart reference attached to a visualize dataset. Only
+ * present when planning succeeded.
+ *
+ * `option` is intentionally NOT included. The resolved Echarts
+ * spec lives off-band in the chart cache: the host UI fetches it
+ * by `chartId` from the plugin's embed route (derived from
+ * `basePath` + {@link MASTRA_ROUTES}.embed, i.e. `/embed/chart/:id`;
+ * see {@link Chart}). Embedding the full spec inline would
+ * inflate every dataset by several KB per chart and round-trip
+ * through the LLM context for zero benefit (the model only needs
+ * the `chartId` to place a `[chart:<chartId>]` marker in its
+ * reply).
+ */
+export const GenieDatasetChartSchema = z.object({
+    chartId: z.string(),
+    chartType: ChartTypeSchema,
+});
+/**
+ * Dataset bundle attached to a {@link GenieSummaryItem} `visualize`
+ * item. `data` is always populated; `chart` is best-effort and
+ * absent when the workflow's chart-planner failed (timeout,
+ * malformed plan, abort) so the host UI can still render the
+ * underlying table.
+ */
+export const GenieDatasetSchema = z.object({
+    data: GenieDatasetDataSchema,
+    chart: GenieDatasetChartSchema.optional(),
+});
+/**
+ * One item inside the Genie workflow's final summary. The
+ * workflow produces a mixed sequence of:
+ *
+ *   - `string`: a markdown paragraph (interpretation, callouts,
+ *     transitions between data blocks).
+ *   - `visualize`: a request from the agent step to visualize a
+ *     specific Genie statement at this position in the prose.
+ *     The finalize step hydrates `dataset.data` (rows from the
+ *     matching `statementId`) and attaches `dataset.chart` after
+ *     running the chart-planner. The agent NEVER picks the chart
+ *     type - it only marks where a visualization belongs.
+ *
+ * The host UI walks the array in display order to compose the
+ * final assistant message.
+ */
+export const GenieSummaryItemSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("string"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("visualize"),
+        statementId: z.string(),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        dataset: GenieDatasetSchema,
+    }),
+]);
+/**
+ * The Genie agent's final output shape - what the calling agent's
+ * Genie tool returns to the calling LLM. The `summary` array is
+ * the user-facing renderable; `conversationId` lets the calling
+ * agent (or the UI) follow up in the same Genie thread on the
+ * next turn.
+ */
+export const GenieAgentResultSchema = z.object({
+    spaceId: z.string(),
+    conversationId: z.string().optional(),
+    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/appkit-mastra-ui`.\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/appkit-mastra-ui`) 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 */\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});\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});\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});\nexport type ServingEndpointsResponse = z.infer<typeof ServingEndpointsResponseSchema>;\n\n/* ----------------------------- chat history ----------------------------- */\n\n/**\n * Structural shape for an AI SDK V5 `UIMessage`. Defined locally\n * so the shared types package stays dependency-free (no `ai`\n * import). The runtime values returned by the `/history` endpoint\n * are produced by `toAISdkV5Messages` and are 1:1 compatible with\n * `UIMessage` from the `ai` package; clients can safely cast when\n * needed.\n */\nexport const MastraHistoryUIMessageSchema = z.object({\n  id: z.string(),\n  role: z.enum([\"system\", \"user\", \"assistant\"]),\n  parts: z.array(z.unknown()).readonly(),\n  metadata: z.unknown().optional(),\n});\nexport type MastraHistoryUIMessage = z.infer<typeof MastraHistoryUIMessageSchema>;\n\n/**\n * JSON payload returned by `GET ${basePath}/history`.\n *\n * Fields:\n *   - `uiMessages`: page of UI-formatted messages, oldest -> newest.\n *     Always chronological regardless of the underlying pagination\n *     order so the client can prepend the array to the live\n *     transcript without sorting.\n *   - `page`: zero-indexed page that produced this response.\n *   - `perPage`: number of items requested per page.\n *   - `total`: total number of messages in the thread.\n *   - `hasMore`: true when at least one older page is still\n *     available.\n */\nexport const MastraHistoryResponseSchema = z.object({\n  uiMessages: z.array(MastraHistoryUIMessageSchema),\n  page: z.number(),\n  perPage: z.number(),\n  total: z.number(),\n  hasMore: z.boolean(),\n});\nexport type MastraHistoryResponse = z.infer<typeof MastraHistoryResponseSchema>;\n\n/**\n * JSON payload returned by `DELETE ${basePath}/history`. Deletes\n * every persisted message + workflow snapshot tied to the caller's\n * thread, so the next chat turn starts from a clean slate. The\n * session cookie that anchors the thread id is preserved so the\n * caller doesn't lose its identity - only the contents go away.\n *\n * `ok` is always `true` on success; the response object is kept\n * as a struct (vs a bare 204) so future fields (e.g. `deletedAt`,\n * `messages`) can be added without bumping the contract.\n *\n * Fields:\n *   - `ok`: literal `true` on success.\n *   - `agentId`: agent whose history was cleared.\n *   - `threadId`: thread id that was wiped.\n *   - `cleared`: number of messages the thread held before\n *     deletion. Useful for client-side \"cleared 12 messages\"\n *     toasts; `0` is reported when the thread was already empty\n *     (call is idempotent).\n */\nexport const MastraClearHistoryResponseSchema = z.object({\n  ok: z.literal(true),\n  agentId: z.string(),\n  threadId: z.string(),\n  cleared: z.number(),\n});\nexport type MastraClearHistoryResponse = z.infer<typeof MastraClearHistoryResponseSchema>;\n\n/* -------------------------------- threads -------------------------------- */\n\n/**\n * A single conversation thread the resource (authenticated user) owns,\n * as returned by `GET ${basePath}/threads`. Mirrors Mastra's\n * `StorageThreadType` but with JSON-safe ISO-8601 timestamps (the wire\n * can't carry `Date`).\n *\n * Fields:\n *   - `id`: thread id. Pass it back as the thread-selection header\n *     (`THREAD_ID_HEADER`) on a stream / history / delete call to act\n *     on this conversation.\n *   - `title`: human-readable title. Present once the agent's memory\n *     has auto-generated one (after the first turn); absent on a\n *     brand-new thread, so the UI falls back to a placeholder.\n *   - `resourceId`: owning resource (the user id). Always the caller's\n *     own resource - the list route filters by it server-side.\n *   - `createdAt` / `updatedAt`: ISO-8601 timestamps. `updatedAt` is\n *     the natural sort key for \"most recent conversations first\".\n *   - `metadata`: opaque thread metadata, passed through untouched.\n */\nexport const MastraThreadSchema = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  resourceId: z.string(),\n  createdAt: z.string(),\n  updatedAt: z.string(),\n  metadata: z.unknown().optional(),\n});\nexport type MastraThread = z.infer<typeof MastraThreadSchema>;\n\n/**\n * JSON payload returned by `GET ${basePath}/threads`. One page of the\n * caller's conversation threads, newest (`updatedAt` DESC) first.\n *\n * Fields:\n *   - `threads`: page of threads for the caller's resource.\n *   - `page`: zero-indexed page that produced this response.\n *   - `perPage`: number of items requested per page.\n *   - `total`: total number of threads the resource owns.\n *   - `hasMore`: true when at least one more page is available.\n */\nexport const MastraThreadsResponseSchema = z.object({\n  threads: z.array(MastraThreadSchema),\n  page: z.number(),\n  perPage: z.number(),\n  total: z.number(),\n  hasMore: z.boolean(),\n});\nexport type MastraThreadsResponse = z.infer<typeof MastraThreadsResponseSchema>;\n\n/**\n * JSON payload returned by `DELETE ${basePath}/threads` (thread id\n * supplied via the thread-selection header / `threadId` query). Wipes\n * the named thread and every message on it.\n *\n * Fields:\n *   - `ok`: literal `true` on success.\n *   - `agentId`: agent whose thread was deleted.\n *   - `threadId`: thread id that was removed.\n *   - `deleted`: `true` when a thread row existed and was removed,\n *     `false` when it was already gone (call is idempotent).\n */\nexport const MastraDeleteThreadResponseSchema = z.object({\n  ok: z.literal(true),\n  agentId: z.string(),\n  threadId: z.string(),\n  deleted: z.boolean(),\n});\nexport type MastraDeleteThreadResponse = z.infer<typeof MastraDeleteThreadResponseSchema>;\n\n/** Longest thread title the rename route accepts (trimmed server-side). */\nexport const MASTRA_THREAD_TITLE_MAX = 200;\n\n/**\n * JSON body for `PATCH ${basePath}/threads` (thread id supplied via the\n * thread-selection header / `threadId` query). Renames a single\n * conversation.\n *\n * Fields:\n *   - `title`: the new human-readable title. Trimmed and capped at\n *     {@link MASTRA_THREAD_TITLE_MAX} characters server-side; must be\n *     non-empty after trimming.\n */\nexport const MastraUpdateThreadRequestSchema = z.object({\n  title: z.string().trim().min(1).max(MASTRA_THREAD_TITLE_MAX),\n});\nexport type MastraUpdateThreadRequest = z.infer<typeof MastraUpdateThreadRequestSchema>;\n\n/**\n * JSON payload returned by `PATCH ${basePath}/threads`. Echoes the\n * renamed thread in its post-update wire shape so the client can reflect\n * the new title without a re-fetch.\n *\n * Fields:\n *   - `ok`: literal `true` on success.\n *   - `agentId`: agent whose thread was renamed.\n *   - `thread`: the updated thread (carries the new `title`).\n */\nexport const MastraUpdateThreadResponseSchema = z.object({\n  ok: z.literal(true),\n  agentId: z.string(),\n  thread: MastraThreadSchema,\n});\nexport type MastraUpdateThreadResponse = z.infer<typeof MastraUpdateThreadResponseSchema>;\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});\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(\"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(\"scatter\")\n      .describe(\"two-numeric-axis correlations between fields (e.g. price vs. quantity)\"),\n    z.literal(\"pie\").describe(\"parts-of-a-whole when 2-7 categories sum to a meaningful total\"),\n  ])\n  .describe(\"The chart shape that best matches the data and intent.\");\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});\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});\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});\nexport type StatementData = z.infer<typeof StatementDataSchema>;\n\n/* ----------------------------- writer surface ---------------------------- */\n\n/**\n * The `ToolStream`-shaped writer the Mastra Genie agent and chart\n * helpers publish events through. Defined here (vs imported from\n * `@mastra/core`) so helpers in `@dbx-tools/appkit-mastra` can\n * accept any object with a `.write` method without dragging\n * Mastra's full `ToolStream` (and its agent / tool typings) into\n * call sites. The actual Mastra `ctx.writer` is assignable to\n * this shape so callers pass it straight through.\n *\n * Kept as a plain TypeScript interface (vs a zod schema) because\n * the contract is a method - zod can only validate the shape via\n * `z.custom`, which adds noise without buying any runtime check.\n */\nexport interface MastraWriter {\n  write: (chunk: unknown) => unknown;\n}\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});\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});\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});\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});\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]);\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]);\nexport type GenieWriterEvent = z.infer<typeof GenieWriterEventSchema>;\n\n/** Discriminator type for {@link GenieWriterEvent}. */\nexport type GenieWriterEventType = GenieWriterEvent[\"type\"];\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});\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});\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});\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]);\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});\nexport type GenieAgentResult = z.infer<typeof GenieAgentResultSchema>;\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +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"}