@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/memory.js

@@ -0,0 +1,275 @@
+/**
+ * Lakebase-backed Mastra memory wiring.
+ *
+ * Provides a {@link MemoryBuilder} that mints one `Memory` per agent
+ * with two independent knobs:
+ *
+ * - **Storage** (threads / messages via `PostgresStore`): defaults to
+ *   **per-agent** namespacing via {@link agentStorageSchemaName} so
+ *   conversation history stays isolated between agents in the same
+ *   database. `PostgresStore` auto-creates the schema with
+ *   `CREATE SCHEMA IF NOT EXISTS` on init.
+ * - **Memory** (semantic recall via `PgVector`): defaults to a single
+ *   **shared** instance across every agent. Cross-agent recall on one
+ *   index is almost always what users want; opt into per-agent recall
+ *   by passing a {@link MastraMemoryConfigOverride} on the agent.
+ *
+ * Additionally, {@link MemoryBuilder.instanceStorage} returns a
+ * **Mastra-instance-level** `PostgresStore` (schema `mastra_instance`)
+ * used for workflow snapshots - the persistence layer
+ * `agent.resumeStream()` reads from when waking a suspended
+ * `requireApproval` tool call. Per-agent stores are not enough for
+ * this: workflow runs are scoped to the Mastra instance, not an
+ * individual agent's `Memory`.
+ *
+ * Plugin-level `config.storage` / `config.memory` act as the baseline
+ * (auto-defaulted to `true` in `plugin.ts` when the `lakebase` plugin
+ * is registered); per-agent settings cascade on top of that.
+ *
+ * @module
+ */
+import { getUsernameWithApiLookup } from "@databricks/appkit";
+import { hash, log } from "@dbx-tools/shared-core";
+import { fastembed } from "@mastra/fastembed";
+import { Memory } from "@mastra/memory";
+import { PgVector, PostgresStore } from "@mastra/pg";
+import { Pool } from "pg";
+import { agentStorageSchemaName } from "./storage-schema.js";
+import { summaryModel, TITLE_INSTRUCTIONS } from "./summarize.js";
+const logger = log.logger("mastra/memory");
+/**
+ * Build a dedicated **service-principal** Lakebase pool for Mastra
+ * memory from the lakebase plugin's resolved SP pg config.
+ *
+ * The plugin's `exports().pool` is a `RoutingPool` that switches to
+ * the per-user (OBO) pool whenever a query runs inside an `asUser`
+ * scope - exactly the context the mastra plugin establishes around
+ * every chat turn. Memory (threads / messages + semantic recall) must
+ * instead always act as the app service principal: it owns the
+ * auto-created `mastra_*` schemas (a per-user role usually can't
+ * `CREATE SCHEMA`) and is shared across users, so it cannot inherit a
+ * request's OBO identity.
+ *
+ * `pgConfig` must be the plugin's `exports().getPgConfig()` evaluated
+ * **outside** any `asUser` scope (i.e. during setup), so it carries
+ * the SP connection target, OAuth token-refresh `password` callback,
+ * and any `lakebase({ pool })` tuning overrides - all of which this
+ * pool inherits. See the call site in `plugin.ts`.
+ */
+export async function createServicePrincipalPool(pgConfig) {
+    // `getPgConfig()` resolves the SP username synchronously from
+    // `PGUSER` / `DATABRICKS_CLIENT_ID`; fall back to the async API
+    // lookup (e.g. local dev authenticating via PAT) so the pool always
+    // has an identity to connect with.
+    const user = pgConfig.user ?? (await getUsernameWithApiLookup());
+    return new Pool({ ...pgConfig, user });
+}
+/**
+ * True when any plugin-level or per-agent setting could need the
+ * Lakebase pool. Used by `plugin.ts` to gate creation of the
+ * service-principal pool and the {@link MemoryBuilder} that consumes
+ * it; when false neither is built.
+ */
+export function needsLakebase(config) {
+    if (settingNeedsSharedPool(config.storage))
+        return true;
+    if (settingNeedsSharedPool(config.memory))
+        return true;
+    const defs = collectAgentDefinitions(config);
+    return defs.some((d) => settingNeedsSharedPool(d.storage) || settingNeedsSharedPool(d.memory));
+}
+/**
+ * Construct a per-agent {@link Memory} factory bound to the supplied
+ * service-principal pool (see {@link createServicePrincipalPool}).
+ * Caches the shared `PgVector` singleton (built on first need) so each
+ * agent build is O(1) after the first.
+ */
+export function createMemoryBuilder(config, servicePrincipalPool) {
+    return new MemoryBuilder(config, servicePrincipalPool);
+}
+/**
+ * Builds one `Memory` per agent against a shared service-principal
+ * Lakebase pool. Per-instance state keeps the shared `PgVector` alive
+ * across calls so registering N agents stays cheap.
+ */
+export class MemoryBuilder {
+    config;
+    servicePrincipalPool;
+    sharedVector;
+    constructor(config, servicePrincipalPool) {
+        this.config = config;
+        this.servicePrincipalPool = servicePrincipalPool;
+    }
+    /**
+     * Build the Mastra-instance-level storage used for workflow
+     * snapshots. Returns `undefined` when plugin-level `storage` is
+     * disabled, in which case `agent.resumeStream()` (and therefore
+     * the `requireApproval` flow) will not be available.
+     *
+     * The store lives in a dedicated `mastra_instance` schema so it
+     * never collides with per-agent {@link agentStorageSchemaName} namespaces.
+     * Workflow snapshots are not per-agent state; they belong to the
+     * `Mastra` instance that owns the workflow execution.
+     */
+    instanceStorage() {
+        const setting = this.config.storage;
+        if (!setting)
+            return undefined;
+        if (typeof setting === "object") {
+            return new PostgresStore(withId(setting, "mastra-store__instance"));
+        }
+        return new PostgresStore({
+            id: "mastra-store__instance",
+            schemaName: "mastra_instance",
+            pool: this.servicePrincipalPool,
+        });
+    }
+    /**
+     * Build a `Memory` for `agentId` after the plugin/agent cascade.
+     * Returns `undefined` when the agent has neither storage nor a
+     * vector store enabled - Mastra accepts a missing `memory` field
+     * and treats the agent as stateless.
+     */
+    forAgent(agentId, def) {
+        const storageSetting = def.storage ?? this.config.storage;
+        const memorySetting = def.memory ?? this.config.memory;
+        const storage = this.buildStorage(agentId, storageSetting);
+        const vector = this.buildVector(memorySetting);
+        if (!storage && !vector) {
+            logger.debug("agent:stateless", { agentId });
+            return undefined;
+        }
+        logger.debug("agent:configured", {
+            agentId,
+            storage: storage !== undefined,
+            vector: vector !== undefined,
+            vectorMode: vector === undefined ? "off" : typeof memorySetting === "object" ? "dedicated" : "shared",
+        });
+        return new Memory({
+            ...(storage ? { storage } : {}),
+            ...(vector ? { vector, embedder: fastembed } : {}),
+            options: {
+                lastMessages: 10,
+                ...(vector ? { semanticRecall: { topK: 3, messageRange: 2 } } : {}),
+                // Auto-name each thread from its opening turn so the
+                // conversation list the UI renders shows meaningful titles
+                // instead of raw ids. Titling runs on the small / fast chat
+                // tier (see `summarize.ts`) rather than the agent's primary
+                // model, so naming a thread never spends the heavyweight model.
+                // Only meaningful when storage is on; harmless otherwise.
+                ...(storage
+                    ? {
+                        generateTitle: {
+                            model: summaryModel(this.config),
+                            instructions: TITLE_INSTRUCTIONS,
+                        },
+                    }
+                    : {}),
+            },
+        });
+    }
+    buildStorage(agentId, setting) {
+        if (!setting)
+            return undefined;
+        if (typeof setting === "boolean") {
+            return new PostgresStore({
+                id: `mastra-store__${agentId}`,
+                schemaName: agentStorageSchemaName(agentId),
+                pool: this.servicePrincipalPool,
+            });
+        }
+        // Cast: `withId` guarantees `id` is set, but the distributive
+        // Omit + `id?: string` shape doesn't structurally narrow to the
+        // discriminated union members. Runtime shape is identical.
+        return new PostgresStore(withId(setting, `mastra-store__${agentId}`));
+    }
+    /**
+     * Resolve the agent's vector store. Cascade:
+     *
+     * - falsy: no vector.
+     * - `boolean` / `undefined-inheriting-true`: return the shared
+     *   singleton (built lazily on first call). All agents that
+     *   default-enable memory write into and recall from one index.
+     * - object: build a dedicated `PgVector` for this agent.
+     */
+    buildVector(setting) {
+        if (!setting)
+            return undefined;
+        if (typeof setting === "boolean")
+            return this.getSharedVector();
+        return buildPgVector(setting);
+    }
+    getSharedVector() {
+        if (!this.sharedVector) {
+            this.sharedVector = buildSharedPgVector(this.servicePrincipalPool);
+        }
+        return this.sharedVector;
+    }
+}
+/**
+ * Build the shared `PgVector` that backs the default
+ * `def.memory === true` case across every agent.
+ *
+ * `PgVector`'s constructor accepts only connection-style configs
+ * (`HostConfig` / `ConnectionStringConfig` / `ClientConfig`); there is
+ * no `{ pool }` shorthand the way `PostgresStore` has one. Worse, the
+ * constructor synchronously kicks off a `cacheWarmupPromise` IIFE that
+ * calls `this.pool.connect()` before returning, so we can't cleanly
+ * hand it an inert config and patch the pool afterwards.
+ *
+ * The trick: pass illegal-but-validation-passing placeholders so the
+ * warmup's `net.connect()` rejects synchronously with `RangeError`
+ * (Node validates `0 <= port < 65536`). The IIFE's `catch {}` swallows
+ * it, no DNS lookup or TCP attempt happens, and we then swap
+ * `pgVector.pool` to the lakebase pool. Every subsequent `PgVector`
+ * method reads `this.pool` at call time, so all real I/O goes through
+ * the lakebase pool from then on. The placeholder pool is `.end()`'d
+ * so its socket book-keeping is released.
+ */
+function buildSharedPgVector(pool) {
+    const vector = new PgVector({
+        id: `pg${hash.id()}`,
+        // Keep the recall index out of `public`: on a Lakebase database the app
+        // service principal has no CREATE on `public` (PG15+ locks it down), so a
+        // default-schema PgVector fails on CREATE INDEX with "permission denied for
+        // schema public". PgVector runs CREATE SCHEMA IF NOT EXISTS for a named
+        // schema, so the SP creates and owns `mastra_instance` (the same
+        // instance-level schema the workflow-snapshot store uses) and the index
+        // lands there. Table names don't collide with the storage tables.
+        schemaName: "mastra_instance",
+        host: "-1",
+        port: -1,
+        database: "_",
+        user: "_",
+        password: "_",
+    });
+    const placeholder = vector.pool;
+    vector.pool = pool;
+    void placeholder.end().catch(() => undefined);
+    return vector;
+}
+/** Per-agent dedicated `PgVector` (rare; opt-in via object override). */
+function buildPgVector(setting) {
+    return new PgVector(withId(setting, `pg-vector__${hash.id()}`));
+}
+/** True when this setting requires the shared Lakebase pool. */
+function settingNeedsSharedPool(setting) {
+    return setting === true;
+}
+/** Walk the three shapes of `config.agents` into a flat list. */
+function collectAgentDefinitions(config) {
+    const agents = config.agents;
+    if (!agents)
+        return [];
+    if (Array.isArray(agents))
+        return agents;
+    if (typeof agents.instructions === "string") {
+        return [agents];
+    }
+    return Object.values(agents);
+}
+/** Fill in a default `id` when the caller didn't supply one. */
+function withId(value, fallback) {
+    return value.id ? value : { ...value, id: fallback };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../src/memory.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lakebase-backed Mastra memory wiring.\n *\n * Provides a {@link MemoryBuilder} that mints one `Memory` per agent\n * with two independent knobs:\n *\n * - **Storage** (threads / messages via `PostgresStore`): defaults to\n *   **per-agent** namespacing via {@link agentStorageSchemaName} so\n *   conversation history stays isolated between agents in the same\n *   database. `PostgresStore` auto-creates the schema with\n *   `CREATE SCHEMA IF NOT EXISTS` on init.\n * - **Memory** (semantic recall via `PgVector`): defaults to a single\n *   **shared** instance across every agent. Cross-agent recall on one\n *   index is almost always what users want; opt into per-agent recall\n *   by passing a {@link MastraMemoryConfigOverride} on the agent.\n *\n * Additionally, {@link MemoryBuilder.instanceStorage} returns a\n * **Mastra-instance-level** `PostgresStore` (schema `mastra_instance`)\n * used for workflow snapshots - the persistence layer\n * `agent.resumeStream()` reads from when waking a suspended\n * `requireApproval` tool call. Per-agent stores are not enough for\n * this: workflow runs are scoped to the Mastra instance, not an\n * individual agent's `Memory`.\n *\n * Plugin-level `config.storage` / `config.memory` act as the baseline\n * (auto-defaulted to `true` in `plugin.ts` when the `lakebase` plugin\n * is registered); per-agent settings cascade on top of that.\n *\n * @module\n */\n\nimport { getUsernameWithApiLookup } from \"@databricks/appkit\";\nimport { hash, log } from \"@dbx-tools/shared-core\";\nimport { fastembed } from \"@mastra/fastembed\";\nimport { Memory } from \"@mastra/memory\";\nimport { PgVector, PostgresStore } from \"@mastra/pg\";\nimport { Pool, type PoolConfig } from \"pg\";\n\nimport type { MastraAgentDefinition, MastraMemoryConfigOverride } from \"./agents\";\nimport type { MastraPluginConfig } from \"./config\";\nimport { agentStorageSchemaName } from \"./storage-schema\";\nimport { summaryModel, TITLE_INSTRUCTIONS } from \"./summarize\";\n\nconst logger = log.logger(\"mastra/memory\");\n\n/**\n * Build a dedicated **service-principal** Lakebase pool for Mastra\n * memory from the lakebase plugin's resolved SP pg config.\n *\n * The plugin's `exports().pool` is a `RoutingPool` that switches to\n * the per-user (OBO) pool whenever a query runs inside an `asUser`\n * scope - exactly the context the mastra plugin establishes around\n * every chat turn. Memory (threads / messages + semantic recall) must\n * instead always act as the app service principal: it owns the\n * auto-created `mastra_*` schemas (a per-user role usually can't\n * `CREATE SCHEMA`) and is shared across users, so it cannot inherit a\n * request's OBO identity.\n *\n * `pgConfig` must be the plugin's `exports().getPgConfig()` evaluated\n * **outside** any `asUser` scope (i.e. during setup), so it carries\n * the SP connection target, OAuth token-refresh `password` callback,\n * and any `lakebase({ pool })` tuning overrides - all of which this\n * pool inherits. See the call site in `plugin.ts`.\n */\nexport async function createServicePrincipalPool(pgConfig: PoolConfig): Promise<Pool> {\n  // `getPgConfig()` resolves the SP username synchronously from\n  // `PGUSER` / `DATABRICKS_CLIENT_ID`; fall back to the async API\n  // lookup (e.g. local dev authenticating via PAT) so the pool always\n  // has an identity to connect with.\n  const user = pgConfig.user ?? (await getUsernameWithApiLookup());\n  return new Pool({ ...pgConfig, user });\n}\n\n/** Effective per-knob setting after the plugin/agent cascade. */\ntype StorageSetting = MastraAgentDefinition[\"storage\"];\ntype MemorySetting = MastraAgentDefinition[\"memory\"];\n\n/**\n * True when any plugin-level or per-agent setting could need the\n * Lakebase pool. Used by `plugin.ts` to gate creation of the\n * service-principal pool and the {@link MemoryBuilder} that consumes\n * it; when false neither is built.\n */\nexport function needsLakebase(config: MastraPluginConfig): boolean {\n  if (settingNeedsSharedPool(config.storage)) return true;\n  if (settingNeedsSharedPool(config.memory)) return true;\n  const defs = collectAgentDefinitions(config);\n  return defs.some((d) => settingNeedsSharedPool(d.storage) || settingNeedsSharedPool(d.memory));\n}\n\n/**\n * Construct a per-agent {@link Memory} factory bound to the supplied\n * service-principal pool (see {@link createServicePrincipalPool}).\n * Caches the shared `PgVector` singleton (built on first need) so each\n * agent build is O(1) after the first.\n */\nexport function createMemoryBuilder(\n  config: MastraPluginConfig,\n  servicePrincipalPool: Pool,\n): MemoryBuilder {\n  return new MemoryBuilder(config, servicePrincipalPool);\n}\n\n/**\n * Builds one `Memory` per agent against a shared service-principal\n * Lakebase pool. Per-instance state keeps the shared `PgVector` alive\n * across calls so registering N agents stays cheap.\n */\nexport class MemoryBuilder {\n  private sharedVector: PgVector | undefined;\n\n  constructor(\n    private readonly config: MastraPluginConfig,\n    private readonly servicePrincipalPool: Pool,\n  ) {}\n\n  /**\n   * Build the Mastra-instance-level storage used for workflow\n   * snapshots. Returns `undefined` when plugin-level `storage` is\n   * disabled, in which case `agent.resumeStream()` (and therefore\n   * the `requireApproval` flow) will not be available.\n   *\n   * The store lives in a dedicated `mastra_instance` schema so it\n   * never collides with per-agent {@link agentStorageSchemaName} namespaces.\n   * Workflow snapshots are not per-agent state; they belong to the\n   * `Mastra` instance that owns the workflow execution.\n   */\n  instanceStorage(): PostgresStore | undefined {\n    const setting = this.config.storage;\n    if (!setting) return undefined;\n    if (typeof setting === \"object\") {\n      return new PostgresStore(\n        withId(setting, \"mastra-store__instance\") as ConstructorParameters<typeof PostgresStore>[0],\n      );\n    }\n    return new PostgresStore({\n      id: \"mastra-store__instance\",\n      schemaName: \"mastra_instance\",\n      pool: this.servicePrincipalPool,\n    });\n  }\n\n  /**\n   * Build a `Memory` for `agentId` after the plugin/agent cascade.\n   * Returns `undefined` when the agent has neither storage nor a\n   * vector store enabled - Mastra accepts a missing `memory` field\n   * and treats the agent as stateless.\n   */\n  forAgent(agentId: string, def: MastraAgentDefinition): Memory | undefined {\n    const storageSetting = def.storage ?? this.config.storage;\n    const memorySetting = def.memory ?? this.config.memory;\n\n    const storage = this.buildStorage(agentId, storageSetting);\n    const vector = this.buildVector(memorySetting);\n    if (!storage && !vector) {\n      logger.debug(\"agent:stateless\", { agentId });\n      return undefined;\n    }\n\n    logger.debug(\"agent:configured\", {\n      agentId,\n      storage: storage !== undefined,\n      vector: vector !== undefined,\n      vectorMode:\n        vector === undefined ? \"off\" : typeof memorySetting === \"object\" ? \"dedicated\" : \"shared\",\n    });\n\n    return new Memory({\n      ...(storage ? { storage } : {}),\n      ...(vector ? { vector, embedder: fastembed } : {}),\n      options: {\n        lastMessages: 10,\n        ...(vector ? { semanticRecall: { topK: 3, messageRange: 2 } } : {}),\n        // Auto-name each thread from its opening turn so the\n        // conversation list the UI renders shows meaningful titles\n        // instead of raw ids. Titling runs on the small / fast chat\n        // tier (see `summarize.ts`) rather than the agent's primary\n        // model, so naming a thread never spends the heavyweight model.\n        // Only meaningful when storage is on; harmless otherwise.\n        ...(storage\n          ? {\n              generateTitle: {\n                model: summaryModel(this.config),\n                instructions: TITLE_INSTRUCTIONS,\n              },\n            }\n          : {}),\n      },\n    });\n  }\n\n  private buildStorage(agentId: string, setting: StorageSetting): PostgresStore | undefined {\n    if (!setting) return undefined;\n    if (typeof setting === \"boolean\") {\n      return new PostgresStore({\n        id: `mastra-store__${agentId}`,\n        schemaName: agentStorageSchemaName(agentId),\n        pool: this.servicePrincipalPool,\n      });\n    }\n    // Cast: `withId` guarantees `id` is set, but the distributive\n    // Omit + `id?: string` shape doesn't structurally narrow to the\n    // discriminated union members. Runtime shape is identical.\n    return new PostgresStore(\n      withId(setting, `mastra-store__${agentId}`) as ConstructorParameters<typeof PostgresStore>[0],\n    );\n  }\n\n  /**\n   * Resolve the agent's vector store. Cascade:\n   *\n   * - falsy: no vector.\n   * - `boolean` / `undefined-inheriting-true`: return the shared\n   *   singleton (built lazily on first call). All agents that\n   *   default-enable memory write into and recall from one index.\n   * - object: build a dedicated `PgVector` for this agent.\n   */\n  private buildVector(setting: MemorySetting): PgVector | undefined {\n    if (!setting) return undefined;\n    if (typeof setting === \"boolean\") return this.getSharedVector();\n    return buildPgVector(setting);\n  }\n\n  private getSharedVector(): PgVector {\n    if (!this.sharedVector) {\n      this.sharedVector = buildSharedPgVector(this.servicePrincipalPool);\n    }\n    return this.sharedVector;\n  }\n}\n\n/**\n * Build the shared `PgVector` that backs the default\n * `def.memory === true` case across every agent.\n *\n * `PgVector`'s constructor accepts only connection-style configs\n * (`HostConfig` / `ConnectionStringConfig` / `ClientConfig`); there is\n * no `{ pool }` shorthand the way `PostgresStore` has one. Worse, the\n * constructor synchronously kicks off a `cacheWarmupPromise` IIFE that\n * calls `this.pool.connect()` before returning, so we can't cleanly\n * hand it an inert config and patch the pool afterwards.\n *\n * The trick: pass illegal-but-validation-passing placeholders so the\n * warmup's `net.connect()` rejects synchronously with `RangeError`\n * (Node validates `0 <= port < 65536`). The IIFE's `catch {}` swallows\n * it, no DNS lookup or TCP attempt happens, and we then swap\n * `pgVector.pool` to the lakebase pool. Every subsequent `PgVector`\n * method reads `this.pool` at call time, so all real I/O goes through\n * the lakebase pool from then on. The placeholder pool is `.end()`'d\n * so its socket book-keeping is released.\n */\nfunction buildSharedPgVector(pool: Pool): PgVector {\n  const vector = new PgVector({\n    id: `pg${hash.id()}`,\n    // Keep the recall index out of `public`: on a Lakebase database the app\n    // service principal has no CREATE on `public` (PG15+ locks it down), so a\n    // default-schema PgVector fails on CREATE INDEX with \"permission denied for\n    // schema public\". PgVector runs CREATE SCHEMA IF NOT EXISTS for a named\n    // schema, so the SP creates and owns `mastra_instance` (the same\n    // instance-level schema the workflow-snapshot store uses) and the index\n    // lands there. Table names don't collide with the storage tables.\n    schemaName: \"mastra_instance\",\n    host: \"-1\",\n    port: -1,\n    database: \"_\",\n    user: \"_\",\n    password: \"_\",\n  });\n  const placeholder = vector.pool;\n  vector.pool = pool;\n  void placeholder.end().catch(() => undefined);\n  return vector;\n}\n\n/** Per-agent dedicated `PgVector` (rare; opt-in via object override). */\nfunction buildPgVector(setting: MastraMemoryConfigOverride): PgVector {\n  return new PgVector(\n    withId(setting, `pg-vector__${hash.id()}`) as ConstructorParameters<typeof PgVector>[0],\n  );\n}\n\n/** True when this setting requires the shared Lakebase pool. */\nfunction settingNeedsSharedPool(setting: StorageSetting | MemorySetting | undefined): boolean {\n  return setting === true;\n}\n\n/** Walk the three shapes of `config.agents` into a flat list. */\nfunction collectAgentDefinitions(config: MastraPluginConfig): MastraAgentDefinition[] {\n  const agents = config.agents;\n  if (!agents) return [];\n  if (Array.isArray(agents)) return agents;\n  if (typeof (agents as MastraAgentDefinition).instructions === \"string\") {\n    return [agents as MastraAgentDefinition];\n  }\n  return Object.values(agents as Record<string, MastraAgentDefinition>);\n}\n\n/** Fill in a default `id` when the caller didn't supply one. */\nfunction withId<T extends { id?: string }>(value: T, fallback: string): T {\n  return value.id ? value : { ...value, id: fallback };\n}\n"]}

package/lib/src/mlflow.d.ts

@@ -0,0 +1,63 @@
+/**
+ * MLflow user-feedback logging: detect whether MLflow tracing is wired
+ * for this deployment, and log a thumbs / comment as a trace
+ * *assessment* via the Databricks MLflow REST API.
+ *
+ * Feedback attaches to a trace, and the plugin's spans reach MLflow
+ * through the same OTel pipeline as every other AppKit span (see
+ * `observability.ts`). MLflow derives its trace id from the OpenTelemetry
+ * trace id (`tr-<hex(otelTraceId)>`), so the server stamps the active
+ * trace id on each turn's response and the client sends it back here.
+ *
+ * There is no MLflow JS SDK, so this posts to the assessments REST
+ * endpoint directly using the OBO-scoped workspace client (the feedback
+ * is thus attributed to the signed-in user). Trace export is
+ * asynchronous, so the just-finished trace may not exist in MLflow yet
+ * when the user reacts; the log call retries briefly on "not found"
+ * before giving up softly.
+ *
+ * @module
+ */
+import { appkit } from "@dbx-tools/appkit";
+/** Workspace client carried on an AppKit execution context. */
+type WorkspaceClient = appkit.WorkspaceClientLike;
+/**
+ * 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.
+ */
+export declare function mlflowEnabled(): boolean;
+/**
+ * Resolve whether user feedback is enabled from the plugin's optional
+ * `config.feedback` override: the explicit boolean wins, otherwise fall
+ * back to auto-detecting MLflow tracing ({@link mlflowEnabled}). Shared
+ * by the plugin's client-config gate and the server's trace-id header so
+ * the two never disagree.
+ */
+export declare function resolveFeedbackEnabled(explicit: boolean | undefined): boolean;
+/** Parameters for {@link logFeedback}. */
+export interface LogFeedbackParams {
+    /** MLflow trace id the assessment attaches to (`tr-<hex>`). */
+    traceId: string;
+    /** Assessment name; defaults per whether a value or a comment is sent. */
+    name?: string;
+    /** Thumbs / rating / label value. Omit for a comment-only submission. */
+    value?: boolean | number | string;
+    /** Freeform comment: the rationale alongside a value, or the value itself when none. */
+    comment?: string;
+    /** Identity the feedback is attributed to (user email / id). */
+    sourceId?: string;
+}
+/**
+ * Log a HUMAN feedback assessment to a trace. Returns the created
+ * assessment id on success, or `undefined` when the trace can't be
+ * found (even after retrying for export lag) or the request otherwise
+ * fails - callers surface that as a soft "not recorded" rather than an
+ * error, keeping the chat usable.
+ */
+export declare function logFeedback(client: WorkspaceClient, params: LogFeedbackParams): Promise<string | undefined>;
+export {};

package/lib/src/mlflow.js

@@ -0,0 +1,117 @@
+/**
+ * MLflow user-feedback logging: detect whether MLflow tracing is wired
+ * for this deployment, and log a thumbs / comment as a trace
+ * *assessment* via the Databricks MLflow REST API.
+ *
+ * Feedback attaches to a trace, and the plugin's spans reach MLflow
+ * through the same OTel pipeline as every other AppKit span (see
+ * `observability.ts`). MLflow derives its trace id from the OpenTelemetry
+ * trace id (`tr-<hex(otelTraceId)>`), so the server stamps the active
+ * trace id on each turn's response and the client sends it back here.
+ *
+ * There is no MLflow JS SDK, so this posts to the assessments REST
+ * endpoint directly using the OBO-scoped workspace client (the feedback
+ * is thus attributed to the signed-in user). Trace export is
+ * asynchronous, so the just-finished trace may not exist in MLflow yet
+ * when the user reacts; the log call retries briefly on "not found"
+ * before giving up softly.
+ *
+ * @module
+ */
+import { async, error, log } from "@dbx-tools/shared-core";
+import { feedback } from "@dbx-tools/shared-mastra";
+import { databricksFetch, readResponseJson, readResponseText } from "./rest.js";
+const logger = log.logger("mastra/mlflow");
+/** Assessments REST path for a trace. `3.0` is the current MLflow API version. */
+const assessmentsPath = (traceId) => `/api/3.0/mlflow/traces/${encodeURIComponent(traceId)}/assessments`;
+/** Number of times to retry a "trace not found" response before giving up. */
+const NOT_FOUND_RETRIES = 3;
+/** Base backoff between "trace not found" retries, in ms (grows linearly). */
+const NOT_FOUND_BACKOFF_MS = 1200;
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * Resolve whether user feedback is enabled from the plugin's optional
+ * `config.feedback` override: the explicit boolean wins, otherwise fall
+ * back to auto-detecting MLflow tracing ({@link mlflowEnabled}). Shared
+ * by the plugin's client-config gate and the server's trace-id header so
+ * the two never disagree.
+ */
+export function resolveFeedbackEnabled(explicit) {
+    return explicit ?? mlflowEnabled();
+}
+/**
+ * Log a HUMAN feedback assessment to a trace. Returns the created
+ * assessment id on success, or `undefined` when the trace can't be
+ * found (even after retrying for export lag) or the request otherwise
+ * fails - callers surface that as a soft "not recorded" rather than an
+ * error, keeping the chat usable.
+ */
+export async function logFeedback(client, params) {
+    // A comment with no thumbs value is logged as text feedback; a value
+    // (with an optional comment as the rationale) is the thumbs path.
+    const hasValue = params.value !== undefined;
+    const name = params.name?.trim() ||
+        (hasValue ? feedback.DEFAULT_FEEDBACK_NAME : feedback.DEFAULT_COMMENT_NAME);
+    const value = hasValue ? params.value : params.comment;
+    const assessment = {
+        trace_id: params.traceId,
+        assessment_name: name,
+        source: {
+            source_type: "HUMAN",
+            source_id: params.sourceId?.trim() || "user",
+        },
+        feedback: { value },
+        ...(hasValue && params.comment?.trim() ? { rationale: params.comment } : {}),
+    };
+    const body = { assessment };
+    for (let attempt = 0; attempt <= NOT_FOUND_RETRIES; attempt++) {
+        let res;
+        try {
+            res = await databricksFetch(client, assessmentsPath(params.traceId), {
+                method: "POST",
+                body,
+            });
+        }
+        catch (err) {
+            logger.warn("feedback request failed", {
+                traceId: params.traceId,
+                error: error.errorMessage(err),
+            });
+            return undefined;
+        }
+        if (res.ok) {
+            const parsed = await readResponseJson(res);
+            const assessmentId = parsed?.assessment?.assessment_id ??
+                parsed?.assessment_id;
+            return typeof assessmentId === "string" ? assessmentId : "";
+        }
+        // Trace export is async; a fresh trace may not exist yet. Retry a
+        // few times with a short backoff before giving up softly.
+        if (res.status === 404 && attempt < NOT_FOUND_RETRIES) {
+            await async.sleep(NOT_FOUND_BACKOFF_MS * (attempt + 1));
+            continue;
+        }
+        logger.warn("feedback not recorded", {
+            traceId: params.traceId,
+            status: res.status,
+            body: await readResponseText(res),
+        });
+        return undefined;
+    }
+    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`). 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). Trace export is\n * asynchronous, so the just-finished trace may not exist in MLflow yet\n * when the user reacts; the log call retries briefly on \"not found\"\n * before giving up softly.\n *\n * @module\n */\n\nimport { appkit } from \"@dbx-tools/appkit\";\nimport { async, error, log } from \"@dbx-tools/shared-core\";\nimport { feedback } from \"@dbx-tools/shared-mastra\";\nimport { databricksFetch, readResponseJson, readResponseText } from \"./rest\";\n\nconst logger = log.logger(\"mastra/mlflow\");\n\n/** Workspace client carried on an AppKit execution context. */\ntype WorkspaceClient = appkit.WorkspaceClientLike;\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\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/** 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 assessment: Record<string, unknown> = {\n    trace_id: params.traceId,\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(params.traceId), {\n        method: \"POST\",\n        body,\n      });\n    } catch (err) {\n      logger.warn(\"feedback request failed\", {\n        traceId: params.traceId,\n        error: error.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 async.sleep(NOT_FOUND_BACKOFF_MS * (attempt + 1));\n      continue;\n    }\n    logger.warn(\"feedback not recorded\", {\n      traceId: params.traceId,\n      status: res.status,\n      body: await readResponseText(res),\n    });\n    return undefined;\n  }\n  return undefined;\n}\n"]}

package/lib/src/model.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Databricks Model Serving resolver for Mastra agents.
+ *
+ * Each agent step calls {@link buildModel} with the active
+ * `RequestContext`. The user stamped by `MastraServer` carries an
+ * AppKit `WorkspaceClient`; we ask it for the workspace host and a
+ * fresh bearer header, then point Mastra's OpenAI-compatible provider
+ * at `/serving-endpoints` on that host.
+ *
+ * This module only adds the Mastra-specific glue. The actual model
+ * selection - listing the workspace catalogue and resolving an
+ * explicit name / class / fallback chain to a real endpoint id - lives
+ * in `@dbx-tools/model` ({@link selectModel}) so non-Mastra consumers
+ * (e.g. a job that just needs a model name) can reuse it. Here we
+ * assemble the explicit ask from Mastra's request context (the
+ * per-request override under {@link MASTRA_MODEL_OVERRIDE_KEY}, the
+ * agent / plugin `modelId`, or `DATABRICKS_SERVING_ENDPOINT_NAME`),
+ * pass the plugin's fuzzy / class / fallback knobs through, and wrap
+ * the resolved id in the OpenAI-compatible provider config Mastra
+ * expects. Catalogue fetches fail loud: network / auth errors
+ * propagate so callers see the real SDK message.
+ *
+ * @module
+ */
+import { model } from "@dbx-tools/shared-model";
+import type { MastraModelConfig } from "@mastra/core/llm";
+import type { RequestContext } from "@mastra/core/request-context";
+import { type MastraPluginConfig } from "./config.js";
+type ModelClass = model.ModelClass;
+/** Optional overrides accepted by {@link buildModel}. */
+export interface BuildModelOverrides {
+    /**
+     * Static model id from the agent / plugin config (string sugar on
+     * `def.model` or `config.defaultModel`). Loses to the per-request
+     * override but wins over env / class / fallback.
+     */
+    modelId?: string;
+    /**
+     * Chat capability class to resolve when no explicit model id is
+     * supplied. Used by internal agents (e.g. the chart planner asks for
+     * {@link model.ModelClass.ChatFast}) to express intent without pinning an
+     * endpoint name; the live catalogue is classified and the top
+     * available model in the class is chosen, falling back to the
+     * class's static list when the workspace has none.
+     */
+    modelClass?: ModelClass;
+}
+/**
+ * Resolve a `MastraModelConfig` for the current agent step. Runs
+ * while `agent.stream` is inside the `asUser(req)` scope so tokens
+ * are user-scoped; outside an active user context the workspace
+ * client falls back to the service principal.
+ *
+ * Endpoint precedence: the per-request override
+ * ({@link MASTRA_MODEL_OVERRIDE_KEY}, only when `config.modelOverride` allows
+ * it), then {@link BuildModelOverrides.modelId} from the agent / plugin
+ * config, then `DATABRICKS_SERVING_ENDPOINT_NAME`. With none of those set the
+ * capability class and fallback ladder in `@dbx-tools/model` choose the
+ * endpoint.
+ */
+export declare function buildModel(config: MastraPluginConfig, requestContext: RequestContext, overrides?: BuildModelOverrides): Promise<MastraModelConfig>;
+export {};