@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/model.js

@@ -0,0 +1,168 @@
+/**
+ * Databricks Model Serving resolver for Mastra agents.
+ *
+ * Each agent step calls {@link buildModel} with the active
+ * `RequestContext`. The user stamped by `MastraServer` carries an
+ * AppKit `WorkspaceClient`; we ask it for the workspace host and a
+ * fresh bearer header, then point Mastra's OpenAI-compatible provider
+ * at `/serving-endpoints` on that host.
+ *
+ * This module only adds the Mastra-specific glue. The actual model
+ * selection - listing the workspace catalogue and resolving an
+ * explicit name / class / fallback chain to a real endpoint id - lives
+ * in `@dbx-tools/model` ({@link selectModel}) so non-Mastra consumers
+ * (e.g. a job that just needs a model name) can reuse it. Here we
+ * assemble the explicit ask from Mastra's request context (the
+ * per-request override under {@link MASTRA_MODEL_OVERRIDE_KEY}, the
+ * agent / plugin `modelId`, or `DATABRICKS_SERVING_ENDPOINT_NAME`),
+ * pass the plugin's fuzzy / class / fallback knobs through, and wrap
+ * the resolved id in the OpenAI-compatible provider config Mastra
+ * expects. Catalogue fetches fail loud: network / auth errors
+ * propagate so callers see the real SDK message.
+ *
+ * @module
+ */
+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 { MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from "./serving.js";
+import { rewriteServingBody, rewriteServingResponseBody } from "./serving-sanitize.js";
+const { parseModelClass } = classes;
+const { selectModel } = resolve;
+/**
+ * Resolve a `MastraModelConfig` for the current agent step. Runs
+ * while `agent.stream` is inside the `asUser(req)` scope so tokens
+ * are user-scoped; outside an active user context the workspace
+ * client falls back to the service principal.
+ *
+ * Endpoint precedence: the per-request override
+ * ({@link MASTRA_MODEL_OVERRIDE_KEY}, only when `config.modelOverride` allows
+ * it), then {@link BuildModelOverrides.modelId} from the agent / plugin
+ * config, then `DATABRICKS_SERVING_ENDPOINT_NAME`. With none of those set the
+ * capability class and fallback ladder in `@dbx-tools/model` choose the
+ * endpoint.
+ */
+export async function buildModel(config, requestContext, overrides = {}) {
+    void setupFetchInterceptor();
+    // The chat path stamps the AppKit user on the request context via
+    // `MastraServer`. The MCP transport routes don't thread that context
+    // into tool execution, so fall back to the ambient execution context
+    // (the active OBO scope, or the service principal) when it's absent.
+    const user = requestContext.get(MASTRA_USER_KEY);
+    const executionContext = user?.executionContext ?? getExecutionContext();
+    const clientConfig = executionContext.client.config;
+    const host = (await clientConfig.getHost()).toString();
+    const headers = new Headers();
+    await clientConfig.authenticate(headers);
+    // The OpenAI Node SDK appends paths like `/chat/completions` to whatever
+    // URL we hand it. Drop the trailing slash so the resulting URL stays
+    // well-formed (`/serving-endpoints/chat/completions`).
+    const url = new URL("/serving-endpoints", host).toString().replace(/\/$/, "");
+    const logger = log.logger(config);
+    const serving = resolveServingConfig(config);
+    const override = serving.allowOverride
+        ? requestContext.get(MASTRA_MODEL_OVERRIDE_KEY)
+        : undefined;
+    // The override / agent default / env value can be either a concrete
+    // endpoint name or a model class slug ("chat-thinking" /
+    // "chat-balanced" / "chat-fast"). A class slug becomes a class intent
+    // (let the live catalogue pick the best model in that band); anything
+    // else is an explicit name fuzzy-matched against the catalogue. An
+    // internal `overrides.modelClass` (e.g. the chart planner) is the
+    // floor when nothing was requested.
+    const requested = override ?? overrides.modelId ?? process.env.DATABRICKS_SERVING_ENDPOINT_NAME;
+    const requestedClass = requested !== undefined ? parseModelClass(requested) : null;
+    const explicit = requestedClass === null ? requested : undefined;
+    const modelClass = requestedClass ?? overrides.modelClass;
+    const { modelId, source } = await selectModel(executionContext.client, host, {
+        ...(explicit !== undefined ? { explicit } : {}),
+        fuzzy: serving.fuzzy,
+        threshold: serving.threshold,
+        ...(modelClass !== undefined ? { modelClass } : {}),
+        fallbacks: serving.fallbacks,
+        ttlMs: serving.ttlMs,
+    });
+    logger.debug("model selected", { modelId, source, requested });
+    return {
+        providerId: config.providerId ?? "databricks",
+        modelId,
+        url,
+        headers: Object.fromEntries(headers.entries()),
+    };
+}
+/** Path prefix that identifies a Databricks Model Serving REST call. */
+const SERVING_ENDPOINTS_PATH_PREFIX = "/serving-endpoints/";
+/**
+ * Install a single shared `globalThis.fetch` wrapper for every POST to
+ * `/serving-endpoints/...`. The wrapper does two things:
+ *
+ *   1. Rewrites the outgoing `messages` array to repair Mastra/AI SDK
+ *      stream-replay quirks that Databricks-hosted Claude rejects (see
+ *      {@link rewriteServingBody} in `./serving-sanitize.js`).
+ *   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}).
+ *
+ * Safe to call from any hot path: {@link functionModule.memoize} ensures
+ * the wrapper is installed at most once per process, so subsequent
+ * calls are a no-op even when {@link buildModel} fires on every agent
+ * step.
+ */
+const setupFetchInterceptor = functionModule.memoize(() => {
+    const logger = log.logger("mastra/llm");
+    const original = globalThis.fetch.bind(globalThis);
+    globalThis.fetch = (async (input, init) => {
+        const url = net.urlBuilder(input);
+        if (!url ||
+            !url.pathname.startsWith(SERVING_ENDPOINTS_PATH_PREFIX) ||
+            typeof init?.body !== "string") {
+            return original(input, init);
+        }
+        const rewritten = rewriteServingBody(init.body);
+        if (rewritten !== init.body) {
+            init = { ...init, body: rewritten };
+        }
+        const parsed = json.parse(rewritten);
+        logger.debug("POST", parsed === undefined
+            ? { url: url.toString(), bodyType: "non-JSON" }
+            : { url: url.toString(), body: parsed });
+        const response = await original(input, init);
+        return repairServingResponse(response);
+    });
+});
+/**
+ * Rewrite a non-streaming serving response whose body needs repair, leaving
+ * everything else 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.
+ */
+async function repairServingResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("application/json"))
+        return response;
+    const body = await response.clone().text();
+    const rewritten = rewriteServingResponseBody(body);
+    if (rewritten === body)
+        return response;
+    // `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, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+//# 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\";\nimport { MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from \"./serving\";\nimport { rewriteServingBody, rewriteServingResponseBody } from \"./serving-sanitize\";\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"]}

