@dbx-tools/appkit-mastra 0.9.65 → 0.9.67

package/lib/src/mlflow.js

@@ -25,11 +25,77 @@
  * @module
  */
 import { ConfigurationError } from "@databricks/appkit";
-import { asyncUtils, errorUtils, log, object } from "@dbx-tools/shared-core";
+import { asyncUtils, environmentUtils, errorUtils, log, object } from "@dbx-tools/shared-core";
 import { feedback } from "@dbx-tools/shared-mastra";
 import { z } from "zod";
 import { databricksFetch, readResponseJson, readResponseText } from "./rest.js";
+import { MLFLOW_AGENT_TAG_ATTR } from "./trace-attributes.js";
 const logger = log.logger("mastra/mlflow");
+let directMlflow;
+let directMlflowInitStarted = false;
+let directMlflowProvider;
+let directMlflowProcessor;
+const NOISY_INSTRUMENTATION_SCOPES = new Set([
+    "@opentelemetry/instrumentation-express",
+    "@opentelemetry/instrumentation-http",
+    "cache-manager-cache-manager",
+]);
+function isAgentTraceRoot(span) {
+    return span.attributes[MLFLOW_AGENT_TAG_ATTR] === "true";
+}
+function isUsefulAgentDescendant(span) {
+    return !NOISY_INSTRUMENTATION_SCOPES.has(span.instrumentationScope.name);
+}
+/**
+ * Restrict the direct MLflow provider to chat roots and their descendants.
+ * AppKit and Mastra create other OTel roots for cache and plugin operations;
+ * forwarding those would recreate the one-trace-per-request noise this path is
+ * intended to avoid.
+ */
+export class AgentTraceSpanProcessor {
+    delegate;
+    traceIds = new Set();
+    spanIds = new Set();
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    onStart(span, parentContext) {
+        const traceId = span.spanContext().traceId;
+        const isRoot = !span.parentSpanContext?.spanId;
+        if (isRoot) {
+            if (!isAgentTraceRoot(span))
+                return;
+            this.traceIds.add(traceId);
+        }
+        else if (!this.traceIds.has(traceId) || !isUsefulAgentDescendant(span)) {
+            return;
+        }
+        this.spanIds.add(span.spanContext().spanId);
+        this.delegate.onStart(span, parentContext);
+    }
+    onEnding(span) {
+        if (!this.spanIds.has(span.spanContext().spanId))
+            return;
+        this.delegate.onEnding?.(span);
+    }
+    onEnd(span) {
+        const traceId = span.spanContext().traceId;
+        const spanId = span.spanContext().spanId;
+        if (!this.spanIds.delete(spanId))
+            return;
+        this.delegate.onEnd(span);
+        if (!span.parentSpanContext?.spanId)
+            this.traceIds.delete(traceId);
+    }
+    forceFlush() {
+        return this.delegate.forceFlush();
+    }
+    shutdown() {
+        this.traceIds.clear();
+        this.spanIds.clear();
+        return this.delegate.shutdown();
+    }
+}
 /** Experiment tag Databricks stores as `catalog.schema.table_prefix`. */
 const TRACE_DESTINATION_PATH_TAG = "mlflow.experiment.databricksTraceDestinationPath";
 /** Experiment tag naming the OTel spans table (`catalog.schema.{prefix}_otel_spans`). */
@@ -194,20 +260,160 @@ function configuredExperiment() {
         ...(name ? { name } : {}),
     };
 }
