@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/serving-sanitize.js

@@ -0,0 +1,228 @@
+/**
+ * Repairs traffic between Mastra / the AI SDK and Databricks Model Serving's
+ * OpenAI-compatible `/chat/completions` route, in both directions.
+ *
+ * Outbound ({@link rewriteServingBody}), because the transcript Mastra
+ * persists is not always a transcript the provider will accept back:
+ * Databricks-hosted Claude rejects replayed extended-thinking blocks and reads
+ * a trailing assistant message as a prefill request.
+ *
+ * Inbound ({@link rewriteServingResponseBody}), because Databricks-hosted
+ * Gemini answers with its native content-parts array where the OpenAI contract
+ * (and therefore the AI SDK's response schema) requires a plain string.
+ *
+ * Every repair here is a provider quirk rather than a schema violation, so all
+ * of them are applied on the wire (see the `globalThis.fetch` wrapper in
+ * `model.ts`) rather than by changing what the agent stores or what the UI
+ * shows.
+ *
+ * @module
+ */
+import { json, string } from "@dbx-tools/shared-core";
+import { openaiChat, openaiResponses, } from "@dbx-tools/shared-model";
+// Shared with the Responses sanitize path so both wire surfaces agree on what
+// counts as a signed reasoning block.
+const REASONING_PART_TYPES = openaiResponses.REASONING_TYPES;
+/**
+ * Parse, sanitize, and re-serialize a `/serving-endpoints/...` POST
+ * body. Returns the original string verbatim when the body is not
+ * JSON or no rewrite was needed.
+ */
+export function rewriteServingBody(body) {
+    const parsed = json.parseRecord(body);
+    if (!parsed)
+        return body;
+    // Runs regardless of `messages`: Databricks refuses to parse a body carrying
+    // an unknown top-level field, so this failure is not specific to a transcript.
+    let changed = openaiChat.stripUnsupportedChatFields(parsed).length > 0;
+    if (Array.isArray(parsed.messages)) {
+        const messages = parsed.messages;
+        // Evaluated eagerly, not short-circuited: one transcript can need both
+        // reasoning blocks stripped AND a trailing assistant prefill folded back.
+        const stripped = stripReasoningFromServingMessages(messages);
+        const repaired = repairAssistantPrefill(messages);
+        changed = changed || stripped || repaired;
+    }
+    return changed ? JSON.stringify(parsed) : body;
+}
+/**
+ * Drop extended-thinking / reasoning blocks from a replayed transcript.
+ *
+ * Hybrid Claude endpoints (e.g. Sonnet 4.5+) may emit `reasoning` content
+ * parts on the first turn. Mastra persists and replays them on the next
+ * agent step, but Databricks-hosted Claude rejects those blocks on
+ * multi-turn tool continuations. The UI already captured reasoning for
+ * display; stripping here keeps provider replay compatible without
+ * changing what users see in the chat bubble.
+ */
+export function stripReasoningFromServingMessages(messages) {
+    let changed = false;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        if (msg.role === "reasoning") {
+            messages.splice(i, 1);
+            changed = true;
+            continue;
+        }
+        if (msg.reasoning !== undefined) {
+            delete msg.reasoning;
+            changed = true;
+        }
+        if (msg.reasoning_content !== undefined) {
+            delete msg.reasoning_content;
+            changed = true;
+        }
+        if (!Array.isArray(msg.content))
+            continue;
+        const filtered = msg.content.filter((part) => {
+            const type = part?.type;
+            if (typeof type === "string" && REASONING_PART_TYPES.has(type)) {
+                changed = true;
+                return false;
+            }
+            return true;
+        });
+        if (filtered.length !== msg.content.length) {
+            msg.content = filtered;
+        }
+        const hasToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+        if (msg.role === "assistant" && !hasToolCalls && isEmptyServingContent(msg.content)) {
+            messages.splice(i, 1);
+            changed = true;
+        }
+    }
+    return changed;
+}
+/**
+ * Repair a Mastra/AI SDK message replay that Databricks-hosted Claude
+ * rejects with `"This model does not support assistant message
+ * prefill. The conversation must end with a user message."`.
+ *
+ * The bug pattern: when an assistant turn streams text *and* a
+ * `tool_call`, the AI SDK persists them as two separate assistant
+ * entries (text-only and tool-call-only). On the next agent step the
+ * tool-call entry is replayed *before* the tool result and the
+ * text entry is replayed *after* it, so the conversation ends with a
+ * trailing assistant text message. Anthropic interprets that as a
+ * prefill request and rejects it on Databricks (the upstream Bedrock
+ * route disallows prefill).
+ *
+ * Fix: when the last message is an assistant text with no `tool_calls`
+ * and the chain immediately before it is `assistant(tool_calls=...)`
+ * followed only by `tool(...)` results, fold the trailing text back
+ * into the `content` of that opening assistant and drop the duplicate.
+ */
+export function repairAssistantPrefill(messages) {
+    if (messages.length < 2)
+        return false;
+    const last = messages[messages.length - 1];
+    if (!last || last.role !== "assistant" || (last.tool_calls && last.tool_calls.length > 0)) {
+        return false;
+    }
+    let i = messages.length - 2;
+    while (i >= 0 && messages[i]?.role === "tool")
+        i--;
+    if (i < 0)
+        return false;
+    const opener = messages[i];
+    if (!opener ||
+        opener.role !== "assistant" ||
+        !opener.tool_calls ||
+        opener.tool_calls.length === 0) {
+        return false;
+    }
+    const merged = [
+        string.trimToNull(textFromServingContent(opener.content)),
+        string.trimToNull(textFromServingContent(last.content)),
+    ]
+        .filter((s) => s !== null)
+        .join("\n\n");
+    opener.content = merged;
+    messages.pop();
+    return true;
+}
+/**
+ * Flatten content to the prose a human would read: text parts only, separated
+ * by blank lines, since the result is spliced into another turn's message body.
+ */
+function textFromServingContent(content) {
+    return openaiChat.chatContentToText(content, { separator: "\n\n", types: ["text"] });
+}
+/**
+ * Whether a turn carries nothing worth replaying. Deliberately stricter than
+ * "has no text": a part of any other type (an image, a cache marker) counts as
+ * content, so a message holding one is kept even though it has no prose.
+ */
+function isEmptyServingContent(content) {
+    if (content === undefined)
+        return true;
+    if (typeof content === "string")
+        return content.trim().length === 0;
+    if (!Array.isArray(content))
+        return true;
+    return content.every((part) => {
+        if (part?.type === "text") {
+            return typeof part.text !== "string" || part.text.trim().length === 0;
+        }
+        return false;
+    });
+}
+/**
+ * Parse, sanitize, and re-serialize a `/serving-endpoints/...` non-streaming
+ * JSON RESPONSE body. Returns the original string verbatim when the body is
+ * not JSON or no rewrite was needed, mirroring
+ * {@link rewriteServingBody} on the request side.
+ */
+export function rewriteServingResponseBody(body) {
+    const parsed = json.parseRecord(body);
+    if (!parsed)
+        return body;
+    return flattenChoiceMessageContent(parsed) ? JSON.stringify(parsed) : body;
+}
+/**
+ * Collapse a structured `choices[].message.content` array to the plain string
+ * the OpenAI Chat Completions contract specifies.
+ *
+ * Databricks-hosted Gemini answers a non-streaming `/chat/completions` call
+ * with the Gemini-native parts shape:
+ *
+ * ```json
+ * "content": [{ "type": "text", "text": "...", "thoughtSignature": "..." }]
+ * ```
+ *
+ * `@ai-sdk/openai-compatible` validates the response against the OpenAI
+ * schema, where `content` is a nullable string, so it throws
+ * `Type validation failed: ... expected string, received array` and the whole
+ * call fails (`AI_APICallError: Invalid JSON response` on an HTTP 200). Mastra
+ * uses `doGenerate` for its side calls, so the visible symptom is
+ * `Error generating title` - every thread keeps its placeholder name.
+ *
+ * Flattening on the wire keeps the repair in one place: the streaming path is
+ * unaffected (deltas already carry string content), and neither the agent's
+ * stored transcript nor the UI has to know the provider emitted parts. Any
+ * non-text part (a `thoughtSignature`-only entry, an inline image) contributes
+ * nothing, matching {@link openaiChat.chatContentToText}, and an all-parts-empty
+ * message flattens to `""` rather than being dropped, so `finish_reason` and
+ * `usage` still round-trip.
+ */
+export function flattenChoiceMessageContent(payload) {
+    if (!Array.isArray(payload.choices))
+        return false;
+    let changed = false;
+    for (const choice of payload.choices) {
+        if (!choice || typeof choice !== "object")
+            continue;
+        const message = choice.message;
+        if (!message || typeof message !== "object")
+            continue;
+        const target = message;
+        if (!Array.isArray(target.content))
+            continue;
+        target.content = openaiChat.chatContentToText(target.content, { types: ["text"] });
+        changed = true;
+    }
+    return changed;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serving-sanitize.js","sourceRoot":"","sources":["../../src/serving-sanitize.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repairs traffic between Mastra / the AI SDK and Databricks Model Serving's\n * OpenAI-compatible `/chat/completions` route, in both directions.\n *\n * Outbound ({@link rewriteServingBody}), because the transcript Mastra\n * persists is not always a transcript the provider will accept back:\n * Databricks-hosted Claude rejects replayed extended-thinking blocks and reads\n * a trailing assistant message as a prefill request.\n *\n * Inbound ({@link rewriteServingResponseBody}), because Databricks-hosted\n * Gemini answers with its native content-parts array where the OpenAI contract\n * (and therefore the AI SDK's response schema) requires a plain string.\n *\n * Every repair here is a provider quirk rather than a schema violation, so all\n * of them are applied on the wire (see the `globalThis.fetch` wrapper in\n * `model.ts`) rather than by changing what the agent stores or what the UI\n * shows.\n *\n * @module\n */\n\nimport { json, string } from \"@dbx-tools/shared-core\";\nimport {\n  type ChatMessage,\n  type ChatRole,\n  openaiChat,\n  openaiResponses,\n} from \"@dbx-tools/shared-model\";\n\n/**\n * A chat message as it arrives on the serving wire, plus the extended-thinking\n * fields Databricks-hosted Claude adds. The OpenAI-standard part of the shape\n * is {@link ChatMessage} from `@dbx-tools/shared-model`; only the provider\n * extensions this module strips are declared here.\n */\nexport interface ServingChatMessage extends ChatMessage {\n  /** Narrowed to the roles this repair pass reasons about, plus Claude's `reasoning` turn. */\n  role: ChatRole | \"reasoning\";\n  reasoning?: unknown;\n  reasoning_content?: unknown;\n}\n\n// Shared with the Responses sanitize path so both wire surfaces agree on what\n// counts as a signed reasoning block.\nconst REASONING_PART_TYPES = openaiResponses.REASONING_TYPES;\n\n/**\n * Parse, sanitize, and re-serialize a `/serving-endpoints/...` POST\n * body. Returns the original string verbatim when the body is not\n * JSON or no rewrite was needed.\n */\nexport function rewriteServingBody(body: string): string {\n  const parsed = json.parseRecord(body);\n  if (!parsed) return body;\n\n  // Runs regardless of `messages`: Databricks refuses to parse a body carrying\n  // an unknown top-level field, so this failure is not specific to a transcript.\n  let changed = openaiChat.stripUnsupportedChatFields(parsed).length > 0;\n\n  if (Array.isArray(parsed.messages)) {\n    const messages = parsed.messages as ServingChatMessage[];\n    // Evaluated eagerly, not short-circuited: one transcript can need both\n    // reasoning blocks stripped AND a trailing assistant prefill folded back.\n    const stripped = stripReasoningFromServingMessages(messages);\n    const repaired = repairAssistantPrefill(messages);\n    changed = changed || stripped || repaired;\n  }\n\n  return changed ? JSON.stringify(parsed) : body;\n}\n\n/**\n * Drop extended-thinking / reasoning blocks from a replayed transcript.\n *\n * Hybrid Claude endpoints (e.g. Sonnet 4.5+) may emit `reasoning` content\n * parts on the first turn. Mastra persists and replays them on the next\n * agent step, but Databricks-hosted Claude rejects those blocks on\n * multi-turn tool continuations. The UI already captured reasoning for\n * display; stripping here keeps provider replay compatible without\n * changing what users see in the chat bubble.\n */\nexport function stripReasoningFromServingMessages(messages: ServingChatMessage[]): boolean {\n  let changed = false;\n  for (let i = messages.length - 1; i >= 0; i--) {\n    const msg = messages[i];\n    if (!msg) continue;\n    if (msg.role === \"reasoning\") {\n      messages.splice(i, 1);\n      changed = true;\n      continue;\n    }\n    if (msg.reasoning !== undefined) {\n      delete msg.reasoning;\n      changed = true;\n    }\n    if (msg.reasoning_content !== undefined) {\n      delete msg.reasoning_content;\n      changed = true;\n    }\n    if (!Array.isArray(msg.content)) continue;\n    const filtered = msg.content.filter((part) => {\n      const type = part?.type;\n      if (typeof type === \"string\" && REASONING_PART_TYPES.has(type)) {\n        changed = true;\n        return false;\n      }\n      return true;\n    });\n    if (filtered.length !== msg.content.length) {\n      msg.content = filtered;\n    }\n    const hasToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;\n    if (msg.role === \"assistant\" && !hasToolCalls && isEmptyServingContent(msg.content)) {\n      messages.splice(i, 1);\n      changed = true;\n    }\n  }\n  return changed;\n}\n\n/**\n * Repair a Mastra/AI SDK message replay that Databricks-hosted Claude\n * rejects with `\"This model does not support assistant message\n * prefill. The conversation must end with a user message.\"`.\n *\n * The bug pattern: when an assistant turn streams text *and* a\n * `tool_call`, the AI SDK persists them as two separate assistant\n * entries (text-only and tool-call-only). On the next agent step the\n * tool-call entry is replayed *before* the tool result and the\n * text entry is replayed *after* it, so the conversation ends with a\n * trailing assistant text message. Anthropic interprets that as a\n * prefill request and rejects it on Databricks (the upstream Bedrock\n * route disallows prefill).\n *\n * Fix: when the last message is an assistant text with no `tool_calls`\n * and the chain immediately before it is `assistant(tool_calls=...)`\n * followed only by `tool(...)` results, fold the trailing text back\n * into the `content` of that opening assistant and drop the duplicate.\n */\nexport function repairAssistantPrefill(messages: ServingChatMessage[]): boolean {\n  if (messages.length < 2) return false;\n  const last = messages[messages.length - 1];\n  if (!last || last.role !== \"assistant\" || (last.tool_calls && last.tool_calls.length > 0)) {\n    return false;\n  }\n\n  let i = messages.length - 2;\n  while (i >= 0 && messages[i]?.role === \"tool\") i--;\n  if (i < 0) return false;\n  const opener = messages[i];\n  if (\n    !opener ||\n    opener.role !== \"assistant\" ||\n    !opener.tool_calls ||\n    opener.tool_calls.length === 0\n  ) {\n    return false;\n  }\n\n  const merged = [\n    string.trimToNull(textFromServingContent(opener.content)),\n    string.trimToNull(textFromServingContent(last.content)),\n  ]\n    .filter((s): s is string => s !== null)\n    .join(\"\\n\\n\");\n  opener.content = merged;\n  messages.pop();\n  return true;\n}\n\n/**\n * Flatten content to the prose a human would read: text parts only, separated\n * by blank lines, since the result is spliced into another turn's message body.\n */\nfunction textFromServingContent(content: ServingChatMessage[\"content\"]): string {\n  return openaiChat.chatContentToText(content, { separator: \"\\n\\n\", types: [\"text\"] });\n}\n\n/**\n * Whether a turn carries nothing worth replaying. Deliberately stricter than\n * \"has no text\": a part of any other type (an image, a cache marker) counts as\n * content, so a message holding one is kept even though it has no prose.\n */\nfunction isEmptyServingContent(content: ServingChatMessage[\"content\"]): boolean {\n  if (content === undefined) return true;\n  if (typeof content === \"string\") return content.trim().length === 0;\n  if (!Array.isArray(content)) return true;\n  return content.every((part) => {\n    if (part?.type === \"text\") {\n      return typeof part.text !== \"string\" || part.text.trim().length === 0;\n    }\n    return false;\n  });\n}\n\n/**\n * Parse, sanitize, and re-serialize a `/serving-endpoints/...` non-streaming\n * JSON RESPONSE body. Returns the original string verbatim when the body is\n * not JSON or no rewrite was needed, mirroring\n * {@link rewriteServingBody} on the request side.\n */\nexport function rewriteServingResponseBody(body: string): string {\n  const parsed = json.parseRecord(body);\n  if (!parsed) return body;\n  return flattenChoiceMessageContent(parsed) ? JSON.stringify(parsed) : body;\n}\n\n/**\n * Collapse a structured `choices[].message.content` array to the plain string\n * the OpenAI Chat Completions contract specifies.\n *\n * Databricks-hosted Gemini answers a non-streaming `/chat/completions` call\n * with the Gemini-native parts shape:\n *\n * ```json\n * \"content\": [{ \"type\": \"text\", \"text\": \"...\", \"thoughtSignature\": \"...\" }]\n * ```\n *\n * `@ai-sdk/openai-compatible` validates the response against the OpenAI\n * schema, where `content` is a nullable string, so it throws\n * `Type validation failed: ... expected string, received array` and the whole\n * call fails (`AI_APICallError: Invalid JSON response` on an HTTP 200). Mastra\n * uses `doGenerate` for its side calls, so the visible symptom is\n * `Error generating title` - every thread keeps its placeholder name.\n *\n * Flattening on the wire keeps the repair in one place: the streaming path is\n * unaffected (deltas already carry string content), and neither the agent's\n * stored transcript nor the UI has to know the provider emitted parts. Any\n * non-text part (a `thoughtSignature`-only entry, an inline image) contributes\n * nothing, matching {@link openaiChat.chatContentToText}, and an all-parts-empty\n * message flattens to `\"\"` rather than being dropped, so `finish_reason` and\n * `usage` still round-trip.\n */\nexport function flattenChoiceMessageContent(payload: Record<string, unknown>): boolean {\n  if (!Array.isArray(payload.choices)) return false;\n  let changed = false;\n  for (const choice of payload.choices) {\n    if (!choice || typeof choice !== \"object\") continue;\n    const message = (choice as { message?: unknown }).message;\n    if (!message || typeof message !== \"object\") continue;\n    const target = message as { content?: unknown };\n    if (!Array.isArray(target.content)) continue;\n    target.content = openaiChat.chatContentToText(target.content, { types: [\"text\"] });\n    changed = true;\n  }\n  return changed;\n}\n"]}