package/lib/src/observability.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Mastra observability wired through the same OTel pipeline AppKit's
+ * built-in plugins (e.g. `agents`) use, via `@mastra/otel-bridge`.
+ *
+ * How traces flow:
+ *
+ * 1. `@databricks/appkit` boots a global `NodeSDK` in
+ *    `TelemetryManager.initialize()` (during `createApp`) when
+ *    `OTEL_EXPORTER_OTLP_ENDPOINT` is set in the process env.
+ * 2. Every AppKit plugin span (e.g. the `agents` plugin's
+ *    `executeStream`) is created via the global OTel tracer
+ *    (`trace.getTracer(<plugin>)`), so it lands on that NodeSDK and
+ *    is shipped through its OTLP exporter.
+ * 3. The Mastra `OtelBridge` ALSO creates real OTel spans on the same
+ *    global tracer for every Mastra operation (agent runs, model
+ *    calls, tool invocations, workflow steps). They inherit the
+ *    ambient OTel context, so when Mastra is invoked from inside an
+ *    AppKit HTTP span the trace stays connected.
+ *
+ * Net effect: Mastra spans get exactly the treatment AppKit's
+ * `agents` plugin gets. No custom OTLP pipeline lives in this
+ * package; the OTLP endpoint, headers, and resource attributes are
+ * driven by the standard OTel env vars
+ * (`OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_EXPORTER_OTLP_HEADERS`,
+ * `OTEL_SERVICE_NAME`, `OTEL_RESOURCE_ATTRIBUTES`, ...) and consumed
+ * by AppKit's `TelemetryManager`. Set those once and both AppKit and
+ * Mastra spans end up at the same backend.
+ *
+ * When `OTEL_EXPORTER_OTLP_ENDPOINT` is unset the bridge is not
+ * registered at all (unless `observability: true` forces it on), so
+ * Mastra does not emit `[OtelBridge] No OTEL span found` warnings.
+ *
+ * @module
+ */
+import { Observability } from "@mastra/observability";
+export interface BuildObservabilityOptions {
+    /**
+     * Whether to wire the Mastra `OtelBridge`. Mirrors
+     * {@link MastraPluginConfig.observability}:
+     *
+     * - `undefined` (auto): on only when `OTEL_EXPORTER_OTLP_ENDPOINT` or
+     *   `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` is set (same signal AppKit's
+     *   `TelemetryManager` uses to register a real tracer). When unset,
+     *   skip the bridge entirely so Mastra does not emit
+     *   `[OtelBridge] No OTEL span found` warnings on the noop tracer.
+     * - `true`: force on even without an OTLP endpoint.
+     * - `false`: force off.
+     */
+    enabled?: boolean;
+    /**
+     * Service name attached to the Mastra `Observability` config. Used
+     * as the tracer scope name on bridged OTel spans (the `service.name`
+     * resource attribute is owned by AppKit's `TelemetryManager` instead
+     * - it reads `OTEL_SERVICE_NAME` / `DATABRICKS_APP_NAME` at
+     * `createApp` time).
+     *
+     * Defaults to project name then `"mastra"`.
+     */
+    serviceName?: string;
+    /**
+     * `RequestContext` keys to extract as span metadata on every Mastra
+     * trace. Defaults to {@link TRACE_REQUEST_CONTEXT_KEYS} (user id,
+     * thread id, request id, environment, model override, ...).
+     *
+     * Supports dot notation for nested values per the Mastra docs.
+     */
+    requestContextKeys?: readonly string[];
+}
+/** True when AppKit's global OTel pipeline is configured to export traces. */
+export declare function isOtlpTracingConfigured(): boolean;
+/**
+ * Build a Mastra `Observability` whose spans ride AppKit's global
+ * OTel pipeline via `@mastra/otel-bridge`.
+ *
+ * Returns `undefined` when tracing is off: either the caller passed
+ * `enabled: false`, or auto mode finds no OTLP endpoint (the default).
+ * Skipping the bridge in that case avoids `[OtelBridge] No OTEL span
+ * found` log spam from Mastra spans that have no parent on the noop
+ * tracer.
+ */
+export declare function buildObservability(options?: BuildObservabilityOptions): Promise<Observability | undefined>;

