@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/workspaces.js

@@ -0,0 +1,246 @@
+/**
+ * Mastra workspace factory for Databricks Apps.
+ *
+ * Builds a per-request {@link Workspace} whose filesystem is a
+ * {@link CompositeFilesystem} over Databricks paths resolved from the
+ * OBO client on {@link MASTRA_USER_KEY}. Optional mount resolver
+ * contributions merge extra filesystems and skill scan roots; built-in
+ * Assistant skill trees are toggled with `assistantSkills` (on by default).
+ *
+ * @module
+ */
+import { log, string, token } from "@dbx-tools/shared-core";
+import { CompositeFilesystem, Workspace, } from "@mastra/core/workspace";
+import { MASTRA_SCOPES_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY } from "./config.js";
+import { DatabricksWorkspaceFilesystem, emptyFilesystem } from "./filesystems.js";
+/* ------------------------------ constants ------------------------------ */
+/** Shared Assistant skills tree in the workspace namespace. */
+const ASSISTANT_SHARED_SKILLS_PATH = "/Workspace/.assistant/skills";
+/** Composite mount for {@link ASSISTANT_SHARED_SKILLS_PATH}. */
+const ASSISTANT_WORKSPACE_SKILLS_MOUNT = "/workspace_skills";
+/** Composite mount for the caller's `/.assistant/skills` tree. */
+const ASSISTANT_USER_SKILLS_MOUNT = "/workspace_user_skills";
+/** OAuth scopes that gate Databricks workspace file mounts. */
+const WORKSPACE_FILE_SCOPES = ["workspace", "workspace.workspace", "all-apis"];
+const logger = log.logger("mastra/workspaces");
+/**
+ * Create a Mastra {@link Workspace} with per-request Databricks mounts.
+ *
+ * @example Assistant skills only (default for agents in this plugin)
+ * ```ts
+ * createWorkspace()
+ * ```
+ *
+ * @example Assistant skills plus a custom mount resolver
+ * ```ts
+ * createWorkspace({
+ *   assistantSkills: true,
+ *   mounts: [
+ *     async ({ requestContext }) => ({
+ *       mounts: { "/data": myFilesystem },
+ *       skillPaths: [],
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export function createWorkspace(options = {}) {
+    const { id, name } = resolveWorkspaceIdentity(options);
+    const resolvers = buildMountResolvers(options);
+    const skills = options.skills ?? (resolvers.length > 0 ? buildWorkspaceSkillsResolver(resolvers) : undefined);
+    const checkSkillFileMtime = options.checkSkillFileMtime ?? options.assistantSkills !== false;
+    const bm25 = options.bm25 !== false;
+    logger.debug("workspace:create", {
+        id,
+        name,
+        resolverCount: resolvers.length,
+        assistantSkills: options.assistantSkills !== false,
+        customMountResolvers: options.mounts?.length ?? 0,
+        customSkillsResolver: Boolean(options.skills),
+        checkSkillFileMtime,
+        bm25,
+    });
+    return new Workspace({
+        id,
+        name,
+        filesystem: (context) => resolveWorkspaceFilesystem(resolvers, context),
+        ...(skills
+            ? {
+                skills,
+                checkSkillFileMtime,
+            }
+            : {}),
+        bm25,
+    });
+}
+/* ---------------------------- private helpers ---------------------------- */
+/**
+ * Map an OBO user email to their Assistant skills directory in the
+ * workspace namespace.
+ */
+function userAssistantSkillsPath(userEmail) {
+    return `/Users/${userEmail.trim()}/.assistant/skills`;
+}
+/**
+ * Return whether the request token carries a scope that allows workspace
+ * file API access (`workspace` or `all-apis` on {@link MASTRA_SCOPES_KEY}).
+ */
+function hasWorkspaceFileScope(requestContext) {
+    return token.includesAccessTokenScope(requestContext?.get(MASTRA_SCOPES_KEY), WORKSPACE_FILE_SCOPES);
+}
+/**
+ * Built-in mount resolver for Assistant `SKILL.md` trees.
+ *
+ * Mounts {@link ASSISTANT_SHARED_SKILLS_PATH} when scope checks pass and
+ * `/Users/<email>/.assistant/skills` when {@link MASTRA_USER_EMAIL_KEY} is
+ * set. Returns empty mounts when the OBO user or client is missing.
+ * Mastra owns filesystem initialization.
+ */
+function resolveAssistantSkillsMounts(context) {
+    const mounts = {};
+    const requestContext = context.requestContext;
+    if (!shouldMountAssistantSkills(requestContext)) {
+        logger.debug("assistant-skills:skipped", {
+            reason: !requestContext ? "no-request-context" : "missing-workspace-scope",
+            nodeEnv: process.env.NODE_ENV,
+            scopes: context.requestContext?.get(MASTRA_SCOPES_KEY),
+        });
+        return { mounts, skillPaths: [] };
+    }
+    const user = requestContext.get(MASTRA_USER_KEY);
+    const client = user?.executionContext.client;
+    if (!client) {
+        logger.debug("assistant-skills:skipped", {
+            reason: "missing-obo-client",
+            userId: user?.id,
+        });
+        return { mounts, skillPaths: [] };
+    }
+    mounts[ASSISTANT_WORKSPACE_SKILLS_MOUNT] = databricksFilesystem(client, ASSISTANT_SHARED_SKILLS_PATH);
+    const email = resolveScopedEmail(requestContext);
+    if (email) {
+        mounts[ASSISTANT_USER_SKILLS_MOUNT] = databricksFilesystem(client, userAssistantSkillsPath(email), false);
+    }
+    logger.debug("assistant-skills:mounted", {
+        sharedPath: ASSISTANT_SHARED_SKILLS_PATH,
+        sharedMount: ASSISTANT_WORKSPACE_SKILLS_MOUNT,
+        userMount: email ? ASSISTANT_USER_SKILLS_MOUNT : undefined,
+        userPath: email ? userAssistantSkillsPath(email) : undefined,
+        mountKeys: Object.keys(mounts),
+    });
+    return { mounts, skillPaths: Object.keys(mounts) };
+}
+/**
+ * Fill in `id` and `name` when either is omitted on {@link CreateWorkspaceOptions}.
+ * Slugifies `name` into `id`; tokenizes `id` into a display `name`.
+ */
+function resolveWorkspaceIdentity(options) {
+    let id = options.id;
+    let name = options.name;
+    if (!id) {
+        id = name ? string.toSlug(name) : "workspace";
+    }
+    if (!name) {
+        name = Array.from(string.tokenize(id)).join(" ");
+    }
+    return { id, name };
+}
+/** Collect built-in and caller-supplied mount resolvers for one workspace. */
+function buildMountResolvers(options) {
+    const resolvers = [];
+    const { assistantSkills = true, mounts } = options;
+    if (assistantSkills) {
+        resolvers.push(resolveAssistantSkillsMounts);
+    }
+    if (mounts?.length) {
+        resolvers.push(...mounts);
+    }
+    logger.debug("mounts:resolvers", {
+        assistantSkills,
+        builtInResolver: assistantSkills,
+        customResolverCount: mounts?.length ?? 0,
+        totalResolverCount: resolvers.length,
+    });
+    return resolvers;
+}
+/**
+ * Gate Assistant skill mounts on request context.
+ *
+ * Always allows mounts in development; in other environments requires
+ * {@link hasWorkspaceFileScope}.
+ */
+function shouldMountAssistantSkills(requestContext) {
+    if (!requestContext)
+        return false;
+    if (process.env.NODE_ENV === "development")
+        return true;
+    return hasWorkspaceFileScope(requestContext);
+}
+/** Read the trimmed OBO user email stamped on {@link MASTRA_USER_EMAIL_KEY}. */
+function resolveScopedEmail(requestContext) {
+    const email = requestContext?.get(MASTRA_USER_EMAIL_KEY);
+    return email?.trim() || undefined;
+}
+/** Construct a read-only {@link DatabricksWorkspaceFilesystem} for `basePath`. */
+function databricksFilesystem(client, basePath, readOnly = true) {
+    return new DatabricksWorkspaceFilesystem({
+        client,
+        basePath,
+        readOnly,
+    });
+}
+/**
+ * Run every mount resolver for one request and merge mounts plus skill paths.
+ * Later resolvers overwrite mount keys from earlier ones.
+ */
+async function resolveWorkspaceContribution(resolvers, context) {
+    const mounts = {};
+    const skillPaths = [];
+    for (const [index, resolver] of resolvers.entries()) {
+        const contribution = await resolver(context);
+        logger.debug("mounts:resolver", {
+            index,
+            mountKeys: Object.keys(contribution.mounts),
+            skillPaths: contribution.skillPaths ?? [],
+        });
+        Object.assign(mounts, contribution.mounts);
+        if (contribution.skillPaths?.length) {
+            skillPaths.push(...contribution.skillPaths);
+        }
+    }
+    logger.debug("mounts:merged", {
+        mountKeys: Object.keys(mounts),
+        skillPaths,
+    });
+    return { mounts, skillPaths };
+}
+/**
+ * Dynamic filesystem resolver passed to Mastra {@link Workspace}.
+ *
+ * Returns a {@link CompositeFilesystem} when any mount resolved; otherwise
+ * {@link emptyFilesystem}.
+ */
+async function resolveWorkspaceFilesystem(resolvers, context) {
+    const { mounts } = await resolveWorkspaceContribution(resolvers, context);
+    const mountKeys = Object.keys(mounts);
+    if (mountKeys.length === 0) {
+        logger.debug("filesystem:empty", {
+            hasRequestContext: Boolean(context.requestContext),
+        });
+        return emptyFilesystem();
+    }
+    logger.debug("filesystem:composite", { mountKeys });
+    return new CompositeFilesystem({ mounts });
+}
+/**
+ * Build the dynamic {@link SkillsResolver} that collects `skillPaths` from
+ * every mount resolver on each request.
+ */
+function buildWorkspaceSkillsResolver(resolvers) {
+    return async (context) => {
+        const { skillPaths } = await resolveWorkspaceContribution(resolvers, context);
+        logger.debug("skills:resolved", { skillPaths });
+        return skillPaths ?? [];
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspaces.js","sourceRoot":"","sources":["../../src/workspaces.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mastra workspace factory for Databricks Apps.\n *\n * Builds a per-request {@link Workspace} whose filesystem is a\n * {@link CompositeFilesystem} over Databricks paths resolved from the\n * OBO client on {@link MASTRA_USER_KEY}. Optional mount resolver\n * contributions merge extra filesystems and skill scan roots; built-in\n * Assistant skill trees are toggled with `assistantSkills` (on by default).\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { log, string, token } from \"@dbx-tools/shared-core\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport {\n  CompositeFilesystem,\n  Workspace,\n  type SkillsContext,\n  type SkillsResolver,\n  type WorkspaceFilesystem,\n} from \"@mastra/core/workspace\";\n\nimport { MASTRA_SCOPES_KEY, MASTRA_USER_EMAIL_KEY, MASTRA_USER_KEY, type User } from \"./config\";\nimport { DatabricksWorkspaceFilesystem, emptyFilesystem } from \"./filesystems\";\n\n/* ------------------------------ constants ------------------------------ */\n\n/** Shared Assistant skills tree in the workspace namespace. */\nconst ASSISTANT_SHARED_SKILLS_PATH = \"/Workspace/.assistant/skills\";\n\n/** Composite mount for {@link ASSISTANT_SHARED_SKILLS_PATH}. */\nconst ASSISTANT_WORKSPACE_SKILLS_MOUNT = \"/workspace_skills\";\n\n/** Composite mount for the caller's `/.assistant/skills` tree. */\nconst ASSISTANT_USER_SKILLS_MOUNT = \"/workspace_user_skills\";\n\n/** OAuth scopes that gate Databricks workspace file mounts. */\nconst WORKSPACE_FILE_SCOPES = [\"workspace\", \"workspace.workspace\", \"all-apis\"] as const;\n\nconst logger = log.logger(\"mastra/workspaces\");\n\n/* -------------------------------- types -------------------------------- */\n\n/** Per-request context for mount resolvers. */\ninterface WorkspaceMountContext {\n  requestContext?: RequestContext;\n}\n\n/** Mount map plus optional Mastra skill scan roots for one resolver. */\ninterface WorkspaceMountContribution {\n  mounts: Record<string, WorkspaceFilesystem>;\n  /** Paths within the composite namespace where `SKILL.md` files are scanned. */\n  skillPaths?: string[];\n}\n\n/** Contributes filesystem mounts (and optional skill paths) for one request. */\ntype WorkspaceMountResolver = (\n  context: WorkspaceMountContext,\n) => WorkspaceMountContribution | Promise<WorkspaceMountContribution>;\n\n/** Options for {@link createWorkspace}. */\nexport interface CreateWorkspaceOptions {\n  /** Workspace id; derived from `name` or `\"workspace\"` when omitted. */\n  id?: string;\n  /** Display name; derived from `id` when omitted. */\n  name?: string;\n  /**\n   * Mount read-only Assistant skill trees from `/Workspace/.assistant/skills`\n   * and `/Users/<email>/.assistant/skills`. Defaults to `true`.\n   */\n  assistantSkills?: boolean;\n  /** Extra per-request mount resolvers (run after built-in options). */\n  mounts?: WorkspaceMountResolver[];\n  /** Replace the auto-built dynamic skills resolver. */\n  skills?: SkillsResolver;\n  /** Forwarded to Mastra when skill discovery is enabled. */\n  checkSkillFileMtime?: boolean;\n  /** Enable BM25 keyword search over indexed workspace content. */\n  bm25?: boolean;\n}\n\n/**\n * Create a Mastra {@link Workspace} with per-request Databricks mounts.\n *\n * @example Assistant skills only (default for agents in this plugin)\n * ```ts\n * createWorkspace()\n * ```\n *\n * @example Assistant skills plus a custom mount resolver\n * ```ts\n * createWorkspace({\n *   assistantSkills: true,\n *   mounts: [\n *     async ({ requestContext }) => ({\n *       mounts: { \"/data\": myFilesystem },\n *       skillPaths: [],\n *     }),\n *   ],\n * })\n * ```\n */\nexport function createWorkspace(options: CreateWorkspaceOptions = {}): Workspace {\n  const { id, name } = resolveWorkspaceIdentity(options);\n  const resolvers = buildMountResolvers(options);\n  const skills =\n    options.skills ?? (resolvers.length > 0 ? buildWorkspaceSkillsResolver(resolvers) : undefined);\n  const checkSkillFileMtime = options.checkSkillFileMtime ?? options.assistantSkills !== false;\n  const bm25 = options.bm25 !== false;\n  logger.debug(\"workspace:create\", {\n    id,\n    name,\n    resolverCount: resolvers.length,\n    assistantSkills: options.assistantSkills !== false,\n    customMountResolvers: options.mounts?.length ?? 0,\n    customSkillsResolver: Boolean(options.skills),\n    checkSkillFileMtime,\n    bm25,\n  });\n\n  return new Workspace({\n    id,\n    name,\n    filesystem: (context) => resolveWorkspaceFilesystem(resolvers, context),\n    ...(skills\n      ? {\n          skills,\n          checkSkillFileMtime,\n        }\n      : {}),\n    bm25,\n  });\n}\n\n/* ---------------------------- private helpers ---------------------------- */\n\n/**\n * Map an OBO user email to their Assistant skills directory in the\n * workspace namespace.\n */\nfunction userAssistantSkillsPath(userEmail: string): string {\n  return `/Users/${userEmail.trim()}/.assistant/skills`;\n}\n\n/**\n * Return whether the request token carries a scope that allows workspace\n * file API access (`workspace` or `all-apis` on {@link MASTRA_SCOPES_KEY}).\n */\nfunction hasWorkspaceFileScope(requestContext: RequestContext | undefined): boolean {\n  return token.includesAccessTokenScope(\n    requestContext?.get(MASTRA_SCOPES_KEY),\n    WORKSPACE_FILE_SCOPES,\n  );\n}\n\n/**\n * Built-in mount resolver for Assistant `SKILL.md` trees.\n *\n * Mounts {@link ASSISTANT_SHARED_SKILLS_PATH} when scope checks pass and\n * `/Users/<email>/.assistant/skills` when {@link MASTRA_USER_EMAIL_KEY} is\n * set. Returns empty mounts when the OBO user or client is missing.\n * Mastra owns filesystem initialization.\n */\nfunction resolveAssistantSkillsMounts(context: WorkspaceMountContext): WorkspaceMountContribution {\n  const mounts: Record<string, DatabricksWorkspaceFilesystem> = {};\n  const requestContext = context.requestContext;\n\n  if (!shouldMountAssistantSkills(requestContext)) {\n    logger.debug(\"assistant-skills:skipped\", {\n      reason: !requestContext ? \"no-request-context\" : \"missing-workspace-scope\",\n      nodeEnv: process.env.NODE_ENV,\n      scopes: context.requestContext?.get(MASTRA_SCOPES_KEY),\n    });\n    return { mounts, skillPaths: [] };\n  }\n\n  const user = requestContext!.get(MASTRA_USER_KEY) as User | undefined;\n  const client = user?.executionContext.client;\n  if (!client) {\n    logger.debug(\"assistant-skills:skipped\", {\n      reason: \"missing-obo-client\",\n      userId: user?.id,\n    });\n    return { mounts, skillPaths: [] };\n  }\n\n  mounts[ASSISTANT_WORKSPACE_SKILLS_MOUNT] = databricksFilesystem(\n    client,\n    ASSISTANT_SHARED_SKILLS_PATH,\n  );\n\n  const email = resolveScopedEmail(requestContext);\n  if (email) {\n    mounts[ASSISTANT_USER_SKILLS_MOUNT] = databricksFilesystem(\n      client,\n      userAssistantSkillsPath(email),\n      false,\n    );\n  }\n\n  logger.debug(\"assistant-skills:mounted\", {\n    sharedPath: ASSISTANT_SHARED_SKILLS_PATH,\n    sharedMount: ASSISTANT_WORKSPACE_SKILLS_MOUNT,\n    userMount: email ? ASSISTANT_USER_SKILLS_MOUNT : undefined,\n    userPath: email ? userAssistantSkillsPath(email) : undefined,\n    mountKeys: Object.keys(mounts),\n  });\n\n  return { mounts, skillPaths: Object.keys(mounts) };\n}\n\n/**\n * Fill in `id` and `name` when either is omitted on {@link CreateWorkspaceOptions}.\n * Slugifies `name` into `id`; tokenizes `id` into a display `name`.\n */\nfunction resolveWorkspaceIdentity(options: CreateWorkspaceOptions): {\n  id: string;\n  name: string;\n} {\n  let id = options.id;\n  let name = options.name;\n  if (!id) {\n    id = name ? string.toSlug(name) : \"workspace\";\n  }\n  if (!name) {\n    name = Array.from(string.tokenize(id)).join(\" \");\n  }\n  return { id, name };\n}\n\n/** Collect built-in and caller-supplied mount resolvers for one workspace. */\nfunction buildMountResolvers(options: CreateWorkspaceOptions): WorkspaceMountResolver[] {\n  const resolvers: WorkspaceMountResolver[] = [];\n  const { assistantSkills = true, mounts } = options;\n  if (assistantSkills) {\n    resolvers.push(resolveAssistantSkillsMounts);\n  }\n  if (mounts?.length) {\n    resolvers.push(...mounts);\n  }\n  logger.debug(\"mounts:resolvers\", {\n    assistantSkills,\n    builtInResolver: assistantSkills,\n    customResolverCount: mounts?.length ?? 0,\n    totalResolverCount: resolvers.length,\n  });\n  return resolvers;\n}\n\n/**\n * Gate Assistant skill mounts on request context.\n *\n * Always allows mounts in development; in other environments requires\n * {@link hasWorkspaceFileScope}.\n */\nfunction shouldMountAssistantSkills(\n  requestContext: RequestContext | undefined,\n): requestContext is RequestContext {\n  if (!requestContext) return false;\n  if (process.env.NODE_ENV === \"development\") return true;\n  return hasWorkspaceFileScope(requestContext);\n}\n\n/** Read the trimmed OBO user email stamped on {@link MASTRA_USER_EMAIL_KEY}. */\nfunction resolveScopedEmail(requestContext: RequestContext | undefined): string | undefined {\n  const email = requestContext?.get(MASTRA_USER_EMAIL_KEY) as string | undefined;\n  return email?.trim() || undefined;\n}\n\n/** Construct a read-only {@link DatabricksWorkspaceFilesystem} for `basePath`. */\nfunction databricksFilesystem(\n  client: WorkspaceClient,\n  basePath: string,\n  readOnly: boolean = true,\n): DatabricksWorkspaceFilesystem {\n  return new DatabricksWorkspaceFilesystem({\n    client,\n    basePath,\n    readOnly,\n  });\n}\n\n/**\n * Run every mount resolver for one request and merge mounts plus skill paths.\n * Later resolvers overwrite mount keys from earlier ones.\n */\nasync function resolveWorkspaceContribution(\n  resolvers: WorkspaceMountResolver[],\n  context: WorkspaceMountContext,\n): Promise<WorkspaceMountContribution> {\n  const mounts: Record<string, WorkspaceFilesystem> = {};\n  const skillPaths: string[] = [];\n\n  for (const [index, resolver] of resolvers.entries()) {\n    const contribution = await resolver(context);\n    logger.debug(\"mounts:resolver\", {\n      index,\n      mountKeys: Object.keys(contribution.mounts),\n      skillPaths: contribution.skillPaths ?? [],\n    });\n    Object.assign(mounts, contribution.mounts);\n    if (contribution.skillPaths?.length) {\n      skillPaths.push(...contribution.skillPaths);\n    }\n  }\n\n  logger.debug(\"mounts:merged\", {\n    mountKeys: Object.keys(mounts),\n    skillPaths,\n  });\n\n  return { mounts, skillPaths };\n}\n\n/**\n * Dynamic filesystem resolver passed to Mastra {@link Workspace}.\n *\n * Returns a {@link CompositeFilesystem} when any mount resolved; otherwise\n * {@link emptyFilesystem}.\n */\nasync function resolveWorkspaceFilesystem(\n  resolvers: WorkspaceMountResolver[],\n  context: WorkspaceMountContext,\n): Promise<WorkspaceFilesystem> {\n  const { mounts } = await resolveWorkspaceContribution(resolvers, context);\n  const mountKeys = Object.keys(mounts);\n  if (mountKeys.length === 0) {\n    logger.debug(\"filesystem:empty\", {\n      hasRequestContext: Boolean(context.requestContext),\n    });\n    return emptyFilesystem();\n  }\n  logger.debug(\"filesystem:composite\", { mountKeys });\n  return new CompositeFilesystem({ mounts });\n}\n\n/**\n * Build the dynamic {@link SkillsResolver} that collects `skillPaths` from\n * every mount resolver on each request.\n */\nfunction buildWorkspaceSkillsResolver(resolvers: WorkspaceMountResolver[]): SkillsResolver {\n  return async (context: SkillsContext) => {\n    const { skillPaths } = await resolveWorkspaceContribution(resolvers, context);\n    logger.debug(\"skills:resolved\", { skillPaths });\n    return skillPaths ?? [];\n  };\n}\n"]}

