@dbx-tools/appkit-mastra 0.9.65 → 0.9.68

package/lib/src/mlflow.js

@@ -24,12 +24,86 @@
  *
  * @module
  */
-import { ConfigurationError } from "@databricks/appkit";
+import { ConfigurationError, createWorkspaceClient } from "@databricks/appkit";
+import { appkit } from "@dbx-tools/appkit";
 import { asyncUtils, errorUtils, log, object } from "@dbx-tools/shared-core";
 import { feedback } from "@dbx-tools/shared-mastra";
+import { TraceLocationType, TraceMetadataKey } from "@mlflow/core";
+import { TraceInfo } from "@mlflow/core/dist/core/entities/trace_info";
+import { TraceState } from "@mlflow/core/dist/core/entities/trace_state";
 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;
+let appMlflowTraceInfoInitStarted = false;
+let appMlflowTraceInfoClient;
+let appMlflowTracePrefix;
+const pendingAppMlflowTraceInfo = new Set();
+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 +268,248 @@ function configuredExperiment() {
         ...(name ? { name } : {}),
     };
 }
+/** Tracking URI for direct local MLflow tracing, with CLI-profile auth injected. */
+export function directMlflowTrackingUri() {
+    if (appkit.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(!appkit.isDatabricksAppEnv() &&
+        process.env.MLFLOW_EXPERIMENT_ID?.trim() &&
+        directMlflowTrackingUri());
+}
+/** Whether a Databricks App can promote OTLP spans into full MLflow trace info. */
+export function appMlflowTraceInfoConfigured() {
+    return Boolean(appkit.isDatabricksAppEnv() &&
+        (process.env.MLFLOW_EXPERIMENT_ID?.trim() || process.env.MLFLOW_EXPERIMENT_NAME?.trim()) &&
+        (process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() ||
+            process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim()));
+}
+/** Initialize the App service-principal client used to persist V4 trace tags and metadata. */
+export async function initializeAppMlflowTraceInfo(client) {
+    if (appMlflowTraceInfoClient && appMlflowTracePrefix)
+        return true;
+    if (appMlflowTraceInfoInitStarted || !appMlflowTraceInfoConfigured())
+        return false;
+    appMlflowTraceInfoInitStarted = true;
+    try {
+        const resolvedClient = client ?? createWorkspaceClient();
+        const prefix = await resolveUcTracePrefix(resolvedClient);
+        if (!prefix || prefix.split(".").length !== 3) {
+            throw new ConfigurationError("Databricks Apps MLflow trace-info promotion requires a UC-linked experiment or MLFLOW_UC_TRACE_PREFIX.");
+        }
+        appMlflowTraceInfoClient = resolvedClient;
+        appMlflowTracePrefix = prefix;
+        logger.info("Databricks Apps MLflow trace-info promotion enabled", { prefix });
+        return true;
+    }
+    catch (err) {
+        logger.warn("Databricks Apps MLflow trace-info promotion disabled", {
+            error: errorUtils.errorMessage(err),
+        });
+        return false;
+    }
+}
+/** Persist MLflow V4 trace info for one Databricks Apps OTel root without re-exporting spans. */
+export function persistAppMlflowTraceInfo(params) {
+    const client = appMlflowTraceInfoClient;
+    const prefix = appMlflowTracePrefix;
+    if (!client || !prefix)
+        return;
+    const [catalogName, schemaName, tablePrefix] = prefix.split(".");
+    if (!catalogName || !schemaName || !tablePrefix)
+        return;
+    const traceInfo = new TraceInfo({
+        traceId: `trace:/${prefix}/${params.traceId}`,
+        traceLocation: {
+            type: TraceLocationType.UC_TABLE_PREFIX,
+            ucTablePrefix: { catalogName, schemaName, tablePrefix },
+        },
+        requestTime: params.requestTime,
+        executionDuration: params.executionDuration,
+        state: params.error ? TraceState.ERROR : TraceState.OK,
+        ...(params.requestPreview ? { requestPreview: params.requestPreview } : {}),
+        ...(params.responsePreview ? { responsePreview: params.responsePreview } : {}),
+        traceMetadata: {
+            [TraceMetadataKey.SCHEMA_VERSION]: "4",
+            ...(params.user ? { [TraceMetadataKey.TRACE_USER]: params.user } : {}),
+            ...(params.sessionId ? { [TraceMetadataKey.TRACE_SESSION]: params.sessionId } : {}),
+        },
+        tags: params.tags,
+        assessments: [],
+    });
+    const path = `/api/4.0/mlflow/traces/${encodeURIComponent(prefix)}/${params.traceId}/info`;
+    const pending = databricksFetch(client, path, { method: "POST", body: traceInfo.toJson() })
+        .then(async (response) => {
+        if (response.ok)
+            return;
+        logger.warn("Databricks Apps MLflow trace-info promotion failed", {
+            traceId: params.traceId,
+            status: response.status,
+            body: await readResponseText(response),
+        });
+    })
+        .catch((err) => {
+        logger.warn("Databricks Apps MLflow trace-info promotion failed", {
+            traceId: params.traceId,
+            error: errorUtils.errorMessage(err),
+        });
+    })
+        .finally(() => pendingAppMlflowTraceInfo.delete(pending));
+    pendingAppMlflowTraceInfo.add(pending);
+}
+/** Reset Apps trace-info promotion state for tests. */
+export function resetAppMlflowTraceInfo() {
+    appMlflowTraceInfoInitStarted = false;
+    appMlflowTraceInfoClient = undefined;
+    appMlflowTracePrefix = undefined;
+    pendingAppMlflowTraceInfo.clear();
+}
+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 Promise.all([...pendingAppMlflowTraceInfo]);
+    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 +662,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, createWorkspaceClient } 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 { TraceLocationType, TraceMetadataKey } from \"@mlflow/core\";\nimport { TraceInfo } from \"@mlflow/core/dist/core/entities/trace_info\";\nimport { TraceState } from \"@mlflow/core/dist/core/entities/trace_state\";\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;\nlet appMlflowTraceInfoInitStarted = false;\nlet appMlflowTraceInfoClient: WorkspaceClient | undefined;\nlet appMlflowTracePrefix: string | undefined;\nconst pendingAppMlflowTraceInfo = new Set<Promise<void>>();\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 (appkit.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    !appkit.isDatabricksAppEnv() &&\n      process.env.MLFLOW_EXPERIMENT_ID?.trim() &&\n      directMlflowTrackingUri(),\n  );\n}\n\n/** Whether a Databricks App can promote OTLP spans into full MLflow trace info. */\nexport function appMlflowTraceInfoConfigured(): boolean {\n  return Boolean(\n    appkit.isDatabricksAppEnv() &&\n      (process.env.MLFLOW_EXPERIMENT_ID?.trim() || process.env.MLFLOW_EXPERIMENT_NAME?.trim()) &&\n      (process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() ||\n        process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim()),\n  );\n}\n\n/** Initialize the App service-principal client used to persist V4 trace tags and metadata. */\nexport async function initializeAppMlflowTraceInfo(\n  client?: WorkspaceClient,\n): Promise<boolean> {\n  if (appMlflowTraceInfoClient && appMlflowTracePrefix) return true;\n  if (appMlflowTraceInfoInitStarted || !appMlflowTraceInfoConfigured()) return false;\n  appMlflowTraceInfoInitStarted = true;\n  try {\n    const resolvedClient = client ?? (createWorkspaceClient() as WorkspaceClient);\n    const prefix = await resolveUcTracePrefix(resolvedClient);\n    if (!prefix || prefix.split(\".\").length !== 3) {\n      throw new ConfigurationError(\n        \"Databricks Apps MLflow trace-info promotion requires a UC-linked experiment or MLFLOW_UC_TRACE_PREFIX.\",\n      );\n    }\n    appMlflowTraceInfoClient = resolvedClient;\n    appMlflowTracePrefix = prefix;\n    logger.info(\"Databricks Apps MLflow trace-info promotion enabled\", { prefix });\n    return true;\n  } catch (err) {\n    logger.warn(\"Databricks Apps MLflow trace-info promotion disabled\", {\n      error: errorUtils.errorMessage(err),\n    });\n    return false;\n  }\n}\n\n/** Trace-level values persisted beside spans already exported by the Apps OTLP sidecar. */\nexport interface AppMlflowTraceInfo {\n  traceId: string;\n  requestTime: number;\n  executionDuration: number;\n  error: boolean;\n  tags: Record<string, string>;\n  user?: string;\n  sessionId?: string;\n  requestPreview?: string;\n  responsePreview?: string;\n}\n\n/** Persist MLflow V4 trace info for one Databricks Apps OTel root without re-exporting spans. */\nexport function persistAppMlflowTraceInfo(params: AppMlflowTraceInfo): void {\n  const client = appMlflowTraceInfoClient;\n  const prefix = appMlflowTracePrefix;\n  if (!client || !prefix) return;\n  const [catalogName, schemaName, tablePrefix] = prefix.split(\".\");\n  if (!catalogName || !schemaName || !tablePrefix) return;\n  const traceInfo = new TraceInfo({\n    traceId: `trace:/${prefix}/${params.traceId}`,\n    traceLocation: {\n      type: TraceLocationType.UC_TABLE_PREFIX,\n      ucTablePrefix: { catalogName, schemaName, tablePrefix },\n    },\n    requestTime: params.requestTime,\n    executionDuration: params.executionDuration,\n    state: params.error ? TraceState.ERROR : TraceState.OK,\n    ...(params.requestPreview ? { requestPreview: params.requestPreview } : {}),\n    ...(params.responsePreview ? { responsePreview: params.responsePreview } : {}),\n    traceMetadata: {\n      [TraceMetadataKey.SCHEMA_VERSION]: \"4\",\n      ...(params.user ? { [TraceMetadataKey.TRACE_USER]: params.user } : {}),\n      ...(params.sessionId ? { [TraceMetadataKey.TRACE_SESSION]: params.sessionId } : {}),\n    },\n    tags: params.tags,\n    assessments: [],\n  });\n  const path = `/api/4.0/mlflow/traces/${encodeURIComponent(prefix)}/${params.traceId}/info`;\n  const pending = databricksFetch(client, path, { method: \"POST\", body: traceInfo.toJson() })\n    .then(async (response) => {\n      if (response.ok) return;\n      logger.warn(\"Databricks Apps MLflow trace-info promotion failed\", {\n        traceId: params.traceId,\n        status: response.status,\n        body: await readResponseText(response),\n      });\n    })\n    .catch((err) => {\n      logger.warn(\"Databricks Apps MLflow trace-info promotion failed\", {\n        traceId: params.traceId,\n        error: errorUtils.errorMessage(err),\n      });\n    })\n    .finally(() => pendingAppMlflowTraceInfo.delete(pending));\n  pendingAppMlflowTraceInfo.add(pending);\n}\n\n/** Reset Apps trace-info promotion state for tests. */\nexport function resetAppMlflowTraceInfo(): void {\n  appMlflowTraceInfoInitStarted = false;\n  appMlflowTraceInfoClient = undefined;\n  appMlflowTracePrefix = undefined;\n  pendingAppMlflowTraceInfo.clear();\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 Promise.all([...pendingAppMlflowTraceInfo]);\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"]}