@dbx-tools/appkit-mastra 0.5.1 → 0.6.0

package/lib/src/identity.js

@@ -0,0 +1,95 @@
+/**
+ * Which Databricks identity a chat turn's workspace calls run as.
+ *
+ * Every Databricks call a turn makes - the `/serving-endpoints` catalogue the
+ * model picker reads, Genie suggestions, `ask_genie`, and the Statement
+ * Execution fetch behind a `[data:<id>]` embed - goes through the workspace
+ * client on the ambient AppKit execution context. That context is user-scoped
+ * (OBO) whenever the plugin enters `asUser(req)` and the app's service principal
+ * otherwise, so ONE decision - do we enter that scope for this request - moves
+ * every call site together. This module owns that decision.
+ *
+ * Why the option exists: OBO requires the caller to be a member of the
+ * WORKSPACE, not merely of the Databricks account. An app shared with an
+ * account-level group can therefore be opened by someone whose OBO token is
+ * perfectly valid but whose every workspace call fails with `Unauthorized
+ * access to Org: <workspace-id>`, and granting workspace membership is not
+ * always available - a workspace caps membership far below the size of a large
+ * account's user group. The app's own service principal already holds the Genie
+ * / warehouse / serving / Unity Catalog grants the app was deployed with, and
+ * works for every caller.
+ *
+ * The two modes, from `config.genieIdentity` (env: {@link IDENTITY_ENV}):
+ *
+ *   - `"user"` (default): always OBO. Calls are attributed per user and Genie /
+ *     Unity Catalog row filters apply per user. Correct whenever every caller is
+ *     a workspace member. This is the historical behavior, so the option is
+ *     purely additive - an app that never sets it is unchanged.
+ *   - `"service-principal"`: always the app service principal. Needs no OBO
+ *     scopes and works for any caller who can open the app, at the cost of
+ *     per-user attribution in Genie / Unity Catalog.
+ *
+ * What `"service-principal"` does NOT change is WHO the turn belongs to. The
+ * memory thread's `resourceId`, the per-user cache namespace, and the user
+ * metadata on traces still come from the forwarded request headers, so two
+ * account users sharing the service principal's data access still get separate
+ * conversations and cannot read each other's threads or cached charts. Only the
+ * Databricks credential is shared.
+ *
+ * @module
+ */
+import { ConfigurationError } from "@databricks/appkit";
+import { string } from "@dbx-tools/shared-core";
+/** Environment fallback for `config.genieIdentity`. */
+export const IDENTITY_ENV = "MASTRA_GENIE_IDENTITY";
+/** Every accepted {@link MastraIdentityMode}. */
+export const IDENTITY_MODES = ["user", "service-principal"];
+/**
+ * Default mode. `"user"` keeps OBO the only identity unless an app opts in, so
+ * adopting this option can never silently widen an existing app's data access.
+ */
+export const DEFAULT_IDENTITY_MODE = "user";
+/**
+ * Resolve the configured mode: explicit plugin config, then {@link IDENTITY_ENV},
+ * then {@link DEFAULT_IDENTITY_MODE}.
+ *
+ * An unrecognized value throws rather than falling back, since falling back
+ * would silently keep serving OBO - and the 500s it produces - to exactly the
+ * callers the option was set to accommodate.
+ */
+export function resolveIdentityMode(configured) {
+    const raw = string.trimToNull(configured) ?? string.trimToNull(process.env[IDENTITY_ENV]);
+    if (raw === null)
+        return DEFAULT_IDENTITY_MODE;
+    const mode = raw.toLowerCase();
+    if (!IDENTITY_MODES.includes(mode)) {
+        throw new ConfigurationError(`genieIdentity must be one of ${IDENTITY_MODES.join(" | ")} (env: ${IDENTITY_ENV})`, { context: { field: "genieIdentity", envVar: IDENTITY_ENV, received: raw } });
+    }
+    return mode;
+}
+/** Header Databricks Apps forward the signed-in user's id on. */
+export const USER_ID_HEADER = "x-forwarded-user";
+/** Header Databricks Apps forward the signed-in user's email on. */
+export const USER_EMAIL_HEADER = "x-forwarded-email";
+/**
+ * The forwarded user id on `req`, or `undefined`. Used to attribute a turn to
+ * the real caller in `service-principal` mode, where the Databricks client is
+ * the app SP but memory / cache / traces must still key off the user.
+ */
+export function requestUserId(req) {
+    return string.trimToNull(req.header(USER_ID_HEADER)) ?? undefined;
+}
+/** The forwarded user email on `req`, or `undefined`. */
+export function requestUserEmail(req) {
+    return string.trimToNull(req.header(USER_EMAIL_HEADER)) ?? undefined;
+}
+/**
+ * Whether this request should run its Databricks calls as the app service
+ * principal rather than OBO. `"service-principal"` always does; `"user"` never
+ * does. The request is accepted for symmetry and to leave room for
+ * request-scoped policy later; it is unused today.
+ */
+export function useServicePrincipal(mode, _req) {
+    return mode === "service-principal";
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAMhD,uDAAuD;AACvD,MAAM,CAAC,MAAM,YAAY,GAAG,uBAAuB,CAAC;AAEpD,iDAAiD;AACjD,MAAM,CAAC,MAAM,cAAc,GAAkC,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE3F;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAuB,MAAM,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,UAA8B;IAChE,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;IAC1F,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,qBAAqB,CAAC;IAC/C,MAAM,IAAI,GAAG,GAAG,CAAC,WAAW,EAAwB,CAAC;IACrD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,kBAAkB,CAC1B,gCAAgC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,YAAY,GAAG,EACnF,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAC7E,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,iEAAiE;AACjE,MAAM,CAAC,MAAM,cAAc,GAAG,kBAAkB,CAAC;AAEjD,oEAAoE;AACpE,MAAM,CAAC,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,GAAoB;IAChD,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,SAAS,CAAC;AACpE,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,gBAAgB,CAAC,GAAoB;IACnD,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,IAAI,SAAS,CAAC;AACvE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAwB,EAAE,IAAsB;IAClF,OAAO,IAAI,KAAK,mBAAmB,CAAC;AACtC,CAAC","sourcesContent":["/**\n * Which Databricks identity a chat turn's workspace calls run as.\n *\n * Every Databricks call a turn makes - the `/serving-endpoints` catalogue the\n * model picker reads, Genie suggestions, `ask_genie`, and the Statement\n * Execution fetch behind a `[data:<id>]` embed - goes through the workspace\n * client on the ambient AppKit execution context. That context is user-scoped\n * (OBO) whenever the plugin enters `asUser(req)` and the app's service principal\n * otherwise, so ONE decision - do we enter that scope for this request - moves\n * every call site together. This module owns that decision.\n *\n * Why the option exists: OBO requires the caller to be a member of the\n * WORKSPACE, not merely of the Databricks account. An app shared with an\n * account-level group can therefore be opened by someone whose OBO token is\n * perfectly valid but whose every workspace call fails with `Unauthorized\n * access to Org: <workspace-id>`, and granting workspace membership is not\n * always available - a workspace caps membership far below the size of a large\n * account's user group. The app's own service principal already holds the Genie\n * / warehouse / serving / Unity Catalog grants the app was deployed with, and\n * works for every caller.\n *\n * The two modes, from `config.genieIdentity` (env: {@link IDENTITY_ENV}):\n *\n *   - `\"user\"` (default): always OBO. Calls are attributed per user and Genie /\n *     Unity Catalog row filters apply per user. Correct whenever every caller is\n *     a workspace member. This is the historical behavior, so the option is\n *     purely additive - an app that never sets it is unchanged.\n *   - `\"service-principal\"`: always the app service principal. Needs no OBO\n *     scopes and works for any caller who can open the app, at the cost of\n *     per-user attribution in Genie / Unity Catalog.\n *\n * What `\"service-principal\"` does NOT change is WHO the turn belongs to. The\n * memory thread's `resourceId`, the per-user cache namespace, and the user\n * metadata on traces still come from the forwarded request headers, so two\n * account users sharing the service principal's data access still get separate\n * conversations and cannot read each other's threads or cached charts. Only the\n * Databricks credential is shared.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { string } from \"@dbx-tools/shared-core\";\nimport type express from \"express\";\n\n/** Identity a chat turn's Databricks calls run as. See the module docs. */\nexport type MastraIdentityMode = \"user\" | \"service-principal\";\n\n/** Environment fallback for `config.genieIdentity`. */\nexport const IDENTITY_ENV = \"MASTRA_GENIE_IDENTITY\";\n\n/** Every accepted {@link MastraIdentityMode}. */\nexport const IDENTITY_MODES: readonly MastraIdentityMode[] = [\"user\", \"service-principal\"];\n\n/**\n * Default mode. `\"user\"` keeps OBO the only identity unless an app opts in, so\n * adopting this option can never silently widen an existing app's data access.\n */\nexport const DEFAULT_IDENTITY_MODE: MastraIdentityMode = \"user\";\n\n/**\n * Resolve the configured mode: explicit plugin config, then {@link IDENTITY_ENV},\n * then {@link DEFAULT_IDENTITY_MODE}.\n *\n * An unrecognized value throws rather than falling back, since falling back\n * would silently keep serving OBO - and the 500s it produces - to exactly the\n * callers the option was set to accommodate.\n */\nexport function resolveIdentityMode(configured: string | undefined): MastraIdentityMode {\n  const raw = string.trimToNull(configured) ?? string.trimToNull(process.env[IDENTITY_ENV]);\n  if (raw === null) return DEFAULT_IDENTITY_MODE;\n  const mode = raw.toLowerCase() as MastraIdentityMode;\n  if (!IDENTITY_MODES.includes(mode)) {\n    throw new ConfigurationError(\n      `genieIdentity must be one of ${IDENTITY_MODES.join(\" | \")} (env: ${IDENTITY_ENV})`,\n      { context: { field: \"genieIdentity\", envVar: IDENTITY_ENV, received: raw } },\n    );\n  }\n  return mode;\n}\n\n/** Header Databricks Apps forward the signed-in user's id on. */\nexport const USER_ID_HEADER = \"x-forwarded-user\";\n\n/** Header Databricks Apps forward the signed-in user's email on. */\nexport const USER_EMAIL_HEADER = \"x-forwarded-email\";\n\n/**\n * The forwarded user id on `req`, or `undefined`. Used to attribute a turn to\n * the real caller in `service-principal` mode, where the Databricks client is\n * the app SP but memory / cache / traces must still key off the user.\n */\nexport function requestUserId(req: express.Request): string | undefined {\n  return string.trimToNull(req.header(USER_ID_HEADER)) ?? undefined;\n}\n\n/** The forwarded user email on `req`, or `undefined`. */\nexport function requestUserEmail(req: express.Request): string | undefined {\n  return string.trimToNull(req.header(USER_EMAIL_HEADER)) ?? undefined;\n}\n\n/**\n * Whether this request should run its Databricks calls as the app service\n * principal rather than OBO. `\"service-principal\"` always does; `\"user\"` never\n * does. The request is accepted for symmetry and to leave room for\n * request-scoped policy later; it is unused today.\n */\nexport function useServicePrincipal(mode: MastraIdentityMode, _req?: express.Request): boolean {\n  return mode === \"service-principal\";\n}\n"]}