package/lib/src/writer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared helper for publishing events through Mastra's
+ * `ctx.writer`. Centralizes the "the downstream stream may already
+ * be closed, don't take the whole tool down" pattern that the
+ * Genie agent and chart tool both need.
+ *
+ * Failures are logged at `warn` (a persistently-closed writer is
+ * the most likely culprit when events go missing client-side) but
+ * swallowed so a cancelled request or a client that navigated
+ * away can't crash a tool mid-flight.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+import type { MastraWriter } from "@dbx-tools/shared-mastra";
+/**
+ * Best-effort `writer.write`. No-op when `writer` is undefined;
+ * caught errors are logged via `log.warn("writer:error", ...)`
+ * along with any caller-supplied `context` fields (e.g. a
+ * `chartId` or `messageId`) so the warning is greppable per
+ * resource.
+ *
+ * Returns when the write resolves or rejects; never throws.
+ */
+export declare function safeWrite(log: log.Logger, writer: MastraWriter | undefined, chunk: unknown, context?: Record<string, unknown>): Promise<void>;

package/lib/src/writer.js

@@ -0,0 +1,40 @@
+/**
+ * Shared helper for publishing events through Mastra's
+ * `ctx.writer`. Centralizes the "the downstream stream may already
+ * be closed, don't take the whole tool down" pattern that the
+ * Genie agent and chart tool both need.
+ *
+ * Failures are logged at `warn` (a persistently-closed writer is
+ * the most likely culprit when events go missing client-side) but
+ * swallowed so a cancelled request or a client that navigated
+ * away can't crash a tool mid-flight.
+ *
+ * @module
+ */
+import { error } from "@dbx-tools/shared-core";
+/**
+ * Best-effort `writer.write`. No-op when `writer` is undefined;
+ * caught errors are logged via `log.warn("writer:error", ...)`
+ * along with any caller-supplied `context` fields (e.g. a
+ * `chartId` or `messageId`) so the warning is greppable per
+ * resource.
+ *
+ * Returns when the write resolves or rejects; never throws.
+ */
+export async function safeWrite(log, writer, chunk, context = {}) {
+    if (!writer) {
+        log.debug("writer:no-writer", context);
+        return;
+    }
+    try {
+        await writer.write(chunk);
+        log.debug("writer:ok", context);
+    }
+    catch (err) {
+        log.warn("writer:error", {
+            ...context,
+            error: error.errorMessage(err),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/agents.ts","../src/chart.ts","../src/config.ts","../src/defaults.ts","../src/filesystems.ts","../src/genie.ts","../src/history.ts","../src/mcp.ts","../src/memory.ts","../src/mlflow.ts","../src/model.ts","../src/observability.ts","../src/pagination.ts","../src/plugin.ts","../src/processors.ts","../src/rest.ts","../src/server.ts","../src/serving-sanitize.ts","../src/serving.ts","../src/statement.ts","../src/storage-schema.ts","../src/summarize.ts","../src/threads.ts","../src/validation.ts","../src/workspaces.ts","../src/writer.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -28,30 +28,34 @@
     "express": "^5.1.0",
     "pg": "^8.22.0",
     "zod": "4.3.6",
-    "@dbx-tools/appkit": "0.3.44",
-    "@dbx-tools/genie": "0.3.44",
-    "@dbx-tools/core": "0.3.44",
-    "@dbx-tools/model": "0.3.44",
-    "@dbx-tools/shared-core": "0.3.44",
-    "@dbx-tools/shared-genie": "0.3.44",
-    "@dbx-tools/shared-mastra": "0.3.44",
-    "@dbx-tools/shared-model": "0.3.44"
+    "@dbx-tools/appkit": "0.4.0",
+    "@dbx-tools/core": "0.4.0",
+    "@dbx-tools/genie": "0.4.0",
+    "@dbx-tools/model": "0.4.0",
+    "@dbx-tools/shared-core": "0.4.0",
+    "@dbx-tools/shared-mastra": "0.4.0",
+    "@dbx-tools/shared-model": "0.4.0",
+    "@dbx-tools/shared-genie": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.44",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "dbxToolsConfig": {
     "tags": [