+/** Tracking URI for direct local MLflow tracing, with CLI-profile auth injected. */
+export function directMlflowTrackingUri() {
+    if (environmentUtils.isDatabricksAppEnv())
+        return undefined;
+    const configured = process.env.MLFLOW_TRACKING_URI?.trim();
+    if (configured && configured !== "databricks")
+        return configured;
+    const profile = process.env.DATABRICKS_CONFIG_PROFILE?.trim();
+    return profile ? `databricks://${profile}` : "databricks";
+}
+/** Parse the optional UC table-prefix location used by direct local tracing. */
+export function directMlflowTraceLocation() {
+    const catalogName = process.env.MLFLOW_UC_CATALOG?.trim();
+    const schemaName = process.env.MLFLOW_UC_SCHEMA?.trim();
+    const tablePrefix = process.env.MLFLOW_UC_TABLE_PREFIX?.trim();
+    if (catalogName && schemaName && tablePrefix) {
+        return { catalogName, schemaName, tablePrefix };
+    }
+    const prefix = normalizeUcPrefix(process.env.MLFLOW_UC_TRACE_PREFIX);
+    if (!prefix)
+        return undefined;
+    const parts = prefix.split(".");
+    if (parts.length !== 3)
+        return undefined;
+    const [prefixCatalog, prefixSchema, prefixTable] = parts;
+    if (!prefixCatalog || !prefixSchema || !prefixTable)
+        return undefined;
+    return {
+        catalogName: prefixCatalog,
+        schemaName: prefixSchema,
+        tablePrefix: prefixTable,
+    };
+}
+/** Whether the local direct-to-experiment MLflow SDK has enough configuration. */
+export function directMlflowTracingConfigured() {
+    return Boolean(!environmentUtils.isDatabricksAppEnv() &&
+        process.env.MLFLOW_EXPERIMENT_ID?.trim() &&
+        directMlflowTrackingUri());
+}
+async function detectedDirectMlflowTraceLocation(mlflow, trackingUri, experimentId, host) {
+    const explicit = directMlflowTraceLocation();
+    if (explicit)
+        return explicit;
+    try {
+        const authProvider = mlflow.createAuthProvider({
+            trackingUri,
+            ...(host ? { host } : {}),
+        });
+        const client = new mlflow.MlflowClient({ trackingUri, authProvider });
+        const experiment = await client.getExperiment(experimentId);
+        if (!experiment)
+            return undefined;
+        const { ucLocationFromExperimentTags } = await import("@mlflow/core/dist/core/destination");
+        const location = ucLocationFromExperimentTags(experiment.tags);
+        if (!location?.tablePrefix)
+            return undefined;
+        return {
+            catalogName: location.catalogName,
+            schemaName: location.schemaName,
+            tablePrefix: location.tablePrefix,
+        };
+    }
+    catch (err) {
+        logger.warn("direct MLflow UC trace-location detection failed", {
+            experimentId,
+            error: errorUtils.errorMessage(err),
+        });
+        return undefined;
+    }
+}
+/**
+ * Start the MLflow Node tracer for local development when AppKit has no OTLP
+ * exporter. This provider is never started in the deployed Apps path, avoiding
+ * a second global OTel provider racing AppKit's telemetry manager.
+ */
+export async function initializeDirectMlflowTracing() {
+    if (directMlflow)
+        return true;
+    if (directMlflowInitStarted || !directMlflowTracingConfigured())
+        return false;
+    directMlflowInitStarted = true;
+    const experimentId = process.env.MLFLOW_EXPERIMENT_ID.trim();
+    const trackingUri = directMlflowTrackingUri();
+    try {
+        const mlflow = await import("@mlflow/core");
+        const rawHost = process.env.DATABRICKS_HOST?.trim();
+        const host = rawHost
+            ? /^https?:\/\//i.test(rawHost)
+                ? rawHost
+                : `https://${rawHost}`
+            : undefined;
+        const traceLocation = await detectedDirectMlflowTraceLocation(mlflow, trackingUri, experimentId, host);
+        if (!traceLocation) {
+            throw new ConfigurationError("Direct local MLflow tracing requires a UC-linked experiment or MLFLOW_UC_TRACE_PREFIX.");
+        }
+        const [{ DatabricksUCTableSpanExporter, DatabricksUCTableSpanProcessor }, sdk] = await Promise.all([
+            import("@mlflow/core/dist/exporters/uc_table"),
+            import("@opentelemetry/sdk-trace-node"),
+        ]);
+        const authProvider = mlflow.createAuthProvider({
+            trackingUri,
+            ...(host ? { host } : {}),
+        });
+        const client = new mlflow.MlflowClient({ trackingUri, authProvider });
+        const exporter = new DatabricksUCTableSpanExporter(client);
+        const processor = new AgentTraceSpanProcessor(new DatabricksUCTableSpanProcessor(exporter, traceLocation));
+        const provider = new sdk.NodeTracerProvider({ spanProcessors: [processor] });
+        provider.register();
+        directMlflow = mlflow;
+        directMlflowProvider = provider;
+        directMlflowProcessor = processor;
+        logger.info("direct MLflow tracing enabled", {
+            experimentId,
+            trackingUri,
+            traceLocation,
+        });
+        return true;
+    }
+    catch (err) {
+        logger.warn("direct MLflow tracing disabled", {
+            error: errorUtils.errorMessage(err),
+        });
+        return false;
+    }
+}
+/** Persist trace-level fields on the direct MLflow trace in the current OTel context. */
+export function updateActiveMlflowTrace(options) {
+    directMlflow?.updateCurrentTrace(options);
+}
+/** Persist tags on the direct MLflow trace active in the current OTel context. */
+export function updateActiveMlflowTraceTags(tags) {
+    updateActiveMlflowTrace({ tags });
+}
+/** Whether this process owns the filtered local MLflow tracer provider. */
+export function directMlflowTracingActive() {
+    return directMlflowProcessor !== undefined;
+}
+/** Flush pending direct local trace exports during graceful shutdown. */
+export async function flushDirectMlflowTracing() {
+    await directMlflowProcessor?.forceFlush();
+    await directMlflowProvider?.forceFlush();
+}
 /**
  * Whether MLflow feedback logging is available for this deployment.
  *
- * Enabled when an OTLP exporter endpoint is configured (traces are
- * actually shipped somewhere) AND an MLflow experiment is named - the
- * two signals that the OTLP backend is MLflow and traces will
- * materialize there. Both are standard env vars, so no plugin config is
- * required; a deployment opts in simply by wiring MLflow tracing.
+ * Enabled when an MLflow experiment is configured and traces have an export
+ * path: AppKit OTLP in a Databricks App, or the direct MLflow Node SDK outside
+ * one. Both paths are selected from standard environment values.
  */
 export function mlflowEnabled() {
     const hasExporter = Boolean(process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() ||
         process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim());
     const hasExperiment = Boolean(process.env.MLFLOW_EXPERIMENT_ID?.trim() || process.env.MLFLOW_EXPERIMENT_NAME?.trim());
-    return hasExporter && hasExperiment;
+    return hasExperiment && (hasExporter || directMlflowTracingConfigured());
 }
 /**
  * Resolve whether user feedback is enabled from the plugin's optional
@@ -360,4 +566,4 @@ export async function logFeedback(client, params) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mlflow.js","sourceRoot":"","sources":["../../src/mlflow.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MLflow user-feedback logging: detect whether MLflow tracing is wired\n * for this deployment, and log a thumbs / comment as a trace\n * *assessment* via the Databricks MLflow REST API.\n *\n * Feedback attaches to a trace, and the plugin's spans reach MLflow\n * through the same OTel pipeline as every other AppKit span (see\n * `observability.ts`). On Databricks Apps that pipeline is the UC\n * sidecar injected by `telemetry_export_destinations`, not a direct\n * workspace OTLP URL. MLflow derives its trace id from the OpenTelemetry\n * trace id (`tr-<hex(otelTraceId)>`), so the server stamps the active\n * trace id on each turn's response and the client sends it back here.\n *\n * There is no MLflow JS SDK, so this posts to the assessments REST\n * endpoint directly using the OBO-scoped workspace client (the feedback\n * is thus attributed to the signed-in user). UC-backed Apps traces need\n * the experiment's table-prefix URI (`trace:/{catalog}.{schema}.{prefix}/{tr-hex}`)\n * rather than the experiment-store id the UI does not store. That prefix is\n * read from the experiment's `mlflow.experiment.databricksTraceDestinationPath`\n * tag (or the spans-table tag); `MLFLOW_UC_TRACE_PREFIX` remains an optional\n * override. Trace export is asynchronous, so the just-finished trace may not\n * exist in MLflow yet when the user reacts; the log call retries briefly on\n * \"not found\" before giving up softly.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport { asyncUtils, errorUtils, log, object } from \"@dbx-tools/shared-core\";\nimport { feedback } from \"@dbx-tools/shared-mastra\";\nimport { z } from \"zod\";\nimport { databricksFetch, readResponseJson, readResponseText } from \"./rest.ts\";\n\nconst logger = log.logger(\"mastra/mlflow\");\n\n/** Workspace client carried on an AppKit execution context. */\ntype WorkspaceClient = appkit.WorkspaceClientLike;\n\n/** Experiment tag Databricks stores as `catalog.schema.table_prefix`. */\nconst TRACE_DESTINATION_PATH_TAG = \"mlflow.experiment.databricksTraceDestinationPath\";\n/** Experiment tag naming the OTel spans table (`catalog.schema.{prefix}_otel_spans`). */\nconst TRACE_SPAN_STORAGE_TABLE_TAG = \"mlflow.experiment.databricksTraceSpanStorageTable\";\n\n/**\n * Cached UC table prefix resolved from the experiment. `loaded` distinguishes\n * \"not fetched yet\" from \"fetched, experiment has no UC location\". Network\n * failures are not cached so a later thumbs click can retry.\n */\nlet loadedUcPrefix: { prefix: string | undefined } | undefined;\n\n/** Strip the `trace:/` URI wrapper and trailing slashes from a UC prefix. */\nfunction normalizeUcPrefix(raw: string | undefined): string | undefined {\n  const value = raw\n    ?.trim()\n    .replace(/^trace:\\//, \"\")\n    .replace(/\\/+$/, \"\");\n  return value || undefined;\n}\n\n/**\n * Derive `catalog.schema.table_prefix` from a spans table name.\n * Databricks names the table `{prefix}_otel_spans`.\n */\nfunction prefixFromSpanTable(table: string | undefined): string | undefined {\n  const name = table?.trim();\n  if (!name) return undefined;\n  if (name.endsWith(\"_otel_spans\")) return name.slice(0, -\"_otel_spans\".length);\n  if (name.endsWith(\"_spans\")) return name.slice(0, -\"_spans\".length);\n  return undefined;\n}\n\nfunction experimentTagMap(raw: unknown): Map<string, string> {\n  const tags = new Map<string, string>();\n  if (Array.isArray(raw)) {\n    for (const tag of raw) {\n      if (!object.isRecord(tag) || typeof tag.key !== \"string\" || typeof tag.value !== \"string\") {\n        continue;\n      }\n      tags.set(tag.key, tag.value);\n    }\n    return tags;\n  }\n  if (!object.isRecord(raw)) return tags;\n  for (const [key, value] of Object.entries(raw)) {\n    if (typeof value === \"string\") tags.set(key, value);\n  }\n  return tags;\n}\n\n/**\n * UC table prefix the assessments API needs, read from experiment tags.\n *\n * Prefers the three-part destination path Databricks writes when the\n * experiment is linked to a table-prefix location. Falls back to stripping\n * `_otel_spans` from the spans-table tag. Two-part schema-linked destinations\n * are ignored (they are not a table prefix).\n */\nexport function ucTracePrefixFromExperimentTags(rawTags: unknown): string | undefined {\n  const tags = experimentTagMap(rawTags);\n  const destination = normalizeUcPrefix(tags.get(TRACE_DESTINATION_PATH_TAG));\n  if (destination && destination.split(\".\").length >= 3) return destination;\n  return prefixFromSpanTable(tags.get(TRACE_SPAN_STORAGE_TABLE_TAG));\n}\n\n/** Drop the in-process UC prefix cache (tests). */\nexport function resetUcTracePrefixCache(): void {\n  loadedUcPrefix = undefined;\n}\n\n/**\n * Trace id the assessments REST API accepts for this deployment.\n *\n * Databricks Apps persist traces in Unity Catalog. The experiment UI lists\n * those rows, but `POST /api/3.0/mlflow/traces/{id}/assessments` looks up the\n * experiment store unless `{id}` is the UC URI `trace:/{catalog}.{schema}.{prefix}/{tr-hex}`.\n * A bare `tr-<hex>` 404s and the assessment never appears.\n */\nexport function mlflowAssessmentTraceId(traceId: string, prefix?: string): string {\n  const resolved = normalizeUcPrefix(prefix);\n  return resolved ? `trace:/${resolved}/${traceId}` : traceId;\n}\n\nasync function resolveUcTracePrefix(client: WorkspaceClient): Promise<string | undefined> {\n  const fromEnv = normalizeUcPrefix(process.env.MLFLOW_UC_TRACE_PREFIX);\n  if (fromEnv) return fromEnv;\n  if (loadedUcPrefix) return loadedUcPrefix.prefix;\n  const experiment = await fetchExperiment(client);\n  if (!experiment) return undefined;\n  const prefix = ucTracePrefixFromExperimentTags(experiment.tags);\n  loadedUcPrefix = { prefix };\n  return prefix;\n}\n\n/** Assessments REST path for a trace. `3.0` is the current MLflow API version. */\nconst assessmentsPath = (traceId: string): string =>\n  `/api/3.0/mlflow/traces/${encodeURIComponent(traceId)}/assessments`;\n\n/** Number of times to retry a \"trace not found\" response before giving up. */\nconst NOT_FOUND_RETRIES = 3;\n/** Base backoff between \"trace not found\" retries, in ms (grows linearly). */\nconst NOT_FOUND_BACKOFF_MS = 1200;\n\nconst MlflowExperimentResponseSchema = z\n  .object({\n    experiment: z\n      .object({\n        experiment_id: z.string().min(1).describe(\"Workspace MLflow experiment identifier.\"),\n        tags: z.unknown().optional().describe(\"Experiment tags, including the UC trace location.\"),\n      })\n      .passthrough()\n      .describe(\"Configured MLflow experiment.\"),\n  })\n  .passthrough()\n  .describe(\"MLflow get-experiment response.\");\n\nconst CurrentUserResponseSchema = z\n  .object({\n    userName: z.string().optional().describe(\"Current workspace user name.\"),\n    applicationId: z.string().optional().describe(\"Current service principal application id.\"),\n    displayName: z.string().optional().describe(\"Current principal display name.\"),\n    groups: z\n      .array(\n        z\n          .object({\n            value: z.string().optional().describe(\"Workspace group identifier.\"),\n            display: z.string().optional().describe(\"Workspace group display name.\"),\n          })\n          .passthrough(),\n      )\n      .optional()\n      .describe(\"Groups assigned to the current principal.\"),\n  })\n  .passthrough()\n  .describe(\"Databricks Current User API response.\");\n\nconst ExperimentPermissionsResponseSchema = z\n  .object({\n    access_control_list: z\n      .array(\n        z\n          .object({\n            user_name: z.string().optional().describe(\"User principal name.\"),\n            group_name: z.string().optional().describe(\"Group principal name.\"),\n            service_principal_name: z\n              .string()\n              .optional()\n              .describe(\"Service principal application id.\"),\n            all_permissions: z\n              .array(\n                z\n                  .object({\n                    permission_level: z.string().describe(\"Effective experiment permission level.\"),\n                  })\n                  .passthrough(),\n              )\n              .optional()\n              .describe(\"Direct and inherited permissions for this principal.\"),\n          })\n          .passthrough(),\n      )\n      .optional()\n      .describe(\"Experiment access control entries.\"),\n  })\n  .passthrough()\n  .describe(\"Databricks experiment permissions response.\");\n\nfunction configuredExperiment(): { id?: string; name?: string } {\n  const id = process.env.MLFLOW_EXPERIMENT_ID?.trim();\n  const name = process.env.MLFLOW_EXPERIMENT_NAME?.trim();\n  return {\n    ...(id ? { id } : {}),\n    ...(name ? { name } : {}),\n  };\n}\n\n/**\n * Whether MLflow feedback logging is available for this deployment.\n *\n * Enabled when an OTLP exporter endpoint is configured (traces are\n * actually shipped somewhere) AND an MLflow experiment is named - the\n * two signals that the OTLP backend is MLflow and traces will\n * materialize there. Both are standard env vars, so no plugin config is\n * required; a deployment opts in simply by wiring MLflow tracing.\n */\nexport function mlflowEnabled(): boolean {\n  const hasExporter = Boolean(\n    process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() ||\n    process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim(),\n  );\n  const hasExperiment = Boolean(\n    process.env.MLFLOW_EXPERIMENT_ID?.trim() || process.env.MLFLOW_EXPERIMENT_NAME?.trim(),\n  );\n  return hasExporter && hasExperiment;\n}\n\n/**\n * Resolve whether user feedback is enabled from the plugin's optional\n * `config.feedback` override: the explicit boolean wins, otherwise fall\n * back to auto-detecting MLflow tracing ({@link mlflowEnabled}). Shared\n * by the plugin's client-config gate and the server's trace-id header so\n * the two never disagree.\n */\nexport function resolveFeedbackEnabled(explicit: boolean | undefined): boolean {\n  return explicit ?? mlflowEnabled();\n}\n\n/**\n * Reject an explicitly enabled feedback surface when no MLflow experiment is\n * configured. Auto mode remains non-fatal and simply disables feedback.\n */\nexport function validateFeedbackConfig(explicit: boolean | undefined): void {\n  if (explicit !== true) return;\n  const experiment = configuredExperiment();\n  if (experiment.id || experiment.name) return;\n  throw new ConfigurationError(\n    \"mastra: feedback is enabled but no MLflow experiment is configured. \" +\n      \"Set MLFLOW_EXPERIMENT_ID or MLFLOW_EXPERIMENT_NAME, use feedback: false, \" +\n      \"or omit feedback to use automatic detection.\",\n  );\n}\n\n/**\n * Return the configured experiment URL only when the active Databricks\n * principal has effective `CAN_MANAGE` permission. Permission lookup is\n * intentionally best-effort so Apps environments that do not expose the\n * required APIs simply omit the debug affordance.\n */\nexport async function mlflowExperimentManagerUrl(\n  client: WorkspaceClient,\n): Promise<string | undefined> {\n  try {\n    return await resolveMlflowExperimentManagerUrl(client);\n  } catch {\n    return undefined;\n  }\n}\n\nasync function resolveMlflowExperimentManagerUrl(\n  client: WorkspaceClient,\n): Promise<string | undefined> {\n  const experimentId = await resolveExperimentId(client);\n  if (!experimentId) return undefined;\n\n  const [currentResponse, permissionsResponse] = await Promise.all([\n    databricksFetch(client, \"/api/2.0/preview/scim/v2/Me\", { method: \"GET\" }),\n    databricksFetch(\n      client,\n      `/api/2.0/permissions/experiments/${encodeURIComponent(experimentId)}`,\n      { method: \"GET\" },\n    ),\n  ]);\n  if (!currentResponse.ok || !permissionsResponse.ok) return undefined;\n\n  const current = CurrentUserResponseSchema.safeParse(await readResponseJson(currentResponse));\n  const permissions = ExperimentPermissionsResponseSchema.safeParse(\n    await readResponseJson(permissionsResponse),\n  );\n  if (!current.success || !permissions.success) return undefined;\n\n  const userNames = new Set(\n    [current.data.userName, current.data.applicationId, current.data.displayName].filter(\n      (value): value is string => Boolean(value),\n    ),\n  );\n  const groupNames = new Set(\n    (current.data.groups ?? []).flatMap(({ value, display }) =>\n      [value, display].filter((entry): entry is string => Boolean(entry)),\n    ),\n  );\n  const canManage = (permissions.data.access_control_list ?? []).some((entry) => {\n    const matches =\n      (entry.user_name !== undefined && userNames.has(entry.user_name)) ||\n      (entry.service_principal_name !== undefined && userNames.has(entry.service_principal_name)) ||\n      (entry.group_name !== undefined && groupNames.has(entry.group_name));\n    return (\n      matches &&\n      (entry.all_permissions ?? []).some(\n        (permission) => permission.permission_level === \"CAN_MANAGE\",\n      )\n    );\n  });\n  if (!canManage) return undefined;\n\n  const host = (await client.config.getHost()).toString();\n  return new URL(`/ml/experiments/${encodeURIComponent(experimentId)}`, host).toString();\n}\n\nasync function fetchExperiment(\n  client: WorkspaceClient,\n): Promise<{ experiment_id: string; tags?: unknown } | undefined> {\n  const experiment = configuredExperiment();\n  const path = experiment.id\n    ? `/api/2.0/mlflow/experiments/get?experiment_id=${encodeURIComponent(experiment.id)}`\n    : experiment.name\n      ? `/api/2.0/mlflow/experiments/get-by-name?experiment_name=${encodeURIComponent(\n          experiment.name,\n        )}`\n      : undefined;\n  if (!path) return undefined;\n  const response = await databricksFetch(client, path, { method: \"GET\" });\n  if (!response.ok) return undefined;\n  const parsed = MlflowExperimentResponseSchema.safeParse(await readResponseJson(response));\n  return parsed.success ? parsed.data.experiment : undefined;\n}\n\nasync function resolveExperimentId(client: WorkspaceClient): Promise<string | undefined> {\n  const configured = configuredExperiment();\n  if (configured.id) return configured.id;\n  return (await fetchExperiment(client))?.experiment_id;\n}\n\n/** Parameters for {@link logFeedback}. */\nexport interface LogFeedbackParams {\n  /** MLflow trace id the assessment attaches to (`tr-<hex>`). */\n  traceId: string;\n  /** Assessment name; defaults per whether a value or a comment is sent. */\n  name?: string;\n  /** Thumbs / rating / label value. Omit for a comment-only submission. */\n  value?: boolean | number | string;\n  /** Freeform comment: the rationale alongside a value, or the value itself when none. */\n  comment?: string;\n  /** Identity the feedback is attributed to (user email / id). */\n  sourceId?: string;\n}\n\n/**\n * Log a HUMAN feedback assessment to a trace. Returns the created\n * assessment id on success, or `undefined` when the trace can't be\n * found (even after retrying for export lag) or the request otherwise\n * fails - callers surface that as a soft \"not recorded\" rather than an\n * error, keeping the chat usable.\n */\nexport async function logFeedback(\n  client: WorkspaceClient,\n  params: LogFeedbackParams,\n): Promise<string | undefined> {\n  // A comment with no thumbs value is logged as text feedback; a value\n  // (with an optional comment as the rationale) is the thumbs path.\n  const hasValue = params.value !== undefined;\n  const name =\n    params.name?.trim() ||\n    (hasValue ? feedback.DEFAULT_FEEDBACK_NAME : feedback.DEFAULT_COMMENT_NAME);\n  const value = hasValue ? params.value : params.comment;\n  const assessmentTraceId = mlflowAssessmentTraceId(\n    params.traceId,\n    await resolveUcTracePrefix(client),\n  );\n  const assessment: Record<string, unknown> = {\n    trace_id: assessmentTraceId,\n    assessment_name: name,\n    source: {\n      source_type: \"HUMAN\",\n      source_id: params.sourceId?.trim() || \"user\",\n    },\n    feedback: { value },\n    ...(hasValue && params.comment?.trim() ? { rationale: params.comment } : {}),\n  };\n  const body = { assessment };\n\n  for (let attempt = 0; attempt <= NOT_FOUND_RETRIES; attempt++) {\n    let res: Response;\n    try {\n      res = await databricksFetch(client, assessmentsPath(assessmentTraceId), {\n        method: \"POST\",\n        body,\n      });\n    } catch (err) {\n      logger.warn(\"feedback request failed\", {\n        traceId: params.traceId,\n        assessmentTraceId,\n        error: errorUtils.errorMessage(err),\n      });\n      return undefined;\n    }\n    if (res.ok) {\n      const parsed = await readResponseJson(res);\n      const assessmentId =\n        (parsed as { assessment?: { assessment_id?: unknown } })?.assessment?.assessment_id ??\n        (parsed as { assessment_id?: unknown })?.assessment_id;\n      return typeof assessmentId === \"string\" ? assessmentId : \"\";\n    }\n    // Trace export is async; a fresh trace may not exist yet. Retry a\n    // few times with a short backoff before giving up softly.\n    if (res.status === 404 && attempt < NOT_FOUND_RETRIES) {\n      await asyncUtils.sleep(NOT_FOUND_BACKOFF_MS * (attempt + 1));\n      continue;\n    }\n    logger.warn(\"feedback not recorded\", {\n      traceId: params.traceId,\n      assessmentTraceId,\n      status: res.status,\n      body: await readResponseText(res),\n    });\n    return undefined;\n  }\n  return undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mlflow.js","sourceRoot":"","sources":["../../src/mlflow.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MLflow user-feedback logging: detect whether MLflow tracing is wired\n * for this deployment, and log a thumbs / comment as a trace\n * *assessment* via the Databricks MLflow REST API.\n *\n * Feedback attaches to a trace, and the plugin's spans reach MLflow\n * through the same OTel pipeline as every other AppKit span (see\n * `observability.ts`). On Databricks Apps that pipeline is the UC\n * sidecar injected by `telemetry_export_destinations`, not a direct\n * workspace OTLP URL. MLflow derives its trace id from the OpenTelemetry\n * trace id (`tr-<hex(otelTraceId)>`), so the server stamps the active\n * trace id on each turn's response and the client sends it back here.\n *\n * There is no MLflow JS SDK, so this posts to the assessments REST\n * endpoint directly using the OBO-scoped workspace client (the feedback\n * is thus attributed to the signed-in user). UC-backed Apps traces need\n * the experiment's table-prefix URI (`trace:/{catalog}.{schema}.{prefix}/{tr-hex}`)\n * rather than the experiment-store id the UI does not store. That prefix is\n * read from the experiment's `mlflow.experiment.databricksTraceDestinationPath`\n * tag (or the spans-table tag); `MLFLOW_UC_TRACE_PREFIX` remains an optional\n * override. Trace export is asynchronous, so the just-finished trace may not\n * exist in MLflow yet when the user reacts; the log call retries briefly on\n * \"not found\" before giving up softly.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport { asyncUtils, environmentUtils, errorUtils, log, object } from \"@dbx-tools/shared-core\";\nimport { feedback } from \"@dbx-tools/shared-mastra\";\nimport type { Context } from \"@opentelemetry/api\";\nimport type {\n  ReadableSpan,\n  Span as SdkSpan,\n  SpanProcessor,\n} from \"@opentelemetry/sdk-trace-base\";\nimport type { NodeTracerProvider } from \"@opentelemetry/sdk-trace-node\";\nimport { z } from \"zod\";\nimport { databricksFetch, readResponseJson, readResponseText } from \"./rest.ts\";\nimport { MLFLOW_AGENT_TAG_ATTR } from \"./trace-attributes.ts\";\n\nconst logger = log.logger(\"mastra/mlflow\");\n\ntype MlflowModule = typeof import(\"@mlflow/core\");\ntype UpdateCurrentTraceOptions = Parameters<MlflowModule[\"updateCurrentTrace\"]>[0];\n\nlet directMlflow: MlflowModule | undefined;\nlet directMlflowInitStarted = false;\nlet directMlflowProvider: NodeTracerProvider | undefined;\nlet directMlflowProcessor: SpanProcessor | undefined;\n\nconst NOISY_INSTRUMENTATION_SCOPES = new Set([\n  \"@opentelemetry/instrumentation-express\",\n  \"@opentelemetry/instrumentation-http\",\n  \"cache-manager-cache-manager\",\n]);\n\nfunction isAgentTraceRoot(span: SdkSpan): boolean {\n  return span.attributes[MLFLOW_AGENT_TAG_ATTR] === \"true\";\n}\n\nfunction isUsefulAgentDescendant(span: SdkSpan): boolean {\n  return !NOISY_INSTRUMENTATION_SCOPES.has(span.instrumentationScope.name);\n}\n\n/**\n * Restrict the direct MLflow provider to chat roots and their descendants.\n * AppKit and Mastra create other OTel roots for cache and plugin operations;\n * forwarding those would recreate the one-trace-per-request noise this path is\n * intended to avoid.\n */\nexport class AgentTraceSpanProcessor implements SpanProcessor {\n  private readonly traceIds = new Set<string>();\n  private readonly spanIds = new Set<string>();\n\n  constructor(private readonly delegate: SpanProcessor) {}\n\n  onStart(span: SdkSpan, parentContext: Context): void {\n    const traceId = span.spanContext().traceId;\n    const isRoot = !span.parentSpanContext?.spanId;\n    if (isRoot) {\n      if (!isAgentTraceRoot(span)) return;\n      this.traceIds.add(traceId);\n    } else if (!this.traceIds.has(traceId) || !isUsefulAgentDescendant(span)) {\n      return;\n    }\n    this.spanIds.add(span.spanContext().spanId);\n    this.delegate.onStart(span, parentContext);\n  }\n\n  onEnding(span: SdkSpan): void {\n    if (!this.spanIds.has(span.spanContext().spanId)) return;\n    this.delegate.onEnding?.(span);\n  }\n\n  onEnd(span: ReadableSpan): void {\n    const traceId = span.spanContext().traceId;\n    const spanId = span.spanContext().spanId;\n    if (!this.spanIds.delete(spanId)) return;\n    this.delegate.onEnd(span);\n    if (!span.parentSpanContext?.spanId) this.traceIds.delete(traceId);\n  }\n\n  forceFlush(): Promise<void> {\n    return this.delegate.forceFlush();\n  }\n\n  shutdown(): Promise<void> {\n    this.traceIds.clear();\n    this.spanIds.clear();\n    return this.delegate.shutdown();\n  }\n}\n\n/** Workspace client carried on an AppKit execution context. */\ntype WorkspaceClient = appkit.WorkspaceClientLike;\n\n/** Experiment tag Databricks stores as `catalog.schema.table_prefix`. */\nconst TRACE_DESTINATION_PATH_TAG = \"mlflow.experiment.databricksTraceDestinationPath\";\n/** Experiment tag naming the OTel spans table (`catalog.schema.{prefix}_otel_spans`). */\nconst TRACE_SPAN_STORAGE_TABLE_TAG = \"mlflow.experiment.databricksTraceSpanStorageTable\";\n\n/**\n * Cached UC table prefix resolved from the experiment. `loaded` distinguishes\n * \"not fetched yet\" from \"fetched, experiment has no UC location\". Network\n * failures are not cached so a later thumbs click can retry.\n */\nlet loadedUcPrefix: { prefix: string | undefined } | undefined;\n\n/** Strip the `trace:/` URI wrapper and trailing slashes from a UC prefix. */\nfunction normalizeUcPrefix(raw: string | undefined): string | undefined {\n  const value = raw\n    ?.trim()\n    .replace(/^trace:\\//, \"\")\n    .replace(/\\/+$/, \"\");\n  return value || undefined;\n}\n\n/**\n * Derive `catalog.schema.table_prefix` from a spans table name.\n * Databricks names the table `{prefix}_otel_spans`.\n */\nfunction prefixFromSpanTable(table: string | undefined): string | undefined {\n  const name = table?.trim();\n  if (!name) return undefined;\n  if (name.endsWith(\"_otel_spans\")) return name.slice(0, -\"_otel_spans\".length);\n  if (name.endsWith(\"_spans\")) return name.slice(0, -\"_spans\".length);\n  return undefined;\n}\n\nfunction experimentTagMap(raw: unknown): Map<string, string> {\n  const tags = new Map<string, string>();\n  if (Array.isArray(raw)) {\n    for (const tag of raw) {\n      if (!object.isRecord(tag) || typeof tag.key !== \"string\" || typeof tag.value !== \"string\") {\n        continue;\n      }\n      tags.set(tag.key, tag.value);\n    }\n    return tags;\n  }\n  if (!object.isRecord(raw)) return tags;\n  for (const [key, value] of Object.entries(raw)) {\n    if (typeof value === \"string\") tags.set(key, value);\n  }\n  return tags;\n}\n\n/**\n * UC table prefix the assessments API needs, read from experiment tags.\n *\n * Prefers the three-part destination path Databricks writes when the\n * experiment is linked to a table-prefix location. Falls back to stripping\n * `_otel_spans` from the spans-table tag. Two-part schema-linked destinations\n * are ignored (they are not a table prefix).\n */\nexport function ucTracePrefixFromExperimentTags(rawTags: unknown): string | undefined {\n  const tags = experimentTagMap(rawTags);\n  const destination = normalizeUcPrefix(tags.get(TRACE_DESTINATION_PATH_TAG));\n  if (destination && destination.split(\".\").length >= 3) return destination;\n  return prefixFromSpanTable(tags.get(TRACE_SPAN_STORAGE_TABLE_TAG));\n}\n\n/** Drop the in-process UC prefix cache (tests). */\nexport function resetUcTracePrefixCache(): void {\n  loadedUcPrefix = undefined;\n}\n\n/**\n * Trace id the assessments REST API accepts for this deployment.\n *\n * Databricks Apps persist traces in Unity Catalog. The experiment UI lists\n * those rows, but `POST /api/3.0/mlflow/traces/{id}/assessments` looks up the\n * experiment store unless `{id}` is the UC URI `trace:/{catalog}.{schema}.{prefix}/{tr-hex}`.\n * A bare `tr-<hex>` 404s and the assessment never appears.\n */\nexport function mlflowAssessmentTraceId(traceId: string, prefix?: string): string {\n  const resolved = normalizeUcPrefix(prefix);\n  return resolved ? `trace:/${resolved}/${traceId}` : traceId;\n}\n\nasync function resolveUcTracePrefix(client: WorkspaceClient): Promise<string | undefined> {\n  const fromEnv = normalizeUcPrefix(process.env.MLFLOW_UC_TRACE_PREFIX);\n  if (fromEnv) return fromEnv;\n  if (loadedUcPrefix) return loadedUcPrefix.prefix;\n  const experiment = await fetchExperiment(client);\n  if (!experiment) return undefined;\n  const prefix = ucTracePrefixFromExperimentTags(experiment.tags);\n  loadedUcPrefix = { prefix };\n  return prefix;\n}\n\n/** Assessments REST path for a trace. `3.0` is the current MLflow API version. */\nconst assessmentsPath = (traceId: string): string =>\n  `/api/3.0/mlflow/traces/${encodeURIComponent(traceId)}/assessments`;\n\n/** Number of times to retry a \"trace not found\" response before giving up. */\nconst NOT_FOUND_RETRIES = 3;\n/** Base backoff between \"trace not found\" retries, in ms (grows linearly). */\nconst NOT_FOUND_BACKOFF_MS = 1200;\n\nconst MlflowExperimentResponseSchema = z\n  .object({\n    experiment: z\n      .object({\n        experiment_id: z.string().min(1).describe(\"Workspace MLflow experiment identifier.\"),\n        tags: z.unknown().optional().describe(\"Experiment tags, including the UC trace location.\"),\n      })\n      .passthrough()\n      .describe(\"Configured MLflow experiment.\"),\n  })\n  .passthrough()\n  .describe(\"MLflow get-experiment response.\");\n\nconst CurrentUserResponseSchema = z\n  .object({\n    userName: z.string().optional().describe(\"Current workspace user name.\"),\n    applicationId: z.string().optional().describe(\"Current service principal application id.\"),\n    displayName: z.string().optional().describe(\"Current principal display name.\"),\n    groups: z\n      .array(\n        z\n          .object({\n            value: z.string().optional().describe(\"Workspace group identifier.\"),\n            display: z.string().optional().describe(\"Workspace group display name.\"),\n          })\n          .passthrough(),\n      )\n      .optional()\n      .describe(\"Groups assigned to the current principal.\"),\n  })\n  .passthrough()\n  .describe(\"Databricks Current User API response.\");\n\nconst ExperimentPermissionsResponseSchema = z\n  .object({\n    access_control_list: z\n      .array(\n        z\n          .object({\n            user_name: z.string().optional().describe(\"User principal name.\"),\n            group_name: z.string().optional().describe(\"Group principal name.\"),\n            service_principal_name: z\n              .string()\n              .optional()\n              .describe(\"Service principal application id.\"),\n            all_permissions: z\n              .array(\n                z\n                  .object({\n                    permission_level: z.string().describe(\"Effective experiment permission level.\"),\n                  })\n                  .passthrough(),\n              )\n              .optional()\n              .describe(\"Direct and inherited permissions for this principal.\"),\n          })\n          .passthrough(),\n      )\n      .optional()\n      .describe(\"Experiment access control entries.\"),\n  })\n  .passthrough()\n  .describe(\"Databricks experiment permissions response.\");\n\nfunction configuredExperiment(): { id?: string; name?: string } {\n  const id = process.env.MLFLOW_EXPERIMENT_ID?.trim();\n  const name = process.env.MLFLOW_EXPERIMENT_NAME?.trim();\n  return {\n    ...(id ? { id } : {}),\n    ...(name ? { name } : {}),\n  };\n}\n\n/** Tracking URI for direct local MLflow tracing, with CLI-profile auth injected. */\nexport function directMlflowTrackingUri(): string | undefined {\n  if (environmentUtils.isDatabricksAppEnv()) return undefined;\n  const configured = process.env.MLFLOW_TRACKING_URI?.trim();\n  if (configured && configured !== \"databricks\") return configured;\n  const profile = process.env.DATABRICKS_CONFIG_PROFILE?.trim();\n  return profile ? `databricks://${profile}` : \"databricks\";\n}\n\n/** Parse the optional UC table-prefix location used by direct local tracing. */\nexport function directMlflowTraceLocation():\n  | { catalogName: string; schemaName: string; tablePrefix: string }\n  | undefined {\n  const catalogName = process.env.MLFLOW_UC_CATALOG?.trim();\n  const schemaName = process.env.MLFLOW_UC_SCHEMA?.trim();\n  const tablePrefix = process.env.MLFLOW_UC_TABLE_PREFIX?.trim();\n  if (catalogName && schemaName && tablePrefix) {\n    return { catalogName, schemaName, tablePrefix };\n  }\n\n  const prefix = normalizeUcPrefix(process.env.MLFLOW_UC_TRACE_PREFIX);\n  if (!prefix) return undefined;\n  const parts = prefix.split(\".\");\n  if (parts.length !== 3) return undefined;\n  const [prefixCatalog, prefixSchema, prefixTable] = parts;\n  if (!prefixCatalog || !prefixSchema || !prefixTable) return undefined;\n  return {\n    catalogName: prefixCatalog,\n    schemaName: prefixSchema,\n    tablePrefix: prefixTable,\n  };\n}\n\n/** Whether the local direct-to-experiment MLflow SDK has enough configuration. */\nexport function directMlflowTracingConfigured(): boolean {\n  return Boolean(\n    !environmentUtils.isDatabricksAppEnv() &&\n      process.env.MLFLOW_EXPERIMENT_ID?.trim() &&\n      directMlflowTrackingUri(),\n  );\n}\n\nasync function detectedDirectMlflowTraceLocation(\n  mlflow: MlflowModule,\n  trackingUri: string,\n  experimentId: string,\n  host: string | undefined,\n): Promise<{ catalogName: string; schemaName: string; tablePrefix: string } | undefined> {\n  const explicit = directMlflowTraceLocation();\n  if (explicit) return explicit;\n  try {\n    const authProvider = mlflow.createAuthProvider({\n      trackingUri,\n      ...(host ? { host } : {}),\n    });\n    const client = new mlflow.MlflowClient({ trackingUri, authProvider });\n    const experiment = await client.getExperiment(experimentId);\n    if (!experiment) return undefined;\n    const { ucLocationFromExperimentTags } = await import(\"@mlflow/core/dist/core/destination\");\n    const location = ucLocationFromExperimentTags(experiment.tags);\n    if (!location?.tablePrefix) return undefined;\n    return {\n      catalogName: location.catalogName,\n      schemaName: location.schemaName,\n      tablePrefix: location.tablePrefix,\n    };\n  } catch (err) {\n    logger.warn(\"direct MLflow UC trace-location detection failed\", {\n      experimentId,\n      error: errorUtils.errorMessage(err),\n    });\n    return undefined;\n  }\n}\n\n/**\n * Start the MLflow Node tracer for local development when AppKit has no OTLP\n * exporter. This provider is never started in the deployed Apps path, avoiding\n * a second global OTel provider racing AppKit's telemetry manager.\n */\nexport async function initializeDirectMlflowTracing(): Promise<boolean> {\n  if (directMlflow) return true;\n  if (directMlflowInitStarted || !directMlflowTracingConfigured()) return false;\n  directMlflowInitStarted = true;\n\n  const experimentId = process.env.MLFLOW_EXPERIMENT_ID!.trim();\n  const trackingUri = directMlflowTrackingUri()!;\n  try {\n    const mlflow = await import(\"@mlflow/core\");\n    const rawHost = process.env.DATABRICKS_HOST?.trim();\n    const host = rawHost\n      ? /^https?:\\/\\//i.test(rawHost)\n        ? rawHost\n        : `https://${rawHost}`\n      : undefined;\n    const traceLocation = await detectedDirectMlflowTraceLocation(\n      mlflow,\n      trackingUri,\n      experimentId,\n      host,\n    );\n    if (!traceLocation) {\n      throw new ConfigurationError(\n        \"Direct local MLflow tracing requires a UC-linked experiment or MLFLOW_UC_TRACE_PREFIX.\",\n      );\n    }\n    const [{ DatabricksUCTableSpanExporter, DatabricksUCTableSpanProcessor }, sdk] =\n      await Promise.all([\n        import(\"@mlflow/core/dist/exporters/uc_table\"),\n        import(\"@opentelemetry/sdk-trace-node\"),\n      ]);\n    const authProvider = mlflow.createAuthProvider({\n      trackingUri,\n      ...(host ? { host } : {}),\n    });\n    const client = new mlflow.MlflowClient({ trackingUri, authProvider });\n    const exporter = new DatabricksUCTableSpanExporter(client);\n    const processor = new AgentTraceSpanProcessor(\n      new DatabricksUCTableSpanProcessor(exporter, traceLocation),\n    );\n    const provider = new sdk.NodeTracerProvider({ spanProcessors: [processor] });\n    provider.register();\n    directMlflow = mlflow;\n    directMlflowProvider = provider;\n    directMlflowProcessor = processor;\n    logger.info(\"direct MLflow tracing enabled\", {\n      experimentId,\n      trackingUri,\n      traceLocation,\n    });\n    return true;\n  } catch (err) {\n    logger.warn(\"direct MLflow tracing disabled\", {\n      error: errorUtils.errorMessage(err),\n    });\n    return false;\n  }\n}\n\n/** Persist trace-level fields on the direct MLflow trace in the current OTel context. */\nexport function updateActiveMlflowTrace(options: UpdateCurrentTraceOptions): void {\n  directMlflow?.updateCurrentTrace(options);\n}\n\n/** Persist tags on the direct MLflow trace active in the current OTel context. */\nexport function updateActiveMlflowTraceTags(tags: Record<string, string>): void {\n  updateActiveMlflowTrace({ tags });\n}\n\n/** Whether this process owns the filtered local MLflow tracer provider. */\nexport function directMlflowTracingActive(): boolean {\n  return directMlflowProcessor !== undefined;\n}\n\n/** Flush pending direct local trace exports during graceful shutdown. */\nexport async function flushDirectMlflowTracing(): Promise<void> {\n  await directMlflowProcessor?.forceFlush();\n  await directMlflowProvider?.forceFlush();\n}\n\n/**\n * Whether MLflow feedback logging is available for this deployment.\n *\n * Enabled when an MLflow experiment is configured and traces have an export\n * path: AppKit OTLP in a Databricks App, or the direct MLflow Node SDK outside\n * one. Both paths are selected from standard environment values.\n */\nexport function mlflowEnabled(): boolean {\n  const hasExporter = Boolean(\n    process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() ||\n    process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim(),\n  );\n  const hasExperiment = Boolean(\n    process.env.MLFLOW_EXPERIMENT_ID?.trim() || process.env.MLFLOW_EXPERIMENT_NAME?.trim(),\n  );\n  return hasExperiment && (hasExporter || directMlflowTracingConfigured());\n}\n\n/**\n * Resolve whether user feedback is enabled from the plugin's optional\n * `config.feedback` override: the explicit boolean wins, otherwise fall\n * back to auto-detecting MLflow tracing ({@link mlflowEnabled}). Shared\n * by the plugin's client-config gate and the server's trace-id header so\n * the two never disagree.\n */\nexport function resolveFeedbackEnabled(explicit: boolean | undefined): boolean {\n  return explicit ?? mlflowEnabled();\n}\n\n/**\n * Reject an explicitly enabled feedback surface when no MLflow experiment is\n * configured. Auto mode remains non-fatal and simply disables feedback.\n */\nexport function validateFeedbackConfig(explicit: boolean | undefined): void {\n  if (explicit !== true) return;\n  const experiment = configuredExperiment();\n  if (experiment.id || experiment.name) return;\n  throw new ConfigurationError(\n    \"mastra: feedback is enabled but no MLflow experiment is configured. \" +\n      \"Set MLFLOW_EXPERIMENT_ID or MLFLOW_EXPERIMENT_NAME, use feedback: false, \" +\n      \"or omit feedback to use automatic detection.\",\n  );\n}\n\n/**\n * Return the configured experiment URL only when the active Databricks\n * principal has effective `CAN_MANAGE` permission. Permission lookup is\n * intentionally best-effort so Apps environments that do not expose the\n * required APIs simply omit the debug affordance.\n */\nexport async function mlflowExperimentManagerUrl(\n  client: WorkspaceClient,\n): Promise<string | undefined> {\n  try {\n    return await resolveMlflowExperimentManagerUrl(client);\n  } catch {\n    return undefined;\n  }\n}\n\nasync function resolveMlflowExperimentManagerUrl(\n  client: WorkspaceClient,\n): Promise<string | undefined> {\n  const experimentId = await resolveExperimentId(client);\n  if (!experimentId) return undefined;\n\n  const [currentResponse, permissionsResponse] = await Promise.all([\n    databricksFetch(client, \"/api/2.0/preview/scim/v2/Me\", { method: \"GET\" }),\n    databricksFetch(\n      client,\n      `/api/2.0/permissions/experiments/${encodeURIComponent(experimentId)}`,\n      { method: \"GET\" },\n    ),\n  ]);\n  if (!currentResponse.ok || !permissionsResponse.ok) return undefined;\n\n  const current = CurrentUserResponseSchema.safeParse(await readResponseJson(currentResponse));\n  const permissions = ExperimentPermissionsResponseSchema.safeParse(\n    await readResponseJson(permissionsResponse),\n  );\n  if (!current.success || !permissions.success) return undefined;\n\n  const userNames = new Set(\n    [current.data.userName, current.data.applicationId, current.data.displayName].filter(\n      (value): value is string => Boolean(value),\n    ),\n  );\n  const groupNames = new Set(\n    (current.data.groups ?? []).flatMap(({ value, display }) =>\n      [value, display].filter((entry): entry is string => Boolean(entry)),\n    ),\n  );\n  const canManage = (permissions.data.access_control_list ?? []).some((entry) => {\n    const matches =\n      (entry.user_name !== undefined && userNames.has(entry.user_name)) ||\n      (entry.service_principal_name !== undefined && userNames.has(entry.service_principal_name)) ||\n      (entry.group_name !== undefined && groupNames.has(entry.group_name));\n    return (\n      matches &&\n      (entry.all_permissions ?? []).some(\n        (permission) => permission.permission_level === \"CAN_MANAGE\",\n      )\n    );\n  });\n  if (!canManage) return undefined;\n\n  const host = (await client.config.getHost()).toString();\n  return new URL(`/ml/experiments/${encodeURIComponent(experimentId)}`, host).toString();\n}\n\nasync function fetchExperiment(\n  client: WorkspaceClient,\n): Promise<{ experiment_id: string; tags?: unknown } | undefined> {\n  const experiment = configuredExperiment();\n  const path = experiment.id\n    ? `/api/2.0/mlflow/experiments/get?experiment_id=${encodeURIComponent(experiment.id)}`\n    : experiment.name\n      ? `/api/2.0/mlflow/experiments/get-by-name?experiment_name=${encodeURIComponent(\n          experiment.name,\n        )}`\n      : undefined;\n  if (!path) return undefined;\n  const response = await databricksFetch(client, path, { method: \"GET\" });\n  if (!response.ok) return undefined;\n  const parsed = MlflowExperimentResponseSchema.safeParse(await readResponseJson(response));\n  return parsed.success ? parsed.data.experiment : undefined;\n}\n\nasync function resolveExperimentId(client: WorkspaceClient): Promise<string | undefined> {\n  const configured = configuredExperiment();\n  if (configured.id) return configured.id;\n  return (await fetchExperiment(client))?.experiment_id;\n}\n\n/** Parameters for {@link logFeedback}. */\nexport interface LogFeedbackParams {\n  /** MLflow trace id the assessment attaches to (`tr-<hex>`). */\n  traceId: string;\n  /** Assessment name; defaults per whether a value or a comment is sent. */\n  name?: string;\n  /** Thumbs / rating / label value. Omit for a comment-only submission. */\n  value?: boolean | number | string;\n  /** Freeform comment: the rationale alongside a value, or the value itself when none. */\n  comment?: string;\n  /** Identity the feedback is attributed to (user email / id). */\n  sourceId?: string;\n}\n\n/**\n * Log a HUMAN feedback assessment to a trace. Returns the created\n * assessment id on success, or `undefined` when the trace can't be\n * found (even after retrying for export lag) or the request otherwise\n * fails - callers surface that as a soft \"not recorded\" rather than an\n * error, keeping the chat usable.\n */\nexport async function logFeedback(\n  client: WorkspaceClient,\n  params: LogFeedbackParams,\n): Promise<string | undefined> {\n  // A comment with no thumbs value is logged as text feedback; a value\n  // (with an optional comment as the rationale) is the thumbs path.\n  const hasValue = params.value !== undefined;\n  const name =\n    params.name?.trim() ||\n    (hasValue ? feedback.DEFAULT_FEEDBACK_NAME : feedback.DEFAULT_COMMENT_NAME);\n  const value = hasValue ? params.value : params.comment;\n  const assessmentTraceId = mlflowAssessmentTraceId(\n    params.traceId,\n    await resolveUcTracePrefix(client),\n  );\n  const assessment: Record<string, unknown> = {\n    trace_id: assessmentTraceId,\n    assessment_name: name,\n    source: {\n      source_type: \"HUMAN\",\n      source_id: params.sourceId?.trim() || \"user\",\n    },\n    feedback: { value },\n    ...(hasValue && params.comment?.trim() ? { rationale: params.comment } : {}),\n  };\n  const body = { assessment };\n\n  for (let attempt = 0; attempt <= NOT_FOUND_RETRIES; attempt++) {\n    let res: Response;\n    try {\n      res = await databricksFetch(client, assessmentsPath(assessmentTraceId), {\n        method: \"POST\",\n        body,\n      });\n    } catch (err) {\n      logger.warn(\"feedback request failed\", {\n        traceId: params.traceId,\n        assessmentTraceId,\n        error: errorUtils.errorMessage(err),\n      });\n      return undefined;\n    }\n    if (res.ok) {\n      const parsed = await readResponseJson(res);\n      const assessmentId =\n        (parsed as { assessment?: { assessment_id?: unknown } })?.assessment?.assessment_id ??\n        (parsed as { assessment_id?: unknown })?.assessment_id;\n      return typeof assessmentId === \"string\" ? assessmentId : \"\";\n    }\n    // Trace export is async; a fresh trace may not exist yet. Retry a\n    // few times with a short backoff before giving up softly.\n    if (res.status === 404 && attempt < NOT_FOUND_RETRIES) {\n      await asyncUtils.sleep(NOT_FOUND_BACKOFF_MS * (attempt + 1));\n      continue;\n    }\n    logger.warn(\"feedback not recorded\", {\n      traceId: params.traceId,\n      assessmentTraceId,\n      status: res.status,\n      body: await readResponseText(res),\n    });\n    return undefined;\n  }\n  return undefined;\n}\n"]}

