@dbx-tools/appkit-mastra 0.6.213 → 0.6.215

package/lib/src/model.js

@@ -26,7 +26,7 @@ import { getExecutionContext } from "@databricks/appkit";
 import { classes, resolve } from "@dbx-tools/model";
 import { functionModule, json, log, net } from "@dbx-tools/shared-core";
 import { MASTRA_USER_KEY } from "./config.js";
-import { rewriteServingBody, rewriteServingResponseBody } from "./serving-sanitize.js";
+import { rewriteServingBody, rewriteServingResponseBody, rewriteServingResponseStream, } from "./serving-sanitize.js";
 import { MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from "./serving.js";
 const { parseModelClass } = classes;
 const { selectModel } = resolve;
@@ -103,10 +103,9 @@ const SERVING_ENDPOINTS_PATH_PREFIX = "/serving-endpoints/";
  *   2. At `LOG_LEVEL=debug`, dumps the (post-sanitize) JSON body so
  *      4xx debugging doesn't have to fight AI SDK's `[Array]`
  *      formatter.
- *   3. Repairs the non-streaming JSON response, where Databricks-hosted
- *      Gemini returns `choices[].message.content` as a parts array that
- *      the AI SDK's OpenAI schema rejects (see
- *      {@link rewriteServingResponseBody}).
+ *   3. Repairs buffered and streaming responses where a provider returns
+ *      `choices[].message.content` or `choices[].delta.content` as a parts
+ *      array that the AI SDK's OpenAI schema rejects.
  *
  * Safe to call from any hot path: {@link functionModule.memoize} ensures
  * the wrapper is installed at most once per process, so subsequent
@@ -136,33 +135,38 @@ const setupFetchInterceptor = functionModule.memoize(() => {
     });
 });
 /**
- * Rewrite a non-streaming serving response whose body needs repair, leaving
- * everything else byte-identical.
+ * Rewrite a serving response whose body needs repair, leaving unsupported
+ * content types byte-identical.
  *
- * Streaming turns are passed straight through: an SSE body must stay a live
- * stream (buffering it to a string would defeat streaming and break
- * `text/event-stream` parsing), and the delta frames already carry string
- * content, so they never hit the array-shaped `content` bug. Likewise a
- * non-JSON or error body is returned untouched, so the caller still sees the
- * original status and headers.
+ * SSE remains a live stream: a TransformStream repairs complete `data:` lines
+ * as bytes arrive and preserves partial lines across network chunks. JSON is
+ * buffered through the existing response-body repair. A non-JSON/non-SSE body
+ * is returned untouched so the caller still sees the original response.
  */
 async function repairServingResponse(response) {
     const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream") && response.body) {
+        return rebuildServingResponse(response, rewriteServingResponseStream(response.body));
+    }
     if (!contentType.includes("application/json"))
         return response;
     const body = await response.clone().text();
     const rewritten = rewriteServingResponseBody(body);
     if (rewritten === body)
         return response;