package/lib/src/serving.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Mastra-specific glue over the generic `@dbx-tools/model` toolkit.
+ *
+ * The live `/serving-endpoints` catalogue access, fuzzy name
+ * resolution, and class/fallback selection all live in
+ * `@dbx-tools/model`; this module only adds what is specific to the
+ * Mastra plugin: pulling a per-request model override off an HTTP
+ * request (header / query / body) and projecting the plugin config
+ * onto the knobs `buildModel` and the `/models` route share.
+ *
+ * @module
+ */
+import type { MastraPluginConfig } from "./config.js";
+/**
+ * `RequestContext` key under which {@link MastraServer} stores the
+ * per-request model override (header / query / body). `model.ts`
+ * reads it before falling back to the agent / plugin default.
+ */
+export declare const MASTRA_MODEL_OVERRIDE_KEY = "mastra__model_override";
+/**
+ * Minimal Express-ish request shape used by {@link extractModelOverride}.
+ * Keeps this module independent of `express` so the helper can be
+ * reused from non-Express adapters.
+ */
+export interface ModelOverrideRequest {
+    headers?: Record<string, string | string[] | undefined>;
+    query?: Record<string, unknown> | undefined;
+    body?: unknown;
+}
+/**
+ * Pull a model override out of a single HTTP request, checking
+ * sources in priority order:
+ *
+ *   1. `X-Mastra-Model` header
+ *   2. `?model=` query string parameter
+ *   3. Body field (`model` or `modelId`, in that order)
+ *
+ * Returns `null` when nothing is set, so callers can wrap with
+ * `if (override) ...` without juggling empty strings. Body inspection
+ * is lenient - any plain object with one of the configured keys
+ * counts, mirroring how AI SDK chat clients pass arbitrary metadata
+ * alongside `messages`.
+ */
+export declare function extractModelOverride(req: ModelOverrideRequest): string | null;
+/**
+ * Read the fuzzy-resolution config knobs off the plugin config with
+ * `@dbx-tools/model` defaults applied. Kept here so `buildModel` and
+ * the `/models` route agree on what "enabled" means.
+ *
+ * `fallbacks` is the priority-ordered list `resolveModel` walks first
+ * when nothing explicit is set; defaults to an empty list so the
+ * generic resolver falls through to the live catalogue and its own
+ * `FALLBACK_MODEL_IDS` floor.
+ */
+export declare function resolveServingConfig(config: MastraPluginConfig): {
+    ttlMs: number;
+    threshold: number;
+    fuzzy: boolean;
+    allowOverride: boolean;
+    fallbacks: readonly string[];
+};