package/lib/src/observability.js

@@ -0,0 +1,98 @@
+/**
+ * Mastra observability wired through the same OTel pipeline AppKit's
+ * built-in plugins (e.g. `agents`) use, via `@mastra/otel-bridge`.
+ *
+ * How traces flow:
+ *
+ * 1. `@databricks/appkit` boots a global `NodeSDK` in
+ *    `TelemetryManager.initialize()` (during `createApp`) when
+ *    `OTEL_EXPORTER_OTLP_ENDPOINT` is set in the process env.
+ * 2. Every AppKit plugin span (e.g. the `agents` plugin's
+ *    `executeStream`) is created via the global OTel tracer
+ *    (`trace.getTracer(<plugin>)`), so it lands on that NodeSDK and
+ *    is shipped through its OTLP exporter.
+ * 3. The Mastra `OtelBridge` ALSO creates real OTel spans on the same
+ *    global tracer for every Mastra operation (agent runs, model
+ *    calls, tool invocations, workflow steps). They inherit the
+ *    ambient OTel context, so when Mastra is invoked from inside an
+ *    AppKit HTTP span the trace stays connected.
+ *
+ * Net effect: Mastra spans get exactly the treatment AppKit's
+ * `agents` plugin gets. No custom OTLP pipeline lives in this
+ * package; the OTLP endpoint, headers, and resource attributes are
+ * driven by the standard OTel env vars
+ * (`OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_EXPORTER_OTLP_HEADERS`,
+ * `OTEL_SERVICE_NAME`, `OTEL_RESOURCE_ATTRIBUTES`, ...) and consumed
+ * by AppKit's `TelemetryManager`. Set those once and both AppKit and
+ * Mastra spans end up at the same backend.
+ *
+ * When `OTEL_EXPORTER_OTLP_ENDPOINT` is unset the bridge is not
+ * registered at all (unless `observability: true` forces it on), so
+ * Mastra does not emit `[OtelBridge] No OTEL span found` warnings.
+ *
+ * @module
+ */
+import { project } from "@dbx-tools/core";
+import { log } from "@dbx-tools/shared-core";
+import { Observability } from "@mastra/observability";
+import { OtelBridge } from "@mastra/otel-bridge";
+import { TRACE_REQUEST_CONTEXT_KEYS } from "./config.js";
+const logger = log.logger("mastra/observability");
+const DEFAULT_SERVICE_NAME = "mastra";
+/** True when AppKit's global OTel pipeline is configured to export traces. */
+export function isOtlpTracingConfigured() {
+    return Boolean(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT);
+}
+/**
+ * Build a Mastra `Observability` whose spans ride AppKit's global
+ * OTel pipeline via `@mastra/otel-bridge`.
+ *
+ * Returns `undefined` when tracing is off: either the caller passed
+ * `enabled: false`, or auto mode finds no OTLP endpoint (the default).
+ * Skipping the bridge in that case avoids `[OtelBridge] No OTEL span
+ * found` log spam from Mastra spans that have no parent on the noop
+ * tracer.
+ */
+export async function buildObservability(options) {
+    const otelBase = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    const otelTracesOverride = process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT;
+    const otlpConfigured = isOtlpTracingConfigured();
+    if (options?.enabled === false || (options?.enabled !== true && !otlpConfigured)) {
+        logger.info("Mastra observability off", {
+            reason: options?.enabled === false
+                ? "disabled in plugin config"
+                : "OTEL_EXPORTER_OTLP_ENDPOINT unset",
+        });
+        return undefined;
+    }
+    const serviceName = options?.serviceName ?? (await project.name()) ?? DEFAULT_SERVICE_NAME;
+    const requestContextKeys = [...(options?.requestContextKeys ?? TRACE_REQUEST_CONTEXT_KEYS)];
+    // The OTel HTTP exporter treats `OTEL_EXPORTER_OTLP_ENDPOINT` as a
+    // *base* URL and appends the signal path itself (e.g.
+    // `http://localhost:6006` -> `http://localhost:6006/v1/traces`). Log
+    // the resolved POST URL so misconfigurations (e.g. accidentally
+    // setting the base var to a `/v1/traces`-suffixed URL, which makes
+    // the SDK POST to `.../v1/traces/v1/traces` and Phoenix 404s) are
+    // obvious in startup output.
+    const resolvedTracesUrl = otelTracesOverride
+        ? otelTracesOverride
+        : otelBase
+            ? `${otelBase.replace(/\/+$/, "")}/v1/traces`
+            : undefined;
+    logger.info("Mastra observability wired through OTel bridge", {
+        serviceName,
+        requestContextKeys,
+        otelBase: otelBase ?? "<unset>",
+        resolvedTracesUrl: resolvedTracesUrl ?? "<unset>",
+    });
+    return new Observability({
+        configs: {
+            serviceName: {
+                serviceName,
+                bridge: new OtelBridge(),
+                requestContextKeys,
+            },
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observability.js","sourceRoot":"","sources":["../../src/observability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAEtD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAElD,MAAM,oBAAoB,GAAG,QAAQ,CAAC;AAoCtC,8EAA8E;AAC9E,MAAM,UAAU,uBAAuB;IACrC,OAAO,OAAO,CACZ,OAAO,CAAC,GAAG,CAAC,2BAA2B,IAAI,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAC1F,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,OAAmC;IAEnC,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC;IACzD,MAAM,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC;IAC1E,MAAM,cAAc,GAAG,uBAAuB,EAAE,CAAC;IAEjD,IAAI,OAAO,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;QACjF,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE;YACtC,MAAM,EACJ,OAAO,EAAE,OAAO,KAAK,KAAK;gBACxB,CAAC,CAAC,2BAA2B;gBAC7B,CAAC,CAAC,mCAAmC;SAC1C,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,WAAW,GAAG,OAAO,EAAE,WAAW,IAAI,CAAC,MAAM,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,oBAAoB,CAAC;IAC3F,MAAM,kBAAkB,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,kBAAkB,IAAI,0BAA0B,CAAC,CAAC,CAAC;IAE5F,mEAAmE;IACnE,sDAAsD;IACtD,qEAAqE;IACrE,gEAAgE;IAChE,mEAAmE;IACnE,kEAAkE;IAClE,6BAA6B;IAC7B,MAAM,iBAAiB,GAAG,kBAAkB;QAC1C,CAAC,CAAC,kBAAkB;QACpB,CAAC,CAAC,QAAQ;YACR,CAAC,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY;YAC7C,CAAC,CAAC,SAAS,CAAC;IAChB,MAAM,CAAC,IAAI,CAAC,gDAAgD,EAAE;QAC5D,WAAW;QACX,kBAAkB;QAClB,QAAQ,EAAE,QAAQ,IAAI,SAAS;QAC/B,iBAAiB,EAAE,iBAAiB,IAAI,SAAS;KAClD,CAAC,CAAC;IAEH,OAAO,IAAI,aAAa,CAAC;QACvB,OAAO,EAAE;YACP,WAAW,EAAE;gBACX,WAAW;gBACX,MAAM,EAAE,IAAI,UAAU,EAAE;gBACxB,kBAAkB;aACnB;SACF;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Mastra observability wired through the same OTel pipeline AppKit's\n * built-in plugins (e.g. `agents`) use, via `@mastra/otel-bridge`.\n *\n * How traces flow:\n *\n * 1. `@databricks/appkit` boots a global `NodeSDK` in\n *    `TelemetryManager.initialize()` (during `createApp`) when\n *    `OTEL_EXPORTER_OTLP_ENDPOINT` is set in the process env.\n * 2. Every AppKit plugin span (e.g. the `agents` plugin's\n *    `executeStream`) is created via the global OTel tracer\n *    (`trace.getTracer(<plugin>)`), so it lands on that NodeSDK and\n *    is shipped through its OTLP exporter.\n * 3. The Mastra `OtelBridge` ALSO creates real OTel spans on the same\n *    global tracer for every Mastra operation (agent runs, model\n *    calls, tool invocations, workflow steps). They inherit the\n *    ambient OTel context, so when Mastra is invoked from inside an\n *    AppKit HTTP span the trace stays connected.\n *\n * Net effect: Mastra spans get exactly the treatment AppKit's\n * `agents` plugin gets. No custom OTLP pipeline lives in this\n * package; the OTLP endpoint, headers, and resource attributes are\n * driven by the standard OTel env vars\n * (`OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_EXPORTER_OTLP_HEADERS`,\n * `OTEL_SERVICE_NAME`, `OTEL_RESOURCE_ATTRIBUTES`, ...) and consumed\n * by AppKit's `TelemetryManager`. Set those once and both AppKit and\n * Mastra spans end up at the same backend.\n *\n * When `OTEL_EXPORTER_OTLP_ENDPOINT` is unset the bridge is not\n * registered at all (unless `observability: true` forces it on), so\n * Mastra does not emit `[OtelBridge] No OTEL span found` warnings.\n *\n * @module\n */\n\nimport { project } from \"@dbx-tools/core\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { Observability } from \"@mastra/observability\";\nimport { OtelBridge } from \"@mastra/otel-bridge\";\n\nimport { TRACE_REQUEST_CONTEXT_KEYS } from \"./config\";\n\nconst logger = log.logger(\"mastra/observability\");\n\nconst DEFAULT_SERVICE_NAME = \"mastra\";\n\nexport interface BuildObservabilityOptions {\n  /**\n   * Whether to wire the Mastra `OtelBridge`. Mirrors\n   * {@link MastraPluginConfig.observability}:\n   *\n   * - `undefined` (auto): on only when `OTEL_EXPORTER_OTLP_ENDPOINT` or\n   *   `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` is set (same signal AppKit's\n   *   `TelemetryManager` uses to register a real tracer). When unset,\n   *   skip the bridge entirely so Mastra does not emit\n   *   `[OtelBridge] No OTEL span found` warnings on the noop tracer.\n   * - `true`: force on even without an OTLP endpoint.\n   * - `false`: force off.\n   */\n  enabled?: boolean;\n  /**\n   * Service name attached to the Mastra `Observability` config. Used\n   * as the tracer scope name on bridged OTel spans (the `service.name`\n   * resource attribute is owned by AppKit's `TelemetryManager` instead\n   * - it reads `OTEL_SERVICE_NAME` / `DATABRICKS_APP_NAME` at\n   * `createApp` time).\n   *\n   * Defaults to project name then `\"mastra\"`.\n   */\n  serviceName?: string;\n  /**\n   * `RequestContext` keys to extract as span metadata on every Mastra\n   * trace. Defaults to {@link TRACE_REQUEST_CONTEXT_KEYS} (user id,\n   * thread id, request id, environment, model override, ...).\n   *\n   * Supports dot notation for nested values per the Mastra docs.\n   */\n  requestContextKeys?: readonly string[];\n}\n\n/** True when AppKit's global OTel pipeline is configured to export traces. */\nexport function isOtlpTracingConfigured(): boolean {\n  return Boolean(\n    process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,\n  );\n}\n\n/**\n * Build a Mastra `Observability` whose spans ride AppKit's global\n * OTel pipeline via `@mastra/otel-bridge`.\n *\n * Returns `undefined` when tracing is off: either the caller passed\n * `enabled: false`, or auto mode finds no OTLP endpoint (the default).\n * Skipping the bridge in that case avoids `[OtelBridge] No OTEL span\n * found` log spam from Mastra spans that have no parent on the noop\n * tracer.\n */\nexport async function buildObservability(\n  options?: BuildObservabilityOptions,\n): Promise<Observability | undefined> {\n  const otelBase = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;\n  const otelTracesOverride = process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT;\n  const otlpConfigured = isOtlpTracingConfigured();\n\n  if (options?.enabled === false || (options?.enabled !== true && !otlpConfigured)) {\n    logger.info(\"Mastra observability off\", {\n      reason:\n        options?.enabled === false\n          ? \"disabled in plugin config\"\n          : \"OTEL_EXPORTER_OTLP_ENDPOINT unset\",\n    });\n    return undefined;\n  }\n\n  const serviceName = options?.serviceName ?? (await project.name()) ?? DEFAULT_SERVICE_NAME;\n  const requestContextKeys = [...(options?.requestContextKeys ?? TRACE_REQUEST_CONTEXT_KEYS)];\n\n  // The OTel HTTP exporter treats `OTEL_EXPORTER_OTLP_ENDPOINT` as a\n  // *base* URL and appends the signal path itself (e.g.\n  // `http://localhost:6006` -> `http://localhost:6006/v1/traces`). Log\n  // the resolved POST URL so misconfigurations (e.g. accidentally\n  // setting the base var to a `/v1/traces`-suffixed URL, which makes\n  // the SDK POST to `.../v1/traces/v1/traces` and Phoenix 404s) are\n  // obvious in startup output.\n  const resolvedTracesUrl = otelTracesOverride\n    ? otelTracesOverride\n    : otelBase\n      ? `${otelBase.replace(/\\/+$/, \"\")}/v1/traces`\n      : undefined;\n  logger.info(\"Mastra observability wired through OTel bridge\", {\n    serviceName,\n    requestContextKeys,\n    otelBase: otelBase ?? \"<unset>\",\n    resolvedTracesUrl: resolvedTracesUrl ?? \"<unset>\",\n  });\n\n  return new Observability({\n    configs: {\n      serviceName: {\n        serviceName,\n        bridge: new OtelBridge(),\n        requestContextKeys,\n      },\n    },\n  });\n}\n"]}

package/lib/src/pagination.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Query-parameter coercion shared by the paginated custom routes
+ * (`history` / `threads`). Each route keeps its own page-size default
+ * and hard cap and passes them in, so the coercion rules stay in one
+ * place without collapsing the routes' distinct sizing.
+ *
+ * @module
+ */
+/** Bounds for {@link clampPerPage}. */
+export interface PerPageBounds {
+    /** Page size used for empty / non-positive / non-numeric inputs. */
+    fallback: number;
+    /** Hard cap so a misbehaving client can't fetch everything at once. */
+    max: number;
+}
+/** Coerce / clamp a `perPage` value, falling back to `bounds.fallback`. */
+export declare function clampPerPage(value: number | undefined, bounds: PerPageBounds): number;
+/**
+ * Coerce a Hono query value into a non-negative integer. Returns
+ * `undefined` for empty / non-numeric / negative inputs so the caller
+ * can apply its built-in defaults.
+ */
+export declare function parseIntParam(value: string | undefined): number | undefined;

package/lib/src/pagination.js

@@ -0,0 +1,31 @@
+/**
+ * Query-parameter coercion shared by the paginated custom routes
+ * (`history` / `threads`). Each route keeps its own page-size default
+ * and hard cap and passes them in, so the coercion rules stay in one
+ * place without collapsing the routes' distinct sizing.
+ *
+ * @module
+ */
+/** Coerce / clamp a `perPage` value, falling back to `bounds.fallback`. */
+export function clampPerPage(value, bounds) {
+    if (value === undefined || Number.isNaN(value))
+        return bounds.fallback;
+    const n = Math.trunc(value);
+    if (n <= 0)
+        return bounds.fallback;
+    return Math.min(n, bounds.max);
+}
+/**
+ * Coerce a Hono query value into a non-negative integer. Returns
+ * `undefined` for empty / non-numeric / negative inputs so the caller
+ * can apply its built-in defaults.
+ */
+export function parseIntParam(value) {
+    if (!value)
+        return undefined;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0)
+        return undefined;
+    return Math.trunc(n);
+}
+//# sourceMappingURL=data:application/json;base64,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