+    return rebuildServingResponse(response, rewritten);
+}
+/** Rebuild a transformed response without stale byte-length/encoding headers. */
+function rebuildServingResponse(response, body) {
     // `content-length` / `content-encoding` describe the ORIGINAL bytes, so they
     // are dropped: the rewritten body is a different length and already decoded.
     const headers = new Headers(response.headers);
     headers.delete("content-length");
     headers.delete("content-encoding");
-    return new Response(rewritten, {
+    return new Response(body, {
         status: response.status,
         statusText: response.statusText,
         headers,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAKxE,OAAO,EAAE,eAAe,EAAsC,MAAM,aAAa,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAG/E,MAAM,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;AACpC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;AAqBhC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,MAA0B,EAC1B,cAA8B,EAC9B,YAAiC,EAAE;IAEnC,KAAK,qBAAqB,EAAE,CAAC;IAC7B,kEAAkE;IAClE,qEAAqE;IACrE,qEAAqE;IACrE,qEAAqE;IACrE,MAAM,IAAI,GAAG,cAAc,CAAC,GAAG,CAAC,eAAe,CAAqB,CAAC;IACrE,MAAM,gBAAgB,GAAG,IAAI,EAAE,gBAAgB,IAAI,mBAAmB,EAAE,CAAC;IACzE,MAAM,YAAY,GAAG,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;IACpD,MAAM,IAAI,GAAG,CAAC,MAAM,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;IACvD,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAC9B,MAAM,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACzC,yEAAyE;IACzE,qEAAqE;IACrE,uDAAuD;IACvD,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAE9E,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,OAAO,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,aAAa;QACpC,CAAC,CAAE,cAAc,CAAC,GAAG,CAAC,yBAAyB,CAAwB;QACvE,CAAC,CAAC,SAAS,CAAC;IAEd,oEAAoE;IACpE,yDAAyD;IACzD,sEAAsE;IACtE,sEAAsE;IACtE,mEAAmE;IACnE,kEAAkE;IAClE,oCAAoC;IACpC,MAAM,SAAS,GAAG,QAAQ,IAAI,SAAS,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC;IAChG,MAAM,cAAc,GAAG,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACnF,MAAM,QAAQ,GAAG,cAAc,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,MAAM,UAAU,GAAG,cAAc,IAAI,SAAS,CAAC,UAAU,CAAC;IAE1D,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,WAAW,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,EAAE;QAC3E,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/C,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACnD,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,KAAK,EAAE,OAAO,CAAC,KAAK;KACrB,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,gBAAgB,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAE/D,OAAO;QACL,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,YAAY;QAC7C,OAAO;QACP,GAAG;QACH,OAAO,EAAE,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;KAC/C,CAAC;AACJ,CAAC;AAED,wEAAwE;AACxE,MAAM,6BAA6B,GAAG,qBAAqB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,qBAAqB,GAAG,cAAc,CAAC,OAAO,CAAC,GAAS,EAAE;IAC9D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACnD,UAAU,CAAC,KAAK,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QACxC,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAClC,IACE,CAAC,GAAG;YACJ,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,6BAA6B,CAAC;YACvD,OAAO,IAAI,EAAE,IAAI,KAAK,QAAQ,EAC9B,CAAC;YACD,OAAO,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC/B,CAAC;QACD,MAAM,SAAS,GAAG,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChD,IAAI,SAAS,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;YAC5B,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QACtC,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAU,SAAS,CAAC,CAAC;QAC9C,MAAM,CAAC,KAAK,CACV,MAAM,EACN,MAAM,KAAK,SAAS;YAClB,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE;YAC/C,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAC1C,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC7C,OAAO,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC,CAA4B,CAAC;AAChC,CAAC,CAAC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,KAAK,UAAU,qBAAqB,CAAC,QAAkB;IACrD,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;IAC/D,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,kBAAkB,CAAC;QAAE,OAAO,QAAQ,CAAC;IAE/D,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;IAC3C,MAAM,SAAS,GAAG,0BAA0B,CAAC,IAAI,CAAC,CAAC;IACnD,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,QAAQ,CAAC;IAExC,6EAA6E;IAC7E,6EAA6E;IAC7E,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;IACjC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;IACnC,OAAO,IAAI,QAAQ,CAAC,SAAS,EAAE;QAC7B,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;QAC/B,OAAO;KACR,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Databricks Model Serving resolver for Mastra agents.\n *\n * Each agent step calls {@link buildModel} with the active\n * `RequestContext`. The user stamped by `MastraServer` carries an\n * AppKit `WorkspaceClient`; we ask it for the workspace host and a\n * fresh bearer header, then point Mastra's OpenAI-compatible provider\n * at `/serving-endpoints` on that host.\n *\n * This module only adds the Mastra-specific glue. The actual model\n * selection - listing the workspace catalogue and resolving an\n * explicit name / class / fallback chain to a real endpoint id - lives\n * in `@dbx-tools/model` ({@link selectModel}) so non-Mastra consumers\n * (e.g. a job that just needs a model name) can reuse it. Here we\n * assemble the explicit ask from Mastra's request context (the\n * per-request override under {@link MASTRA_MODEL_OVERRIDE_KEY}, the\n * agent / plugin `modelId`, or `DATABRICKS_SERVING_ENDPOINT_NAME`),\n * pass the plugin's fuzzy / class / fallback knobs through, and wrap\n * the resolved id in the OpenAI-compatible provider config Mastra\n * expects. Catalogue fetches fail loud: network / auth errors\n * propagate so callers see the real SDK message.\n *\n * @module\n */\n\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { classes, resolve } from \"@dbx-tools/model\";\nimport { functionModule, json, log, net } from \"@dbx-tools/shared-core\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport type { MastraModelConfig } from \"@mastra/core/llm\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\n\nimport { MASTRA_USER_KEY, type MastraPluginConfig, type User } from \"./config.ts\";\nimport { rewriteServingBody, rewriteServingResponseBody } from \"./serving-sanitize.ts\";\nimport { MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from \"./serving.ts\";\n\ntype ModelClass = model.ModelClass;\nconst { parseModelClass } = classes;\nconst { selectModel } = resolve;\n\n/** Optional overrides accepted by {@link buildModel}. */\nexport interface BuildModelOverrides {\n  /**\n   * Static model id from the agent / plugin config (string sugar on\n   * `def.model` or `config.defaultModel`). Loses to the per-request\n   * override but wins over env / class / fallback.\n   */\n  modelId?: string;\n  /**\n   * Chat capability class to resolve when no explicit model id is\n   * supplied. Used by internal agents (e.g. the chart planner asks for\n   * {@link model.ModelClass.ChatFast}) to express intent without pinning an\n   * endpoint name; the live catalogue is classified and the top\n   * available model in the class is chosen, falling back to the\n   * class's static list when the workspace has none.\n   */\n  modelClass?: ModelClass;\n}\n\n/**\n * Resolve a `MastraModelConfig` for the current agent step. Runs\n * while `agent.stream` is inside the `asUser(req)` scope so tokens\n * are user-scoped; outside an active user context the workspace\n * client falls back to the service principal.\n *\n * Endpoint precedence: the per-request override\n * ({@link MASTRA_MODEL_OVERRIDE_KEY}, only when `config.modelOverride` allows\n * it), then {@link BuildModelOverrides.modelId} from the agent / plugin\n * config, then `DATABRICKS_SERVING_ENDPOINT_NAME`. With none of those set the\n * capability class and fallback ladder in `@dbx-tools/model` choose the\n * endpoint.\n */\nexport async function buildModel(\n  config: MastraPluginConfig,\n  requestContext: RequestContext,\n  overrides: BuildModelOverrides = {},\n): Promise<MastraModelConfig> {\n  void setupFetchInterceptor();\n  // The chat path stamps the AppKit user on the request context via\n  // `MastraServer`. The MCP transport routes don't thread that context\n  // into tool execution, so fall back to the ambient execution context\n  // (the active OBO scope, or the service principal) when it's absent.\n  const user = requestContext.get(MASTRA_USER_KEY) as User | undefined;\n  const executionContext = user?.executionContext ?? getExecutionContext();\n  const clientConfig = executionContext.client.config;\n  const host = (await clientConfig.getHost()).toString();\n  const headers = new Headers();\n  await clientConfig.authenticate(headers);\n  // The OpenAI Node SDK appends paths like `/chat/completions` to whatever\n  // URL we hand it. Drop the trailing slash so the resulting URL stays\n  // well-formed (`/serving-endpoints/chat/completions`).\n  const url = new URL(\"/serving-endpoints\", host).toString().replace(/\\/$/, \"\");\n\n  const logger = log.logger(config);\n  const serving = resolveServingConfig(config);\n  const override = serving.allowOverride\n    ? (requestContext.get(MASTRA_MODEL_OVERRIDE_KEY) as string | undefined)\n    : undefined;\n\n  // The override / agent default / env value can be either a concrete\n  // endpoint name or a model class slug (\"chat-thinking\" /\n  // \"chat-balanced\" / \"chat-fast\"). A class slug becomes a class intent\n  // (let the live catalogue pick the best model in that band); anything\n  // else is an explicit name fuzzy-matched against the catalogue. An\n  // internal `overrides.modelClass` (e.g. the chart planner) is the\n  // floor when nothing was requested.\n  const requested = override ?? overrides.modelId ?? process.env.DATABRICKS_SERVING_ENDPOINT_NAME;\n  const requestedClass = requested !== undefined ? parseModelClass(requested) : null;\n  const explicit = requestedClass === null ? requested : undefined;\n  const modelClass = requestedClass ?? overrides.modelClass;\n\n  const { modelId, source } = await selectModel(executionContext.client, host, {\n    ...(explicit !== undefined ? { explicit } : {}),\n    fuzzy: serving.fuzzy,\n    threshold: serving.threshold,\n    ...(modelClass !== undefined ? { modelClass } : {}),\n    fallbacks: serving.fallbacks,\n    ttlMs: serving.ttlMs,\n  });\n  logger.debug(\"model selected\", { modelId, source, requested });\n\n  return {\n    providerId: config.providerId ?? \"databricks\",\n    modelId,\n    url,\n    headers: Object.fromEntries(headers.entries()),\n  };\n}\n\n/** Path prefix that identifies a Databricks Model Serving REST call. */\nconst SERVING_ENDPOINTS_PATH_PREFIX = \"/serving-endpoints/\";\n\n/**\n * Install a single shared `globalThis.fetch` wrapper for every POST to\n * `/serving-endpoints/...`. The wrapper does two things:\n *\n *   1. Rewrites the outgoing `messages` array to repair Mastra/AI SDK\n *      stream-replay quirks that Databricks-hosted Claude rejects (see\n *      {@link rewriteServingBody} in `./serving-sanitize.js`).\n *   2. At `LOG_LEVEL=debug`, dumps the (post-sanitize) JSON body so\n *      4xx debugging doesn't have to fight AI SDK's `[Array]`\n *      formatter.\n *   3. Repairs the non-streaming JSON response, where Databricks-hosted\n *      Gemini returns `choices[].message.content` as a parts array that\n *      the AI SDK's OpenAI schema rejects (see\n *      {@link rewriteServingResponseBody}).\n *\n * Safe to call from any hot path: {@link functionModule.memoize} ensures\n * the wrapper is installed at most once per process, so subsequent\n * calls are a no-op even when {@link buildModel} fires on every agent\n * step.\n */\nconst setupFetchInterceptor = functionModule.memoize((): void => {\n  const logger = log.logger(\"mastra/llm\");\n  const original = globalThis.fetch.bind(globalThis);\n  globalThis.fetch = (async (input, init) => {\n    const url = net.urlBuilder(input);\n    if (\n      !url ||\n      !url.pathname.startsWith(SERVING_ENDPOINTS_PATH_PREFIX) ||\n      typeof init?.body !== \"string\"\n    ) {\n      return original(input, init);\n    }\n    const rewritten = rewriteServingBody(init.body);\n    if (rewritten !== init.body) {\n      init = { ...init, body: rewritten };\n    }\n    const parsed = json.parse<unknown>(rewritten);\n    logger.debug(\n      \"POST\",\n      parsed === undefined\n        ? { url: url.toString(), bodyType: \"non-JSON\" }\n        : { url: url.toString(), body: parsed },\n    );\n    const response = await original(input, init);\n    return repairServingResponse(response);\n  }) as typeof globalThis.fetch;\n});\n\n/**\n * Rewrite a non-streaming serving response whose body needs repair, leaving\n * everything else byte-identical.\n *\n * Streaming turns are passed straight through: an SSE body must stay a live\n * stream (buffering it to a string would defeat streaming and break\n * `text/event-stream` parsing), and the delta frames already carry string\n * content, so they never hit the array-shaped `content` bug. Likewise a\n * non-JSON or error body is returned untouched, so the caller still sees the\n * original status and headers.\n */\nasync function repairServingResponse(response: Response): Promise<Response> {\n  const contentType = response.headers.get(\"content-type\") ?? \"\";\n  if (!contentType.includes(\"application/json\")) return response;\n\n  const body = await response.clone().text();\n  const rewritten = rewriteServingResponseBody(body);\n  if (rewritten === body) return response;\n\n  // `content-length` / `content-encoding` describe the ORIGINAL bytes, so they\n  // are dropped: the rewritten body is a different length and already decoded.\n  const headers = new Headers(response.headers);\n  headers.delete(\"content-length\");\n  headers.delete(\"content-encoding\");\n  return new Response(rewritten, {\n    status: response.status,\n    statusText: response.statusText,\n    headers,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/model.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Databricks Model Serving resolver for Mastra agents.\n *\n * Each agent step calls {@link buildModel} with the active\n * `RequestContext`. The user stamped by `MastraServer` carries an\n * AppKit `WorkspaceClient`; we ask it for the workspace host and a\n * fresh bearer header, then point Mastra's OpenAI-compatible provider\n * at `/serving-endpoints` on that host.\n *\n * This module only adds the Mastra-specific glue. The actual model\n * selection - listing the workspace catalogue and resolving an\n * explicit name / class / fallback chain to a real endpoint id - lives\n * in `@dbx-tools/model` ({@link selectModel}) so non-Mastra consumers\n * (e.g. a job that just needs a model name) can reuse it. Here we\n * assemble the explicit ask from Mastra's request context (the\n * per-request override under {@link MASTRA_MODEL_OVERRIDE_KEY}, the\n * agent / plugin `modelId`, or `DATABRICKS_SERVING_ENDPOINT_NAME`),\n * pass the plugin's fuzzy / class / fallback knobs through, and wrap\n * the resolved id in the OpenAI-compatible provider config Mastra\n * expects. Catalogue fetches fail loud: network / auth errors\n * propagate so callers see the real SDK message.\n *\n * @module\n */\n\nimport { getExecutionContext } from \"@databricks/appkit\";\nimport { classes, resolve } from \"@dbx-tools/model\";\nimport { functionModule, json, log, net } from \"@dbx-tools/shared-core\";\nimport { model } from \"@dbx-tools/shared-model\";\nimport type { MastraModelConfig } from \"@mastra/core/llm\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\n\nimport { MASTRA_USER_KEY, type MastraPluginConfig, type User } from \"./config.ts\";\nimport {\n  rewriteServingBody,\n  rewriteServingResponseBody,\n  rewriteServingResponseStream,\n} from \"./serving-sanitize.ts\";\nimport { MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from \"./serving.ts\";\n\ntype ModelClass = model.ModelClass;\nconst { parseModelClass } = classes;\nconst { selectModel } = resolve;\n\n/** Optional overrides accepted by {@link buildModel}. */\nexport interface BuildModelOverrides {\n  /**\n   * Static model id from the agent / plugin config (string sugar on\n   * `def.model` or `config.defaultModel`). Loses to the per-request\n   * override but wins over env / class / fallback.\n   */\n  modelId?: string;\n  /**\n   * Chat capability class to resolve when no explicit model id is\n   * supplied. Used by internal agents (e.g. the chart planner asks for\n   * {@link model.ModelClass.ChatFast}) to express intent without pinning an\n   * endpoint name; the live catalogue is classified and the top\n   * available model in the class is chosen, falling back to the\n   * class's static list when the workspace has none.\n   */\n  modelClass?: ModelClass;\n}\n\n/**\n * Resolve a `MastraModelConfig` for the current agent step. Runs\n * while `agent.stream` is inside the `asUser(req)` scope so tokens\n * are user-scoped; outside an active user context the workspace\n * client falls back to the service principal.\n *\n * Endpoint precedence: the per-request override\n * ({@link MASTRA_MODEL_OVERRIDE_KEY}, only when `config.modelOverride` allows\n * it), then {@link BuildModelOverrides.modelId} from the agent / plugin\n * config, then `DATABRICKS_SERVING_ENDPOINT_NAME`. With none of those set the\n * capability class and fallback ladder in `@dbx-tools/model` choose the\n * endpoint.\n */\nexport async function buildModel(\n  config: MastraPluginConfig,\n  requestContext: RequestContext,\n  overrides: BuildModelOverrides = {},\n): Promise<MastraModelConfig> {\n  void setupFetchInterceptor();\n  // The chat path stamps the AppKit user on the request context via\n  // `MastraServer`. The MCP transport routes don't thread that context\n  // into tool execution, so fall back to the ambient execution context\n  // (the active OBO scope, or the service principal) when it's absent.\n  const user = requestContext.get(MASTRA_USER_KEY) as User | undefined;\n  const executionContext = user?.executionContext ?? getExecutionContext();\n  const clientConfig = executionContext.client.config;\n  const host = (await clientConfig.getHost()).toString();\n  const headers = new Headers();\n  await clientConfig.authenticate(headers);\n  // The OpenAI Node SDK appends paths like `/chat/completions` to whatever\n  // URL we hand it. Drop the trailing slash so the resulting URL stays\n  // well-formed (`/serving-endpoints/chat/completions`).\n  const url = new URL(\"/serving-endpoints\", host).toString().replace(/\\/$/, \"\");\n\n  const logger = log.logger(config);\n  const serving = resolveServingConfig(config);\n  const override = serving.allowOverride\n    ? (requestContext.get(MASTRA_MODEL_OVERRIDE_KEY) as string | undefined)\n    : undefined;\n\n  // The override / agent default / env value can be either a concrete\n  // endpoint name or a model class slug (\"chat-thinking\" /\n  // \"chat-balanced\" / \"chat-fast\"). A class slug becomes a class intent\n  // (let the live catalogue pick the best model in that band); anything\n  // else is an explicit name fuzzy-matched against the catalogue. An\n  // internal `overrides.modelClass` (e.g. the chart planner) is the\n  // floor when nothing was requested.\n  const requested = override ?? overrides.modelId ?? process.env.DATABRICKS_SERVING_ENDPOINT_NAME;\n  const requestedClass = requested !== undefined ? parseModelClass(requested) : null;\n  const explicit = requestedClass === null ? requested : undefined;\n  const modelClass = requestedClass ?? overrides.modelClass;\n\n  const { modelId, source } = await selectModel(executionContext.client, host, {\n    ...(explicit !== undefined ? { explicit } : {}),\n    fuzzy: serving.fuzzy,\n    threshold: serving.threshold,\n    ...(modelClass !== undefined ? { modelClass } : {}),\n    fallbacks: serving.fallbacks,\n    ttlMs: serving.ttlMs,\n  });\n  logger.debug(\"model selected\", { modelId, source, requested });\n\n  return {\n    providerId: config.providerId ?? \"databricks\",\n    modelId,\n    url,\n    headers: Object.fromEntries(headers.entries()),\n  };\n}\n\n/** Path prefix that identifies a Databricks Model Serving REST call. */\nconst SERVING_ENDPOINTS_PATH_PREFIX = \"/serving-endpoints/\";\n\n/**\n * Install a single shared `globalThis.fetch` wrapper for every POST to\n * `/serving-endpoints/...`. The wrapper does two things:\n *\n *   1. Rewrites the outgoing `messages` array to repair Mastra/AI SDK\n *      stream-replay quirks that Databricks-hosted Claude rejects (see\n *      {@link rewriteServingBody} in `./serving-sanitize.js`).\n *   2. At `LOG_LEVEL=debug`, dumps the (post-sanitize) JSON body so\n *      4xx debugging doesn't have to fight AI SDK's `[Array]`\n *      formatter.\n *   3. Repairs buffered and streaming responses where a provider returns\n *      `choices[].message.content` or `choices[].delta.content` as a parts\n *      array that the AI SDK's OpenAI schema rejects.\n *\n * Safe to call from any hot path: {@link functionModule.memoize} ensures\n * the wrapper is installed at most once per process, so subsequent\n * calls are a no-op even when {@link buildModel} fires on every agent\n * step.\n */\nconst setupFetchInterceptor = functionModule.memoize((): void => {\n  const logger = log.logger(\"mastra/llm\");\n  const original = globalThis.fetch.bind(globalThis);\n  globalThis.fetch = (async (input, init) => {\n    const url = net.urlBuilder(input);\n    if (\n      !url ||\n      !url.pathname.startsWith(SERVING_ENDPOINTS_PATH_PREFIX) ||\n      typeof init?.body !== \"string\"\n    ) {\n      return original(input, init);\n    }\n    const rewritten = rewriteServingBody(init.body);\n    if (rewritten !== init.body) {\n      init = { ...init, body: rewritten };\n    }\n    const parsed = json.parse<unknown>(rewritten);\n    logger.debug(\n      \"POST\",\n      parsed === undefined\n        ? { url: url.toString(), bodyType: \"non-JSON\" }\n        : { url: url.toString(), body: parsed },\n    );\n    const response = await original(input, init);\n    return repairServingResponse(response);\n  }) as typeof globalThis.fetch;\n});\n\n/**\n * Rewrite a serving response whose body needs repair, leaving unsupported\n * content types byte-identical.\n *\n * SSE remains a live stream: a TransformStream repairs complete `data:` lines\n * as bytes arrive and preserves partial lines across network chunks. JSON is\n * buffered through the existing response-body repair. A non-JSON/non-SSE body\n * is returned untouched so the caller still sees the original response.\n */\nasync function repairServingResponse(response: Response): Promise<Response> {\n  const contentType = response.headers.get(\"content-type\") ?? \"\";\n  if (contentType.includes(\"text/event-stream\") && response.body) {\n    return rebuildServingResponse(response, rewriteServingResponseStream(response.body));\n  }\n  if (!contentType.includes(\"application/json\")) return response;\n\n  const body = await response.clone().text();\n  const rewritten = rewriteServingResponseBody(body);\n  if (rewritten === body) return response;\n  return rebuildServingResponse(response, rewritten);\n}\n\n/** Rebuild a transformed response without stale byte-length/encoding headers. */\nfunction rebuildServingResponse(\n  response: Response,\n  body: string | ReadableStream<Uint8Array>,\n): Response {\n  // `content-length` / `content-encoding` describe the ORIGINAL bytes, so they\n  // are dropped: the rewritten body is a different length and already decoded.\n  const headers = new Headers(response.headers);\n  headers.delete(\"content-length\");\n  headers.delete(\"content-encoding\");\n  return new Response(body, {\n    status: response.status,\n    statusText: response.statusText,\n    headers,\n  });\n}\n"]}

package/lib/src/serving-sanitize.d.ts

@@ -7,8 +7,9 @@
  * 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
+ * Inbound ({@link rewriteServingResponseBody} and
+ * {@link rewriteServingResponseStream}), because Databricks-hosted Gemini and
+ * Claude can answer with native content-parts arrays 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
@@ -75,6 +76,13 @@ export declare function repairAssistantPrefill(messages: ServingChatMessage[]):
  * {@link rewriteServingBody} on the request side.
  */
 export declare function rewriteServingResponseBody(body: string): string;
+/**
+ * Repair array-valued `choices[].delta.content` inside an OpenAI SSE stream
+ * without buffering the response. The decoder retains partial lines across
+ * arbitrary network chunk boundaries; each complete `data:` line is parsed and
+ * re-encoded only when its content needs normalization.
+ */
+export declare function rewriteServingResponseStream(body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
 /**
  * Collapse a structured `choices[].message.content` array to the plain string
  * the OpenAI Chat Completions contract specifies.
@@ -93,12 +101,17 @@ export declare function rewriteServingResponseBody(body: string): string;
  * 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
+ * Flattening on the wire keeps the repair in one place: 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.
+ * non-text part (a reasoning block, `thoughtSignature`-only entry, or 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 declare function flattenChoiceMessageContent(payload: Record<string, unknown>): boolean;
+/**
+ * Collapse structured streaming `choices[].delta.content` arrays to strings.
+ * Claude reasoning-only chunks become an empty content delta while text parts
+ * are concatenated in order.
+ */
+export declare function flattenChoiceDeltaContent(payload: Record<string, unknown>): boolean;

package/lib/src/serving-sanitize.js

@@ -7,8 +7,9 @@
  * 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
+ * Inbound ({@link rewriteServingResponseBody} and
+ * {@link rewriteServingResponseStream}), because Databricks-hosted Gemini and
+ * Claude can answer with native content-parts arrays 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
@@ -74,9 +75,10 @@ export function stripReasoningFromServingMessages(messages) {
             delete msg.reasoning_content;
             changed = true;
         }
-        if (!Array.isArray(msg.content))
+        const parts = openaiChat.chatContentParts(msg.content);
+        if (!parts)
             continue;
-        const filtered = msg.content.filter((part) => {
+        const filtered = parts.filter((part) => {
             const type = part?.type;
             if (typeof type === "string" && REASONING_PART_TYPES.has(type)) {
                 changed = true;
@@ -84,7 +86,7 @@ export function stripReasoningFromServingMessages(messages) {
             }
             return true;
         });
-        if (filtered.length !== msg.content.length) {
+        if (filtered.length !== parts.length) {
             msg.content = filtered;
         }
         const hasToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
@@ -160,9 +162,10 @@ function isEmptyServingContent(content) {
         return true;
     if (typeof content === "string")
         return content.trim().length === 0;
-    if (!Array.isArray(content))
+    const parts = openaiChat.chatContentParts(content);
+    if (!parts)
         return true;
-    return content.every((part) => {
+    return parts.every((part) => {
         if (part?.type === "text") {
             return typeof part.text !== "string" || part.text.trim().length === 0;
         }
@@ -181,6 +184,46 @@ export function rewriteServingResponseBody(body) {
         return body;
     return flattenChoiceMessageContent(parsed) ? JSON.stringify(parsed) : body;
 }
+/**
+ * Repair array-valued `choices[].delta.content` inside an OpenAI SSE stream
+ * without buffering the response. The decoder retains partial lines across
+ * arbitrary network chunk boundaries; each complete `data:` line is parsed and
+ * re-encoded only when its content needs normalization.
+ */
+export function rewriteServingResponseStream(body) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let buffer = "";
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline + 1);
+                buffer = buffer.slice(newline + 1);
+                controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(line)));
+                newline = buffer.indexOf("\n");
+            }
+        },
+        flush(controller) {
+            buffer += decoder.decode();
+            if (buffer)
+                controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(buffer)));
+        },
+    }));
+}
+/** Normalize one SSE line while preserving its `data:` spacing and line ending. */
+function rewriteServingResponseStreamLine(line) {
+    const lineEnding = line.endsWith("\r\n") ? "\r\n" : line.endsWith("\n") ? "\n" : "";
+    const content = lineEnding ? line.slice(0, -lineEnding.length) : line;
+    const match = /^(data:\s*)(.*)$/.exec(content);
+    if (!match || match[2] === "[DONE]")
+        return line;
+    const parsed = json.parseRecord(match[2]);
+    if (!parsed || !flattenChoiceDeltaContent(parsed))
+        return line;
+    return `${match[1]}${JSON.stringify(parsed)}${lineEnding}`;
+}
 /**
  * Collapse a structured `choices[].message.content` array to the plain string
  * the OpenAI Chat Completions contract specifies.
@@ -199,30 +242,42 @@ export function rewriteServingResponseBody(body) {
  * 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
+ * Flattening on the wire keeps the repair in one place: 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.
+ * non-text part (a reasoning block, `thoughtSignature`-only entry, or 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) {
+    return flattenChoiceContent(payload, "message");
+}
+/**
+ * Collapse structured streaming `choices[].delta.content` arrays to strings.
+ * Claude reasoning-only chunks become an empty content delta while text parts
+ * are concatenated in order.
+ */
+export function flattenChoiceDeltaContent(payload) {
+    return flattenChoiceContent(payload, "delta");
+}
+/** Shared choice walker for buffered `message` and streaming `delta` payloads. */
+function flattenChoiceContent(payload, field) {
     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")
+        const container = choice[field];
+        if (!container || typeof container !== "object")
             continue;
-        const target = message;
-        if (!Array.isArray(target.content))
+        const target = container;
+        const parts = openaiChat.chatContentParts(target.content);
+        if (!parts)
             continue;
-        target.content = openaiChat.chatContentToText(target.content, { types: ["text"] });
+        target.content = openaiChat.chatContentToText(parts, { 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"]}
+//# 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} and\n * {@link rewriteServingResponseStream}), because Databricks-hosted Gemini and\n * Claude can answer with native content-parts arrays 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    const parts = openaiChat.chatContentParts(msg.content);\n    if (!parts) continue;\n    const filtered = parts.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 !== parts.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  const parts = openaiChat.chatContentParts(content);\n  if (!parts) return true;\n  return parts.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 * Repair array-valued `choices[].delta.content` inside an OpenAI SSE stream\n * without buffering the response. The decoder retains partial lines across\n * arbitrary network chunk boundaries; each complete `data:` line is parsed and\n * re-encoded only when its content needs normalization.\n */\nexport function rewriteServingResponseStream(\n  body: ReadableStream<Uint8Array>,\n): ReadableStream<Uint8Array> {\n  const decoder = new TextDecoder();\n  const encoder = new TextEncoder();\n  let buffer = \"\";\n\n  return body.pipeThrough(\n    new TransformStream<Uint8Array, Uint8Array>({\n      transform(chunk, controller) {\n        buffer += decoder.decode(chunk, { stream: true });\n        let newline = buffer.indexOf(\"\\n\");\n        while (newline >= 0) {\n          const line = buffer.slice(0, newline + 1);\n          buffer = buffer.slice(newline + 1);\n          controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(line)));\n          newline = buffer.indexOf(\"\\n\");\n        }\n      },\n      flush(controller) {\n        buffer += decoder.decode();\n        if (buffer) controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(buffer)));\n      },\n    }),\n  );\n}\n\n/** Normalize one SSE line while preserving its `data:` spacing and line ending. */\nfunction rewriteServingResponseStreamLine(line: string): string {\n  const lineEnding = line.endsWith(\"\\r\\n\") ? \"\\r\\n\" : line.endsWith(\"\\n\") ? \"\\n\" : \"\";\n  const content = lineEnding ? line.slice(0, -lineEnding.length) : line;\n  const match = /^(data:\\s*)(.*)$/.exec(content);\n  if (!match || match[2] === \"[DONE]\") return line;\n\n  const parsed = json.parseRecord(match[2]);\n  if (!parsed || !flattenChoiceDeltaContent(parsed)) return line;\n  return `${match[1]}${JSON.stringify(parsed)}${lineEnding}`;\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: neither the agent's\n * stored transcript nor the UI has to know the provider emitted parts. Any\n * non-text part (a reasoning block, `thoughtSignature`-only entry, or inline\n * image) contributes nothing, matching {@link openaiChat.chatContentToText},\n * and an all-parts-empty message flattens to `\"\"` rather than being dropped, so\n * `finish_reason` and `usage` still round-trip.\n */\nexport function flattenChoiceMessageContent(payload: Record<string, unknown>): boolean {\n  return flattenChoiceContent(payload, \"message\");\n}\n\n/**\n * Collapse structured streaming `choices[].delta.content` arrays to strings.\n * Claude reasoning-only chunks become an empty content delta while text parts\n * are concatenated in order.\n */\nexport function flattenChoiceDeltaContent(payload: Record<string, unknown>): boolean {\n  return flattenChoiceContent(payload, \"delta\");\n}\n\n/** Shared choice walker for buffered `message` and streaming `delta` payloads. */\nfunction flattenChoiceContent(\n  payload: Record<string, unknown>,\n  field: \"message\" | \"delta\",\n): 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 container = (choice as Record<string, unknown>)[field];\n    if (!container || typeof container !== \"object\") continue;\n    const target = container as { content?: unknown };\n    const parts = openaiChat.chatContentParts(target.content);\n    if (!parts) continue;\n    target.content = openaiChat.chatContentToText(parts, { types: [\"text\"] });\n    changed = true;\n  }\n  return changed;\n}\n"]}

package/package.json

@@ -31,18 +31,18 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.60.0",
-    "@dbx-tools/appkit": "0.6.213",
-    "@dbx-tools/core": "0.6.213",
-    "@dbx-tools/databricks": "0.6.213",
-    "@dbx-tools/fs": "0.6.213",
-    "@dbx-tools/genie": "0.6.213",
-    "@dbx-tools/model": "0.6.213",
-    "@dbx-tools/path": "0.6.213",
-    "@dbx-tools/shared-core": "0.6.213",
-    "@dbx-tools/shared-fs": "0.6.213",
-    "@dbx-tools/shared-genie": "0.6.213",
-    "@dbx-tools/shared-mastra": "0.6.213",
-    "@dbx-tools/shared-model": "0.6.213",
+    "@dbx-tools/appkit": "0.6.215",
+    "@dbx-tools/core": "0.6.215",
+    "@dbx-tools/databricks": "0.6.215",
+    "@dbx-tools/fs": "0.6.215",
+    "@dbx-tools/genie": "0.6.215",
+    "@dbx-tools/model": "0.6.215",
+    "@dbx-tools/path": "0.6.215",
+    "@dbx-tools/shared-core": "0.6.215",
+    "@dbx-tools/shared-fs": "0.6.215",
+    "@dbx-tools/shared-genie": "0.6.215",
+    "@dbx-tools/shared-mastra": "0.6.215",
+    "@dbx-tools/shared-model": "0.6.215",
     "@mastra/ai-sdk": "1.6.0",
     "@mastra/core": "1.47.0",
     "@mastra/express": "1.4.2",
@@ -72,7 +72,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.213",
+  "version": "0.6.215",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/genie.ts

@@ -402,8 +402,9 @@ function buildAskGenieTool(opts: {
 
       Returns the final \`GenieMessage\`. Agent Mode includes the
       synthesized answer and can include SQL result values as a
-      Markdown text attachment. A legacy polling result instead
-      carries a \`statement_id\` (at
+      Markdown text attachment. Agent Mode has no \`statement_id\`;
+      use \`render_data\` with its inline rows when a chart is needed.
+      A legacy polling result instead carries a \`statement_id\` (at
       \`message.query_result.statement_id\` or the first
       attachment's \`query.statement_id\`); call
       \`get_statement\` with that id only when you need to read
@@ -823,10 +824,17 @@ export const GENIE_INSTRUCTIONS = string.toDescription([
       `
         Each \`ask_genie\` call returns the terminal \`GenieMessage\`.
         Read Agent Mode's synthesized answer and Markdown query output
-        directly from its text attachments. A legacy polling result may
-        instead expose a \`statement_id\` at
+        directly from its text attachments. Agent Mode does NOT expose a
+        \`statement_id\`. To chart its result, call \`render_data\` with
+        rows copied from the Markdown table or structured table metadata,
+        then copy the returned marker. Never pass an Agent Mode response id,
+        conversation id, function-call id, or any other identifier to
+        \`prepare_chart\`.
+
+        A legacy polling result may instead expose a \`statement_id\` at
         \`message.query_result.statement_id\` (or the first
-        attachment's \`query.statement_id\`).
+        attachment's \`query.statement_id\`). Only that real statement id
+        belongs in \`prepare_chart\` or a \`[data:<statement_id>]\` marker.
       `,
       [
         `
@@ -837,34 +845,35 @@ export const GENIE_INSTRUCTIONS = string.toDescription([
         {
           bullets: [
             `
-              \`[data:<statement_id>]\` - render the rows as a table.
+              \`[data:<statement_id>]\` - render legacy polling rows as a table.
               Use this when there's no clear visual story (long lists,
               reference data, single-row results, or the user just
-              wants to see the data). Embed the marker directly; no
-              tool call needed.
+              wants to see the data). Embed the marker directly when
+              \`ask_genie\` returned a real \`statement_id\`; Agent Mode
+              already carries its query output inline.
             `,
             `
               \`[chart:<chartId>]\` - render the rows as a chart. To
-              get one, call \`prepare_chart\` with the
-              statement's id (and an optional \`title\` / one-line
-              \`description\` of the insight to surface). The tool
-              returns the complete \`marker\` synchronously and
-              prepares the chart spec in the background; copy that
-              marker VERBATIM onto its own line wherever the chart
-              should appear. Use a chart when the data has a
-              story a visual conveys better than a table (trends,
-              rankings, distributions, parts-of-a-whole).
+              get one from Agent Mode, call \`render_data\` with the
+              inline rows. To get one from legacy polling, call
+              \`prepare_chart\` with the real statement id. Both tools
+              accept an optional \`title\` / one-line \`description\`
+              of the insight to surface, return the complete \`marker\`
+              synchronously, and prepare the chart spec in the
+              background. Copy that marker VERBATIM onto its own line
+              wherever the chart should appear. Use a chart when the
+              data has a story a visual conveys better than a table
+              (trends, rankings, distributions, parts-of-a-whole).
 
               NEVER invent or hand-build a marker. A valid marker is
-              the complete opaque string a \`prepare_chart\` call
-              returned to you in THIS turn - nothing else. Its id is
-              NOT a \`statement_id\`, and it is NOT a
+              the complete opaque string a \`render_data\` or
+              \`prepare_chart\` call returned to you in THIS turn -
+              nothing else. Its id is NOT a \`statement_id\`, and it is NOT a
               \`statement_id\` prefix with a label appended (e.g.
               \`01f1...-region-fill\`). If you have not called
-              \`prepare_chart\` and received an id back, do not write
-              a \`[chart:...]\` marker at all - use \`[data:...]\`
-              instead. A fabricated chart id renders nothing and
-              wastes a request.
+              one of those chart tools and received an id back, do not
+              write a \`[chart:...]\` marker at all. A fabricated chart
+              id renders nothing and wastes a request.
             `,
           ],
         },
@@ -872,10 +881,10 @@ export const GENIE_INSTRUCTIONS = string.toDescription([
           The host UI resolves both markers on its own once it sees
           them - you do NOT need to call \`get_statement\` just to
           display data, and you do NOT need to wait on
-          \`prepare_chart\` (it returns the id immediately and the
-          host UI fetches the cached chart later). Pick at most one
-          marker per statement; don't chart AND table the same result
-          side by side.
+          \`render_data\` or \`prepare_chart\` (they return the id
+          immediately and the host UI fetches the cached chart later).
+          Pick at most one marker per result; don't chart AND table the
+          same result side by side.
         `,
       ],
       `