package/lib/src/serving.js

@@ -0,0 +1,78 @@
+/**
+ * Mastra-specific glue over the generic `@dbx-tools/model` toolkit.
+ *
+ * The live `/serving-endpoints` catalogue access, fuzzy name
+ * resolution, and class/fallback selection all live in
+ * `@dbx-tools/model`; this module only adds what is specific to the
+ * Mastra plugin: pulling a per-request model override off an HTTP
+ * request (header / query / body) and projecting the plugin config
+ * onto the knobs `buildModel` and the `/models` route share.
+ *
+ * @module
+ */
+import { serving as nodeServing } from "@dbx-tools/model";
+import { string } from "@dbx-tools/shared-core";
+import { override } from "@dbx-tools/shared-mastra";
+/**
+ * `RequestContext` key under which {@link MastraServer} stores the
+ * per-request model override (header / query / body). `model.ts`
+ * reads it before falling back to the agent / plugin default.
+ */
+export const MASTRA_MODEL_OVERRIDE_KEY = "mastra__model_override";
+/**
+ * Pull a model override out of a single HTTP request, checking
+ * sources in priority order:
+ *
+ *   1. `X-Mastra-Model` header
+ *   2. `?model=` query string parameter
+ *   3. Body field (`model` or `modelId`, in that order)
+ *
+ * Returns `null` when nothing is set, so callers can wrap with
+ * `if (override) ...` without juggling empty strings. Body inspection
+ * is lenient - any plain object with one of the configured keys
+ * counts, mirroring how AI SDK chat clients pass arbitrary metadata
+ * alongside `messages`.
+ */
+export function extractModelOverride(req) {
+    const headers = req.headers;
+    if (headers) {
+        const headerVal = string.firstNonEmpty(headers[override.MODEL_OVERRIDE_HEADER] ??
+            headers[override.MODEL_OVERRIDE_HEADER.toLowerCase()]);
+        if (headerVal)
+            return headerVal;
+    }
+    if (req.query) {
+        const queryVal = string.firstNonEmpty(req.query[override.MODEL_OVERRIDE_QUERY]);
+        if (queryVal)
+            return queryVal;
+    }
+    if (req.body && typeof req.body === "object") {
+        const record = req.body;
+        for (const field of override.MODEL_OVERRIDE_BODY_FIELDS) {
+            const bodyVal = string.firstNonEmpty(record[field]);
+            if (bodyVal)
+                return bodyVal;
+        }
+    }
+    return null;
+}
+/**
+ * Read the fuzzy-resolution config knobs off the plugin config with
+ * `@dbx-tools/model` defaults applied. Kept here so `buildModel` and
+ * the `/models` route agree on what "enabled" means.
+ *
+ * `fallbacks` is the priority-ordered list `resolveModel` walks first
+ * when nothing explicit is set; defaults to an empty list so the
+ * generic resolver falls through to the live catalogue and its own
+ * `FALLBACK_MODEL_IDS` floor.
+ */
+export function resolveServingConfig(config) {
+    return {
+        ttlMs: config.modelCacheTtlMs ?? nodeServing.DEFAULT_MODEL_CACHE_TTL_MS,
+        threshold: config.modelFuzzyThreshold ?? nodeServing.DEFAULT_FUZZY_THRESHOLD,
+        fuzzy: config.modelFuzzyMatch !== false,
+        allowOverride: config.modelOverride !== false,
+        fallbacks: config.defaultModelFallbacks ?? [],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/statement.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Databricks Statement Execution helpers for the Mastra plugin.
+ *
+ * Wraps `client.statementExecution.getStatement` with the shape and
+ * size handling the plugin's tools and the `/embed/data/:id` route
+ * both need: a low-level fetch that returns a raw
+ * `{columns, rows, rowCount}` shape and coerces numeric strings to
+ * numbers so downstream charts and aggregations don't have to, plus a
+ * hard row cap callers clamp `limit` to so a runaway result set can't
+ * hose a response. Upstream 404s are detected via
+ * `error.errorContext(err).notFound` at the call sites.
+ *
+ * Not Genie-specific: a Databricks `statement_id` is workspace
+ * scoped and lives in the Statement Execution API regardless of
+ * which producer (Genie, a tool, a notebook, etc.) submitted the
+ * query. Co-located here so consumers can fetch / cap / handle
+ * 404s without reaching into the Genie tool module.
+ *
+ * @module
+ */
+import { WorkspaceClient } from "@databricks/sdk-experimental";
+import type { GenieDatasetData } from "@dbx-tools/shared-mastra";
+/**
+ * Hard server-side cap on rows returned by the
+ * `/embed/data/:id` route. Sized to keep responses small
+ * enough for inline tables to render snappily; the route surfaces
+ * a `truncated` flag whenever the upstream `rowCount` exceeds
+ * this so end users know they're seeing a sample.
+ */
+export declare const STATEMENT_ROW_CAP = 500;
+/**
+ * Fetch a single statement's rows via the Statement Execution API
+ * and reshape into the shared {@link GenieDatasetData} shape
+ * (column array + row records).
+ *
+ * Optional `limit` slices the returned `rows` client-side so the
+ * agent can scan a small sample without paging the full result
+ * set into context. `rowCount` always reflects the upstream total
+ * so callers know when the slice truncated.
+ *
+ * Exported because every consumer in the plugin (the
+ * `get_statement` tool, the `prepare_chart` dataset resolver, and
+ * the `/embed/data/:id` route) needs the exact same
+ * fetch + coercion pipeline so LLM-side `get_statement` output
+ * and UI-side `[data:<id>]` rendering stay shape-identical for
+ * the same `statement_id`.
+ */
+export declare function fetchStatementData(client: WorkspaceClient, statementId: string, options?: {
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<GenieDatasetData>;

package/lib/src/statement.js

@@ -0,0 +1,83 @@
+/**
+ * Databricks Statement Execution helpers for the Mastra plugin.
+ *
+ * Wraps `client.statementExecution.getStatement` with the shape and
+ * size handling the plugin's tools and the `/embed/data/:id` route
+ * both need: a low-level fetch that returns a raw
+ * `{columns, rows, rowCount}` shape and coerces numeric strings to
+ * numbers so downstream charts and aggregations don't have to, plus a
+ * hard row cap callers clamp `limit` to so a runaway result set can't
+ * hose a response. Upstream 404s are detected via
+ * `error.errorContext(err).notFound` at the call sites.
+ *
+ * Not Genie-specific: a Databricks `statement_id` is workspace
+ * scoped and lives in the Statement Execution API regardless of
+ * which producer (Genie, a tool, a notebook, etc.) submitted the
+ * query. Co-located here so consumers can fetch / cap / handle
+ * 404s without reaching into the Genie tool module.
+ *
+ * @module
+ */
+import { databricks } from "@dbx-tools/appkit";
+/**
+ * Hard server-side cap on rows returned by the
+ * `/embed/data/:id` route. Sized to keep responses small
+ * enough for inline tables to render snappily; the route surfaces
+ * a `truncated` flag whenever the upstream `rowCount` exceeds
+ * this so end users know they're seeing a sample.
+ */
+export const STATEMENT_ROW_CAP = 500;
+/**
+ * Best-effort numeric coercion for the Statement Execution API's
+ * all-strings cells. Leaves non-numeric strings (and explicit
+ * `null`s) intact; everything else flows through `Number`.
+ */
+function coerceCell(cell) {
+    if (cell === null)
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(cell)) {
+        const n = Number(cell);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return cell;
+}
+/**
+ * Fetch a single statement's rows via the Statement Execution API
+ * and reshape into the shared {@link GenieDatasetData} shape
+ * (column array + row records).
+ *
+ * Optional `limit` slices the returned `rows` client-side so the
+ * agent can scan a small sample without paging the full result
+ * set into context. `rowCount` always reflects the upstream total
+ * so callers know when the slice truncated.
+ *
+ * Exported because every consumer in the plugin (the
+ * `get_statement` tool, the `prepare_chart` dataset resolver, and
+ * the `/embed/data/:id` route) needs the exact same
+ * fetch + coercion pipeline so LLM-side `get_statement` output
+ * and UI-side `[data:<id>]` rendering stay shape-identical for
+ * the same `statement_id`.
+ */
+export async function fetchStatementData(client, statementId, options) {
+    const ctx = options?.signal ? databricks.toContext(options.signal) : undefined;
+    const r = await client.statementExecution.getStatement({ statement_id: statementId }, ctx);
+    const columns = (r.manifest?.schema?.columns ?? []).map((c) => c.name ?? "");
+    const dataArray = (r.result?.data_array ?? []);
+    const sliced = options?.limit !== undefined && options.limit >= 0
+        ? dataArray.slice(0, options.limit)
+        : dataArray;
+    const rows = sliced.map((row) => {
+        const obj = {};
+        columns.forEach((col, i) => {
+            obj[col] = coerceCell(row[i] ?? null);
+        });
+        return obj;
+    });
+    return {
+        columns,
+        rows,
+        rowCount: r.manifest?.total_row_count ?? dataArray.length,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/storage-schema.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Derive a Postgres-safe schema name for per-agent Mastra storage.
+ *
+ * Agent ids are often kebab-case route segments (`data-mesh-book-assistant`)
+ * but {@link PostgresStore} validates `schemaName` with Mastra's
+ * `parseSqlIdentifier` (letter/underscore start, `[A-Za-z0-9_]` only, max 63).
+ *
+ * @module
+ */
+/**
+ * Default Lakebase schema for one agent's thread/message store:
+ * `mastra_<sanitized-agent-id>`.
+ */
+export declare function agentStorageSchemaName(agentId: string): string;

package/lib/src/storage-schema.js

@@ -0,0 +1,34 @@
+/**
+ * Derive a Postgres-safe schema name for per-agent Mastra storage.
+ *
+ * Agent ids are often kebab-case route segments (`data-mesh-book-assistant`)
+ * but {@link PostgresStore} validates `schemaName` with Mastra's
+ * `parseSqlIdentifier` (letter/underscore start, `[A-Za-z0-9_]` only, max 63).
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+const SCHEMA_PREFIX = "mastra_";
+const MAX_PG_IDENTIFIER_LEN = 63;
+/**
+ * Default Lakebase schema for one agent's thread/message store:
+ * `mastra_<sanitized-agent-id>`.
+ */
+export function agentStorageSchemaName(agentId) {
+    const maxSlugLen = MAX_PG_IDENTIFIER_LEN - SCHEMA_PREFIX.length;
+    const slug = string.toIdentifierWithOptions({
+        delimiter: "_",
+        maxLength: maxSlugLen,
+        truncateStrategy: "hash",
+        truncateHashLength: 6,
+    }, agentId);
+    const body = slug ||
+        string.toIdentifierWithOptions({
+            delimiter: "_",
+            maxLength: maxSlugLen,
+            truncateStrategy: "hash",
+            truncateHashLength: 6,
+        }, "agent", agentId);
+    return `${SCHEMA_PREFIX}${body}`;
+}
+//# sourceMappingURL=data:application/json;base64,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