package/lib/src/plugin.d.ts

@@ -103,6 +103,12 @@ export declare class MastraPlugin extends Plugin<MastraPluginConfig> {
      * {@link buildAgentAndServer} and registered on the Mastra instance.
      */
     private mcp;
+    /**
+     * Resolved {@link MastraIdentityMode}: the identity the chat path's Databricks
+     * calls run as. Read once at setup so an invalid `genieIdentity` fails the app
+     * boot rather than the first request, and so every request agrees.
+     */
+    private identityMode;
     /**
      * Dedicated service-principal Lakebase pool backing Mastra memory /
      * storage. Built once in {@link buildAgentAndServer} (outside any
@@ -112,6 +118,22 @@ export declare class MastraPlugin extends Plugin<MastraPluginConfig> {
      */
     private servicePrincipalPool;
     setup(): Promise<void>;
+    /**
+     * The plugin instance the chat path's Databricks calls should run through for
+     * `req`, honoring {@link identityMode}.
+     *
+     * In `"user"` mode (the default) this is `this.asUser(req)` - AppKit's own
+     * proxy that runs every call inside `runInUserContext`, so `getExecutionContext()`
+     * returns the caller's OBO client, exactly as before this option existed. In
+     * `"service-principal"` mode it is `this` unwrapped, so the same methods run in
+     * the ambient service context and `getExecutionContext()` returns the app
+     * service principal's client - the same "just don't enter `asUser`" pattern
+     * AppKit's own service-context calls use. One helper covers every workspace
+     * call the chat path makes (serving catalogue, Genie suggestions, `ask_genie`
+     * via the dispatched agent turn, statement fetch, feedback), so the identity
+     * decision lives in one place.
+     */
+    private scopedSelf;
     /**
      * When the `lakebase` plugin is registered, auto-enable `storage`
      * and `memory` unless the caller opted out explicitly (`false` or a