package/lib/src/model.js

@@ -28,6 +28,7 @@ import { functionUtils, json, log, net } from "@dbx-tools/shared-core";
 import { MASTRA_USER_KEY } from "./config.js";
 import { rewriteServingRequest, rewriteServingResponseBody, rewriteServingResponseStream, } from "./serving-sanitize.js";
 import { MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from "./serving.js";
+import { recordActiveTraceAuth, recordActiveTraceModel } from "./telemetry.js";
 const { parseModelClass } = classes;
 const { selectModel } = resolve;
 /** Keep Responses turns stateless so tool continuations replay encrypted reasoning inline. */
@@ -87,6 +88,7 @@ export async function buildModel(config, requestContext, overrides = {}) {
     // (the active OBO scope, or the service principal) when it's absent.
     const user = requestContext.get(MASTRA_USER_KEY);
     const executionContext = user?.executionContext ?? getExecutionContext();
+    recordActiveTraceAuth("isUserContext" in executionContext ? "obo" : "service-principal");
     const clientConfig = executionContext.client.config;
     const host = (await clientConfig.getHost()).toString();
     const headers = new Headers();
@@ -110,6 +112,7 @@ export async function buildModel(config, requestContext, overrides = {}) {
     const requested = override ?? overrides.modelId ?? process.env.DATABRICKS_SERVING_ENDPOINT_NAME;
     const { modelId, source } = await selectModel(executionContext.client, host, selectionInput(config, requested, overrides.modelClass, serving));
     logger.debug("model selected", { modelId, source, requested });
+    recordActiveTraceModel(modelId);
     return {
         providerId: config.providerId ?? "databricks",
         modelId,
@@ -195,4 +198,4 @@ function rebuildServingResponse(response, body) {
         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, invoke, policy, resolve } from \"@dbx-tools/model\";\nimport { functionUtils, json, log, net } from \"@dbx-tools/shared-core\";\nimport { model, type ServingEndpointSummary } 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  rewriteServingRequest,\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/** Keep Responses turns stateless so tool continuations replay encrypted reasoning inline. */\nexport const RESPONSES_PROVIDER_OPTIONS = {\n  openai: {\n    store: false,\n  },\n} as const;\n\n/** Pick the native Databricks inference surface required by a resolved model. */\nexport function servingApi(modelId: string): \"chat\" | \"responses\" {\n  return policy.modelServingApi(modelId);\n}\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\nfunction selectionInput(\n  config: MastraPluginConfig,\n  requested: string | undefined,\n  defaultClass: ModelClass | undefined,\n  serving = resolveServingConfig(config),\n) {\n  const requestedClass = requested !== undefined ? parseModelClass(requested) : null;\n  const explicit = requestedClass === null ? requested : undefined;\n  const modelClass = requestedClass ?? defaultClass;\n  return {\n    ...(explicit !== undefined ? { explicit } : {}),\n    fuzzy: serving.fuzzy,\n    threshold: serving.threshold,\n    ...(modelClass !== undefined ? { modelClass } : {}),\n    fallbacks: serving.fallbacks.slice(),\n    liveOnly: requested === undefined,\n    ttlMs: serving.ttlMs,\n  };\n}\n\n/**\n * Resolve an agent's unpinned default against an already-loaded live catalogue.\n *\n * With no configured id/class/fallback, the generic model ranker selects the\n * highest-ranked currently available GPT, then falls back to the highest-ranked\n * live chat endpoint when the workspace has no GPT.\n */\nexport function resolveDefaultModelId(\n  config: MastraPluginConfig,\n  endpoints: readonly ServingEndpointSummary[],\n  overrides: BuildModelOverrides = {},\n): string {\n  const requested = overrides.modelId ?? process.env.DATABRICKS_SERVING_ENDPOINT_NAME;\n  return resolve.resolveModel(endpoints, selectionInput(config, requested, overrides.modelClass))\n    .modelId;\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\n  const { modelId, source } = await selectModel(\n    executionContext.client,\n    host,\n    selectionInput(config, requested, overrides.modelClass, serving),\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    api: servingApi(modelId),\n  };\n}\n\n/** Chat Completions route whose provider-specific wire shapes are normalized here. */\nconst CHAT_COMPLETIONS_PATH = `/${invoke.CHAT_COMPLETIONS_PATH}`;\n\n/**\n * Install a single shared `globalThis.fetch` wrapper for Chat Completions\n * requests. The wrapper does three things:\n *\n *   1. Rewrites outgoing JSON from either `init.body` or a `Request` to repair\n *      provider-specific request constraints (see {@link rewriteServingRequest}\n *      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 functionUtils.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 = functionUtils.memoize((): void => {\n  globalThis.fetch = createServingFetchInterceptor(globalThis.fetch.bind(globalThis));\n});\n\n/** Build the serving fetch wrapper; exported for transport-level regression tests. */\nexport function createServingFetchInterceptor(original: typeof fetch): typeof fetch {\n  const logger = log.logger(\"mastra/llm\");\n  return (async (input, init) => {\n    const url = net.urlBuilder(input);\n    const method = init?.method ?? (input instanceof Request ? input.method : \"GET\");\n    if (!url || url.pathname !== CHAT_COMPLETIONS_PATH || method.toUpperCase() !== \"POST\") {\n      return original(input, init);\n    }\n    const rewritten = await rewriteServingRequest(input, init);\n    const parsed = json.parse<unknown>(rewritten.body);\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(rewritten.input, rewritten.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"]}
+//# 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,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAKvE,OAAO,EAAE,eAAe,EAAsC,MAAM,aAAa,CAAC;AAClF,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAG/E,MAAM,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;AACpC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;AAEhC,8FAA8F;AAC9F,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,MAAM,EAAE;QACN,KAAK,EAAE,KAAK;KACb;CACO,CAAC;AAEX,iFAAiF;AACjF,MAAM,UAAU,UAAU,CAAC,OAAe;IACxC,OAAO,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;AACzC,CAAC;AAqBD,SAAS,cAAc,CACrB,MAA0B,EAC1B,SAA6B,EAC7B,YAAoC,EACpC,OAAO,GAAG,oBAAoB,CAAC,MAAM,CAAC;IAEtC,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,YAAY,CAAC;IAClD,OAAO;QACL,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,CAAC,KAAK,EAAE;QACpC,QAAQ,EAAE,SAAS,KAAK,SAAS;QACjC,KAAK,EAAE,OAAO,CAAC,KAAK;KACrB,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAA0B,EAC1B,SAA4C,EAC5C,YAAiC,EAAE;IAEnC,MAAM,SAAS,GAAG,SAAS,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC;IACpF,OAAO,OAAO,CAAC,YAAY,CAAC,SAAS,EAAE,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;SAC5F,OAAO,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;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,qBAAqB,CAAC,eAAe,IAAI,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IACzF,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;IAEhG,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,WAAW,CAC3C,gBAAgB,CAAC,MAAM,EACvB,IAAI,EACJ,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,CACjE,CAAC;IACF,MAAM,CAAC,KAAK,CAAC,gBAAgB,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAC/D,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAEhC,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;QAC9C,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC;KACzB,CAAC;AACJ,CAAC;AAED,sFAAsF;AACtF,MAAM,qBAAqB,GAAG,IAAI,MAAM,CAAC,qBAAqB,EAAE,CAAC;AAEjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,CAAC,GAAS,EAAE;IAC7D,UAAU,CAAC,KAAK,GAAG,6BAA6B,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;AACtF,CAAC,CAAC,CAAC;AAEH,sFAAsF;AACtF,MAAM,UAAU,6BAA6B,CAAC,QAAsB;IAClE,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IACxC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAC5B,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,IAAI,EAAE,MAAM,IAAI,CAAC,KAAK,YAAY,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACjF,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,KAAK,qBAAqB,IAAI,MAAM,CAAC,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;YACtF,OAAO,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC/B,CAAC;QACD,MAAM,SAAS,GAAG,MAAM,qBAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC3D,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAU,SAAS,CAAC,IAAI,CAAC,CAAC;QACnD,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,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QACjE,OAAO,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC,CAA4B,CAAC;AAChC,CAAC;AAED;;;;;;;;GAQG;AACH,KAAK,UAAU,qBAAqB,CAAC,QAAkB;IACrD,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;IAC/D,IAAI,WAAW,CAAC,QAAQ,CAAC,mBAAmB,CAAC,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC/D,OAAO,sBAAsB,CAAC,QAAQ,EAAE,4BAA4B,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACvF,CAAC;IACD,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;IACxC,OAAO,sBAAsB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AACrD,CAAC;AAED,iFAAiF;AACjF,SAAS,sBAAsB,CAC7B,QAAkB,EAClB,IAAyC;IAEzC,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,IAAI,EAAE;QACxB,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, invoke, policy, resolve } from \"@dbx-tools/model\";\nimport { functionUtils, json, log, net } from \"@dbx-tools/shared-core\";\nimport { model, type ServingEndpointSummary } 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  rewriteServingRequest,\n  rewriteServingResponseBody,\n  rewriteServingResponseStream,\n} from \"./serving-sanitize.ts\";\nimport { MASTRA_MODEL_OVERRIDE_KEY, resolveServingConfig } from \"./serving.ts\";\nimport { recordActiveTraceAuth, recordActiveTraceModel } from \"./telemetry.ts\";\n\ntype ModelClass = model.ModelClass;\nconst { parseModelClass } = classes;\nconst { selectModel } = resolve;\n\n/** Keep Responses turns stateless so tool continuations replay encrypted reasoning inline. */\nexport const RESPONSES_PROVIDER_OPTIONS = {\n  openai: {\n    store: false,\n  },\n} as const;\n\n/** Pick the native Databricks inference surface required by a resolved model. */\nexport function servingApi(modelId: string): \"chat\" | \"responses\" {\n  return policy.modelServingApi(modelId);\n}\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\nfunction selectionInput(\n  config: MastraPluginConfig,\n  requested: string | undefined,\n  defaultClass: ModelClass | undefined,\n  serving = resolveServingConfig(config),\n) {\n  const requestedClass = requested !== undefined ? parseModelClass(requested) : null;\n  const explicit = requestedClass === null ? requested : undefined;\n  const modelClass = requestedClass ?? defaultClass;\n  return {\n    ...(explicit !== undefined ? { explicit } : {}),\n    fuzzy: serving.fuzzy,\n    threshold: serving.threshold,\n    ...(modelClass !== undefined ? { modelClass } : {}),\n    fallbacks: serving.fallbacks.slice(),\n    liveOnly: requested === undefined,\n    ttlMs: serving.ttlMs,\n  };\n}\n\n/**\n * Resolve an agent's unpinned default against an already-loaded live catalogue.\n *\n * With no configured id/class/fallback, the generic model ranker selects the\n * highest-ranked currently available GPT, then falls back to the highest-ranked\n * live chat endpoint when the workspace has no GPT.\n */\nexport function resolveDefaultModelId(\n  config: MastraPluginConfig,\n  endpoints: readonly ServingEndpointSummary[],\n  overrides: BuildModelOverrides = {},\n): string {\n  const requested = overrides.modelId ?? process.env.DATABRICKS_SERVING_ENDPOINT_NAME;\n  return resolve.resolveModel(endpoints, selectionInput(config, requested, overrides.modelClass))\n    .modelId;\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  recordActiveTraceAuth(\"isUserContext\" in executionContext ? \"obo\" : \"service-principal\");\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\n  const { modelId, source } = await selectModel(\n    executionContext.client,\n    host,\n    selectionInput(config, requested, overrides.modelClass, serving),\n  );\n  logger.debug(\"model selected\", { modelId, source, requested });\n  recordActiveTraceModel(modelId);\n\n  return {\n    providerId: config.providerId ?? \"databricks\",\n    modelId,\n    url,\n    headers: Object.fromEntries(headers.entries()),\n    api: servingApi(modelId),\n  };\n}\n\n/** Chat Completions route whose provider-specific wire shapes are normalized here. */\nconst CHAT_COMPLETIONS_PATH = `/${invoke.CHAT_COMPLETIONS_PATH}`;\n\n/**\n * Install a single shared `globalThis.fetch` wrapper for Chat Completions\n * requests. The wrapper does three things:\n *\n *   1. Rewrites outgoing JSON from either `init.body` or a `Request` to repair\n *      provider-specific request constraints (see {@link rewriteServingRequest}\n *      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 functionUtils.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 = functionUtils.memoize((): void => {\n  globalThis.fetch = createServingFetchInterceptor(globalThis.fetch.bind(globalThis));\n});\n\n/** Build the serving fetch wrapper; exported for transport-level regression tests. */\nexport function createServingFetchInterceptor(original: typeof fetch): typeof fetch {\n  const logger = log.logger(\"mastra/llm\");\n  return (async (input, init) => {\n    const url = net.urlBuilder(input);\n    const method = init?.method ?? (input instanceof Request ? input.method : \"GET\");\n    if (!url || url.pathname !== CHAT_COMPLETIONS_PATH || method.toUpperCase() !== \"POST\") {\n      return original(input, init);\n    }\n    const rewritten = await rewriteServingRequest(input, init);\n    const parsed = json.parse<unknown>(rewritten.body);\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(rewritten.input, rewritten.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/observability.d.ts

@@ -90,7 +90,8 @@ export declare function configureOtelPropagation(): boolean;
  * 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).
+ * `enabled: false`, or auto mode finds neither AppKit OTLP nor a local MLflow
+ * experiment.
  * 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.