@dbx-tools/appkit-mastra 0.6.9 → 0.6.10

package/lib/src/databricks-aitools.d.ts

@@ -3,28 +3,23 @@
  *
  * Databricks AI Tools (`databricks aitools`) are Databricks-owned Agent-Skill
  * (`SKILL.md`) trees installed and kept up to date through the Databricks CLI.
- * The CLI installs them globally under `~/.databricks/aitools/skills/<name>/`
- * (with a `.state.json` manifest) and can also write a resolved, agent-agnostic
- * copy to any directory with `databricks aitools install --path <dir>
- * --skills-only`.
- *
- * {@link provisionDatabricksAITools} folds those skills into a Mastra workspace
- * as extra LOCAL skill scan paths so an agent can use them without anyone
- * hand-copying `SKILL.md` files. It never reimplements the CLI's sourcing: it
- * either points Mastra at the already-installed global tree, or shells out to
- * the CLI to materialize a curated subset into a temp dir.
+ * {@link provisionDatabricksAITools} shells out to the CLI
+ * (`databricks aitools install --path <dir>`) to materialize a resolved,
+ * agent-agnostic skill set into a directory, then hands it to Mastra as an
+ * extra LOCAL skill scan path - so an agent gets first-class Databricks skills
+ * without anyone hand-copying `SKILL.md` files. It never reimplements the CLI's
+ * sourcing; the CLI is the source of truth.
  *
  * The option is `false | true | "auto" | DatabricksAIToolsOptions`:
  *
  * - `false` (default) - off.
- * - `"auto"` - enable only when the global tree already exists OR the
- *   `databricks` CLI is resolvable; otherwise silently no-op. The "on if the
- *   CLI is around" default.
- * - `true` - required: fail startup (subject to `failOnError`) when neither the
- *   installed tree nor the CLI can supply skills.
- * - an options bag for a specific `skills` subset, `experimental` skills, a
- *   `refresh` that re-runs the CLI even when a tree exists, or an explicit
- *   `path`.
+ * - `"auto"` - run the CLI when it's installed; if the `databricks` CLI isn't
+ *   available, log and move on (never fails startup). The "on if the CLI is
+ *   around" default.
+ * - `true` (`"require"`) - require the CLI: fail startup (subject to
+ *   `failOnError`) when it isn't available or produces nothing.
+ * - an options bag for a specific `skills` subset, `experimental` skills, an
+ *   explicit output `path`, or a custom `cli` path.
  *
  * @module
  */
@@ -33,22 +28,17 @@ export type DatabricksAIToolsMode = "auto" | "require";
 /** Options for {@link provisionDatabricksAITools}. */
 export interface DatabricksAIToolsOptions {
     /**
-     * `"auto"` (default) enables only when the installed tree exists or the CLI
-     * is resolvable; `"require"` fails startup when neither can supply skills.
+     * `"auto"` (default) runs the CLI when installed and logs-and-continues when
+     * it isn't; `"require"` fails startup when the CLI can't supply skills.
      */
     mode?: DatabricksAIToolsMode;
     /** Install only these skill names (comma/space list or array). */
     skills?: string | string[];
     /** Include experimental skills when the CLI has to fetch. */
     experimental?: boolean;
-    /**
-     * Re-run the CLI to (re)materialize skills into a fresh dir even when the
-     * global tree already exists. Defaults to `false` (reuse the installed tree).
-     */
-    refresh?: boolean;
     /**
      * Explicit directory to materialize skills into with the CLI. Defaults to a
-     * temp dir. Ignored when the installed global tree is used as-is.
+     * fresh {@link localFS.tmpFS} root.
      */
     path?: string;
     /** Absolute path to the `databricks` CLI. Defaults to `databricks` on PATH. */
@@ -66,7 +56,7 @@ export interface ProvisionedDatabricksAITools {
     /** Extra LOCAL skill scan paths to hand Mastra. Empty when disabled/unresolved. */
     localSkillPaths: string[];
     /** How the skills were sourced, for logging. */
-    source?: "installed" | "cli";
+    source?: "cli";
 }
 /** Normalize the `databricksAITools` option into a flat options bag, or `undefined` when off. */
 export declare function normalizeDatabricksAIToolsOption(option: DatabricksAIToolsOption | undefined): DatabricksAIToolsOptions | undefined;

package/lib/src/databricks-aitools.js

@@ -3,42 +3,35 @@
  *
  * Databricks AI Tools (`databricks aitools`) are Databricks-owned Agent-Skill
  * (`SKILL.md`) trees installed and kept up to date through the Databricks CLI.
- * The CLI installs them globally under `~/.databricks/aitools/skills/<name>/`
- * (with a `.state.json` manifest) and can also write a resolved, agent-agnostic
- * copy to any directory with `databricks aitools install --path <dir>
- * --skills-only`.
- *
- * {@link provisionDatabricksAITools} folds those skills into a Mastra workspace
- * as extra LOCAL skill scan paths so an agent can use them without anyone
- * hand-copying `SKILL.md` files. It never reimplements the CLI's sourcing: it
- * either points Mastra at the already-installed global tree, or shells out to
- * the CLI to materialize a curated subset into a temp dir.
+ * {@link provisionDatabricksAITools} shells out to the CLI
+ * (`databricks aitools install --path <dir>`) to materialize a resolved,
+ * agent-agnostic skill set into a directory, then hands it to Mastra as an
+ * extra LOCAL skill scan path - so an agent gets first-class Databricks skills
+ * without anyone hand-copying `SKILL.md` files. It never reimplements the CLI's
+ * sourcing; the CLI is the source of truth.
  *
  * The option is `false | true | "auto" | DatabricksAIToolsOptions`:
  *
  * - `false` (default) - off.
- * - `"auto"` - enable only when the global tree already exists OR the
- *   `databricks` CLI is resolvable; otherwise silently no-op. The "on if the
- *   CLI is around" default.
- * - `true` - required: fail startup (subject to `failOnError`) when neither the
- *   installed tree nor the CLI can supply skills.
- * - an options bag for a specific `skills` subset, `experimental` skills, a
- *   `refresh` that re-runs the CLI even when a tree exists, or an explicit
- *   `path`.
+ * - `"auto"` - run the CLI when it's installed; if the `databricks` CLI isn't
+ *   available, log and move on (never fails startup). The "on if the CLI is
+ *   around" default.
+ * - `true` (`"require"`) - require the CLI: fail startup (subject to
+ *   `failOnError`) when it isn't available or produces nothing.
+ * - an options bag for a specific `skills` subset, `experimental` skills, an
+ *   explicit output `path`, or a custom `cli` path.
  *
  * @module
  */
-import { mkdtemp } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "@dbx-tools/core";
+import { exec } from "@dbx-tools/core";
+import { localFS } from "@dbx-tools/fs";
 import { error, log, string } from "@dbx-tools/shared-core";
 const logger = log.logger("mastra/databricks-aitools");
-/** Global skills tree the `databricks aitools` CLI installs into. */
-const GLOBAL_AITOOLS_SKILLS_PATH = join(homedir(), ".databricks", "aitools", "skills");
 /** The Databricks CLI binary name; resolved on `PATH`. */
 const DATABRICKS_CLI = "databricks";
+/** Stable temp directory the CLI's skill tree is rebuilt into each boot. */
+const SKILLS_CACHE_DIR = "databricks-aitools";
 /* ------------------------------- helpers ------------------------------- */
 /** Normalize the `databricksAITools` option into a flat options bag, or `undefined` when off. */
 export function normalizeDatabricksAIToolsOption(option) {
@@ -67,30 +60,22 @@ export async function provisionDatabricksAITools(option) {
         return empty;
     const mode = options.mode ?? "auto";
     const failOnError = options.failOnError ?? mode === "require";
-    const wantsCliFetch = options.refresh === true ||
-        options.path !== undefined ||
-        string.parseList(options.skills).length > 0 ||
-        options.experimental === true;
     try {
-        // Fast path: reuse the already-installed global tree, no CLI call.
-        if (!wantsCliFetch && installedTreeExists()) {
-            logger.debug("using installed aitools tree", { path: GLOBAL_AITOOLS_SKILLS_PATH });
-            return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: "installed" };
-        }
+        // The `databricks` CLI is the source of truth. When it's resolvable, run
+        // `databricks aitools install --path <dir>` to materialize a fresh,
+        // agent-agnostic skill set into a dir Mastra can scan.
         const cliPath = await resolveCli(options.cli);
         if (cliPath) {
             const dir = await materializeViaCli(cliPath, options);
             if (dir)
                 return { localSkillPaths: [dir], source: "cli" };
         }
-        // Nothing fetched. Fall back to the installed tree if it's there.
-        if (installedTreeExists()) {
-            return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: "installed" };
-        }
+        // CLI not installed (or produced nothing). "auto" logs and moves on;
+        // "require" fails startup unless `failOnError: false`.
         if (failOnError) {
-            throw new Error(`Databricks AI Tools requested but no installed skills tree at "${GLOBAL_AITOOLS_SKILLS_PATH}" and the "${DATABRICKS_CLI}" CLI is not resolvable. Install with \`databricks aitools install\`, or set databricksAITools: "auto".`);
+            throw new Error(`Databricks AI Tools required but the "${DATABRICKS_CLI}" CLI is not available. Install the Databricks CLI (\`databricks aitools install\`), or set databricksAITools: "auto".`);
         }
-        logger.debug("databricks aitools unavailable; skipping");
+        logger.info("databricks CLI not available; skipping AI Tools skills");
         return empty;
     }
     catch (err) {
@@ -101,15 +86,11 @@ export async function provisionDatabricksAITools(option) {
         return empty;
     }
 }
-/** Whether the CLI's global skills tree exists and holds at least one skill. */
-function installedTreeExists() {
-    return existsSync(GLOBAL_AITOOLS_SKILLS_PATH);
-}
 /** Resolve the `databricks` CLI, returning its invocation path or `undefined`. */
 async function resolveCli(cli) {
     const command = string.trimToNull(cli) ?? DATABRICKS_CLI;
     try {
-        const result = await spawn(command, ["aitools", "version"], {
+        const result = await exec.spawn(command, ["aitools", "version"], {
             stdout: "capture",
             stderr: "capture",
             check: false,
@@ -123,18 +104,43 @@ async function resolveCli(cli) {
     return undefined;
 }
 /**
- * Run `databricks aitools install --path <dir> --skills-only` to materialize a
- * resolved, agent-agnostic skill set into a directory (no agents, no state).
+ * Run `databricks aitools install --path <dir>` to materialize a resolved,
+ * agent-agnostic skill set into a directory (writes `<name>/SKILL.md` trees,
+ * no agents, no state) Mastra can then scan.
  */
 async function materializeViaCli(cli, options) {
-    const dir = string.trimToNull(options.path) ?? (await mkdtemp(join(tmpdir(), "databricks-aitools-")));
-    const args = ["aitools", "install", "--path", dir, "--skills-only"];
+    const explicit = string.trimToNull(options.path);
+    let dir;
+    if (explicit) {
+        // An explicit path is the caller's to own - install straight into it.
+        await installSkills(cli, options, explicit);
+        dir = explicit;
+    }
+    else {
+        // The resolved skill set is the same on almost every boot, so rebuild ONE
+        // stable temp tree rather than leaving a fresh scratch dir behind each
+        // time. The CLI writes into a throwaway root that only replaces the stable
+        // one on success, so a failed install keeps the previous skills usable.
+        const stable = await localFS.rebuildFS(SKILLS_CACHE_DIR, (scratch) => installSkills(cli, options, scratch.root));
+        dir = stable.root;
+    }
+    if (!existsSync(dir))
+        return undefined;
+    logger.debug("materialized aitools skills via CLI", {
+        path: dir,
+        skills: string.parseList(options.skills),
+    });
+    return dir;
+}
+/** Run `databricks aitools install --path <dir>`, failing loudly on a non-zero exit. */
+async function installSkills(cli, options, dir) {
+    const args = ["aitools", "install", "--path", dir];
     const skills = string.parseList(options.skills);
     if (skills.length > 0)
         args.push("--skills", skills.join(","));
     if (options.experimental)
         args.push("--experimental");
-    const result = await spawn(cli, args, {
+    const result = await exec.spawn(cli, args, {
         stdout: "capture",
         stderr: "capture",
         check: false,
@@ -142,9 +148,5 @@ async function materializeViaCli(cli, options) {
     if (result.exitCode !== 0) {
         throw new Error(`databricks aitools install failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
     }
-    if (!existsSync(dir))
-        return undefined;
-    logger.debug("materialized aitools skills via CLI", { path: dir, skills });
-    return dir;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"databricks-aitools.js","sourceRoot":"","sources":["../../src/databricks-aitools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAE5D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,2BAA2B,CAAC,CAAC;AAEvD,qEAAqE;AACrE,MAAM,0BAA0B,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;AAEvF,0DAA0D;AAC1D,MAAM,cAAc,GAAG,YAAY,CAAC;AAgDpC,6EAA6E;AAE7E,iGAAiG;AACjG,MAAM,UAAU,gCAAgC,CAC9C,MAA2C;IAE3C,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,KAAK;QAAE,OAAO,SAAS,CAAC;IAC/D,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAChD,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AACpD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,MAA2C;IAE3C,MAAM,OAAO,GAAG,gCAAgC,CAAC,MAAM,CAAC,CAAC;IACzD,MAAM,KAAK,GAAiC,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC;IACpE,IAAI,CAAC,OAAO;QAAE,OAAO,KAAK,CAAC;IAE3B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,MAAM,CAAC;IACpC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,IAAI,KAAK,SAAS,CAAC;IAC9D,MAAM,aAAa,GACjB,OAAO,CAAC,OAAO,KAAK,IAAI;QACxB,OAAO,CAAC,IAAI,KAAK,SAAS;QAC1B,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC;QAC3C,OAAO,CAAC,YAAY,KAAK,IAAI,CAAC;IAEhC,IAAI,CAAC;QACH,mEAAmE;QACnE,IAAI,CAAC,aAAa,IAAI,mBAAmB,EAAE,EAAE,CAAC;YAC5C,MAAM,CAAC,KAAK,CAAC,8BAA8B,EAAE,EAAE,IAAI,EAAE,0BAA0B,EAAE,CAAC,CAAC;YACnF,OAAO,EAAE,eAAe,EAAE,CAAC,0BAA0B,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;QAChF,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9C,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,GAAG,GAAG,MAAM,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YACtD,IAAI,GAAG;gBAAE,OAAO,EAAE,eAAe,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QAC5D,CAAC;QAED,kEAAkE;QAClE,IAAI,mBAAmB,EAAE,EAAE,CAAC;YAC1B,OAAO,EAAE,eAAe,EAAE,CAAC,0BAA0B,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;QAChF,CAAC;QAED,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACb,kEAAkE,0BAA0B,cAAc,cAAc,yGAAyG,CAClO,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC;QACzD,OAAO,KAAK,CAAC;IACf,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACb,mDAAmD,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,EAC5E,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAC9B,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC3D,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,gFAAgF;AAChF,SAAS,mBAAmB;IAC1B,OAAO,UAAU,CAAC,0BAA0B,CAAC,CAAC;AAChD,CAAC;AAED,kFAAkF;AAClF,KAAK,UAAU,UAAU,CAAC,GAAuB;IAC/C,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,cAAc,CAAC;IACzD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE;YAC1D,MAAM,EAAE,SAAS;YACjB,MAAM,EAAE,SAAS;YACjB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC;YAAE,OAAO,OAAO,CAAC;IAC5C,CAAC;IAAC,MAAM,CAAC;QACP,mEAAmE;IACrE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,iBAAiB,CAC9B,GAAW,EACX,OAAiC;IAEjC,MAAM,GAAG,GACP,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAC5F,MAAM,IAAI,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,CAAC,CAAC;IACpE,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/D,IAAI,OAAO,CAAC,YAAY;QAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAEtD,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE;QACpC,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,SAAS;QACjB,KAAK,EAAE,KAAK;KACb,CAAC,CAAC;IACH,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,2CAA2C,MAAM,CAAC,QAAQ,MAAM,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,CACjG,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACvC,MAAM,CAAC,KAAK,CAAC,qCAAqC,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3E,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["/**\n * Startup provisioning of Databricks AI Tools skills for a Mastra workspace.\n *\n * Databricks AI Tools (`databricks aitools`) are Databricks-owned Agent-Skill\n * (`SKILL.md`) trees installed and kept up to date through the Databricks CLI.\n * The CLI installs them globally under `~/.databricks/aitools/skills/<name>/`\n * (with a `.state.json` manifest) and can also write a resolved, agent-agnostic\n * copy to any directory with `databricks aitools install --path <dir>\n * --skills-only`.\n *\n * {@link provisionDatabricksAITools} folds those skills into a Mastra workspace\n * as extra LOCAL skill scan paths so an agent can use them without anyone\n * hand-copying `SKILL.md` files. It never reimplements the CLI's sourcing: it\n * either points Mastra at the already-installed global tree, or shells out to\n * the CLI to materialize a curated subset into a temp dir.\n *\n * The option is `false | true | \"auto\" | DatabricksAIToolsOptions`:\n *\n * - `false` (default) - off.\n * - `\"auto\"` - enable only when the global tree already exists OR the\n *   `databricks` CLI is resolvable; otherwise silently no-op. The \"on if the\n *   CLI is around\" default.\n * - `true` - required: fail startup (subject to `failOnError`) when neither the\n *   installed tree nor the CLI can supply skills.\n * - an options bag for a specific `skills` subset, `experimental` skills, a\n *   `refresh` that re-runs the CLI even when a tree exists, or an explicit\n *   `path`.\n *\n * @module\n */\n\nimport { mkdtemp } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport { homedir, tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { spawn } from \"@dbx-tools/core\";\nimport { error, log, string } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"mastra/databricks-aitools\");\n\n/** Global skills tree the `databricks aitools` CLI installs into. */\nconst GLOBAL_AITOOLS_SKILLS_PATH = join(homedir(), \".databricks\", \"aitools\", \"skills\");\n\n/** The Databricks CLI binary name; resolved on `PATH`. */\nconst DATABRICKS_CLI = \"databricks\";\n\n/* -------------------------------- types -------------------------------- */\n\n/** How aggressively to enable Databricks AI Tools skills. */\nexport type DatabricksAIToolsMode = \"auto\" | \"require\";\n\n/** Options for {@link provisionDatabricksAITools}. */\nexport interface DatabricksAIToolsOptions {\n  /**\n   * `\"auto\"` (default) enables only when the installed tree exists or the CLI\n   * is resolvable; `\"require\"` fails startup when neither can supply skills.\n   */\n  mode?: DatabricksAIToolsMode;\n  /** Install only these skill names (comma/space list or array). */\n  skills?: string | string[];\n  /** Include experimental skills when the CLI has to fetch. */\n  experimental?: boolean;\n  /**\n   * Re-run the CLI to (re)materialize skills into a fresh dir even when the\n   * global tree already exists. Defaults to `false` (reuse the installed tree).\n   */\n  refresh?: boolean;\n  /**\n   * Explicit directory to materialize skills into with the CLI. Defaults to a\n   * temp dir. Ignored when the installed global tree is used as-is.\n   */\n  path?: string;\n  /** Absolute path to the `databricks` CLI. Defaults to `databricks` on PATH. */\n  cli?: string;\n  /**\n   * Fail app startup when required skills can't be provisioned. Defaults to\n   * `true` for `mode: \"require\"` and `false` for `\"auto\"`.\n   */\n  failOnError?: boolean;\n}\n\n/** The `databricksAITools` config option: a toggle, `\"auto\"`, or an options bag. */\nexport type DatabricksAIToolsOption = boolean | \"auto\" | DatabricksAIToolsOptions;\n\n/** What {@link provisionDatabricksAITools} resolved. */\nexport interface ProvisionedDatabricksAITools {\n  /** Extra LOCAL skill scan paths to hand Mastra. Empty when disabled/unresolved. */\n  localSkillPaths: string[];\n  /** How the skills were sourced, for logging. */\n  source?: \"installed\" | \"cli\";\n}\n\n/* ------------------------------- helpers ------------------------------- */\n\n/** Normalize the `databricksAITools` option into a flat options bag, or `undefined` when off. */\nexport function normalizeDatabricksAIToolsOption(\n  option: DatabricksAIToolsOption | undefined,\n): DatabricksAIToolsOptions | undefined {\n  if (option === undefined || option === false) return undefined;\n  if (option === true) return { mode: \"require\" };\n  if (option === \"auto\") return { mode: \"auto\" };\n  return { mode: option.mode ?? \"auto\", ...option };\n}\n\n/**\n * Materialize Databricks AI Tools skills at app startup and return them as\n * extra local skill scan paths.\n *\n * Resolution: reuse the installed global tree when present (no CLI call) unless\n * `refresh`/`skills`/`path` ask for a fresh CLI materialization; otherwise run\n * `databricks aitools install --path <dir> --skills-only` when the CLI resolves.\n * A `\"require\"` provision that yields nothing fails startup unless\n * `failOnError: false`.\n */\nexport async function provisionDatabricksAITools(\n  option: DatabricksAIToolsOption | undefined,\n): Promise<ProvisionedDatabricksAITools> {\n  const options = normalizeDatabricksAIToolsOption(option);\n  const empty: ProvisionedDatabricksAITools = { localSkillPaths: [] };\n  if (!options) return empty;\n\n  const mode = options.mode ?? \"auto\";\n  const failOnError = options.failOnError ?? mode === \"require\";\n  const wantsCliFetch =\n    options.refresh === true ||\n    options.path !== undefined ||\n    string.parseList(options.skills).length > 0 ||\n    options.experimental === true;\n\n  try {\n    // Fast path: reuse the already-installed global tree, no CLI call.\n    if (!wantsCliFetch && installedTreeExists()) {\n      logger.debug(\"using installed aitools tree\", { path: GLOBAL_AITOOLS_SKILLS_PATH });\n      return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: \"installed\" };\n    }\n\n    const cliPath = await resolveCli(options.cli);\n    if (cliPath) {\n      const dir = await materializeViaCli(cliPath, options);\n      if (dir) return { localSkillPaths: [dir], source: \"cli\" };\n    }\n\n    // Nothing fetched. Fall back to the installed tree if it's there.\n    if (installedTreeExists()) {\n      return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: \"installed\" };\n    }\n\n    if (failOnError) {\n      throw new Error(\n        `Databricks AI Tools requested but no installed skills tree at \"${GLOBAL_AITOOLS_SKILLS_PATH}\" and the \"${DATABRICKS_CLI}\" CLI is not resolvable. Install with \\`databricks aitools install\\`, or set databricksAITools: \"auto\".`,\n      );\n    }\n    logger.debug(\"databricks aitools unavailable; skipping\");\n    return empty;\n  } catch (err) {\n    if (failOnError) {\n      throw new Error(\n        `failed to provision Databricks AI Tools skills: ${error.errorMessage(err)}`,\n        { cause: error.toError(err) },\n      );\n    }\n    logger.warn(\"skipped\", { error: error.errorMessage(err) });\n    return empty;\n  }\n}\n\n/** Whether the CLI's global skills tree exists and holds at least one skill. */\nfunction installedTreeExists(): boolean {\n  return existsSync(GLOBAL_AITOOLS_SKILLS_PATH);\n}\n\n/** Resolve the `databricks` CLI, returning its invocation path or `undefined`. */\nasync function resolveCli(cli: string | undefined): Promise<string | undefined> {\n  const command = string.trimToNull(cli) ?? DATABRICKS_CLI;\n  try {\n    const result = await spawn(command, [\"aitools\", \"version\"], {\n      stdout: \"capture\",\n      stderr: \"capture\",\n      check: false,\n    });\n    if (result.exitCode === 0) return command;\n  } catch {\n    // CLI absent or `aitools` unsupported - caller falls back / fails.\n  }\n  return undefined;\n}\n\n/**\n * Run `databricks aitools install --path <dir> --skills-only` to materialize a\n * resolved, agent-agnostic skill set into a directory (no agents, no state).\n */\nasync function materializeViaCli(\n  cli: string,\n  options: DatabricksAIToolsOptions,\n): Promise<string | undefined> {\n  const dir =\n    string.trimToNull(options.path) ?? (await mkdtemp(join(tmpdir(), \"databricks-aitools-\")));\n  const args = [\"aitools\", \"install\", \"--path\", dir, \"--skills-only\"];\n  const skills = string.parseList(options.skills);\n  if (skills.length > 0) args.push(\"--skills\", skills.join(\",\"));\n  if (options.experimental) args.push(\"--experimental\");\n\n  const result = await spawn(cli, args, {\n    stdout: \"capture\",\n    stderr: \"capture\",\n    check: false,\n  });\n  if (result.exitCode !== 0) {\n    throw new Error(\n      `databricks aitools install failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`,\n    );\n  }\n  if (!existsSync(dir)) return undefined;\n  logger.debug(\"materialized aitools skills via CLI\", { path: dir, skills });\n  return dir;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"databricks-aitools.js","sourceRoot":"","sources":["../../src/databricks-aitools.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Startup provisioning of Databricks AI Tools skills for a Mastra workspace.\n *\n * Databricks AI Tools (`databricks aitools`) are Databricks-owned Agent-Skill\n * (`SKILL.md`) trees installed and kept up to date through the Databricks CLI.\n * {@link provisionDatabricksAITools} shells out to the CLI\n * (`databricks aitools install --path <dir>`) to materialize a resolved,\n * agent-agnostic skill set into a directory, then hands it to Mastra as an\n * extra LOCAL skill scan path - so an agent gets first-class Databricks skills\n * without anyone hand-copying `SKILL.md` files. It never reimplements the CLI's\n * sourcing; the CLI is the source of truth.\n *\n * The option is `false | true | \"auto\" | DatabricksAIToolsOptions`:\n *\n * - `false` (default) - off.\n * - `\"auto\"` - run the CLI when it's installed; if the `databricks` CLI isn't\n *   available, log and move on (never fails startup). The \"on if the CLI is\n *   around\" default.\n * - `true` (`\"require\"`) - require the CLI: fail startup (subject to\n *   `failOnError`) when it isn't available or produces nothing.\n * - an options bag for a specific `skills` subset, `experimental` skills, an\n *   explicit output `path`, or a custom `cli` path.\n *\n * @module\n */\n\nimport { existsSync } from \"node:fs\";\nimport { exec } from \"@dbx-tools/core\";\nimport { localFS } from \"@dbx-tools/fs\";\nimport { error, log, string } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"mastra/databricks-aitools\");\n\n/** The Databricks CLI binary name; resolved on `PATH`. */\nconst DATABRICKS_CLI = \"databricks\";\n\n/** Stable temp directory the CLI's skill tree is rebuilt into each boot. */\nconst SKILLS_CACHE_DIR = \"databricks-aitools\";\n\n/* -------------------------------- types -------------------------------- */\n\n/** How aggressively to enable Databricks AI Tools skills. */\nexport type DatabricksAIToolsMode = \"auto\" | \"require\";\n\n/** Options for {@link provisionDatabricksAITools}. */\nexport interface DatabricksAIToolsOptions {\n  /**\n   * `\"auto\"` (default) runs the CLI when installed and logs-and-continues when\n   * it isn't; `\"require\"` fails startup when the CLI can't supply skills.\n   */\n  mode?: DatabricksAIToolsMode;\n  /** Install only these skill names (comma/space list or array). */\n  skills?: string | string[];\n  /** Include experimental skills when the CLI has to fetch. */\n  experimental?: boolean;\n  /**\n   * Explicit directory to materialize skills into with the CLI. Defaults to a\n   * fresh {@link localFS.tmpFS} root.\n   */\n  path?: string;\n  /** Absolute path to the `databricks` CLI. Defaults to `databricks` on PATH. */\n  cli?: string;\n  /**\n   * Fail app startup when required skills can't be provisioned. Defaults to\n   * `true` for `mode: \"require\"` and `false` for `\"auto\"`.\n   */\n  failOnError?: boolean;\n}\n\n/** The `databricksAITools` config option: a toggle, `\"auto\"`, or an options bag. */\nexport type DatabricksAIToolsOption = boolean | \"auto\" | DatabricksAIToolsOptions;\n\n/** What {@link provisionDatabricksAITools} resolved. */\nexport interface ProvisionedDatabricksAITools {\n  /** Extra LOCAL skill scan paths to hand Mastra. Empty when disabled/unresolved. */\n  localSkillPaths: string[];\n  /** How the skills were sourced, for logging. */\n  source?: \"cli\";\n}\n\n/* ------------------------------- helpers ------------------------------- */\n\n/** Normalize the `databricksAITools` option into a flat options bag, or `undefined` when off. */\nexport function normalizeDatabricksAIToolsOption(\n  option: DatabricksAIToolsOption | undefined,\n): DatabricksAIToolsOptions | undefined {\n  if (option === undefined || option === false) return undefined;\n  if (option === true) return { mode: \"require\" };\n  if (option === \"auto\") return { mode: \"auto\" };\n  return { mode: option.mode ?? \"auto\", ...option };\n}\n\n/**\n * Materialize Databricks AI Tools skills at app startup and return them as\n * extra local skill scan paths.\n *\n * Resolution: reuse the installed global tree when present (no CLI call) unless\n * `refresh`/`skills`/`path` ask for a fresh CLI materialization; otherwise run\n * `databricks aitools install --path <dir> --skills-only` when the CLI resolves.\n * A `\"require\"` provision that yields nothing fails startup unless\n * `failOnError: false`.\n */\nexport async function provisionDatabricksAITools(\n  option: DatabricksAIToolsOption | undefined,\n): Promise<ProvisionedDatabricksAITools> {\n  const options = normalizeDatabricksAIToolsOption(option);\n  const empty: ProvisionedDatabricksAITools = { localSkillPaths: [] };\n  if (!options) return empty;\n\n  const mode = options.mode ?? \"auto\";\n  const failOnError = options.failOnError ?? mode === \"require\";\n\n  try {\n    // The `databricks` CLI is the source of truth. When it's resolvable, run\n    // `databricks aitools install --path <dir>` to materialize a fresh,\n    // agent-agnostic skill set into a dir Mastra can scan.\n    const cliPath = await resolveCli(options.cli);\n    if (cliPath) {\n      const dir = await materializeViaCli(cliPath, options);\n      if (dir) return { localSkillPaths: [dir], source: \"cli\" };\n    }\n\n    // CLI not installed (or produced nothing). \"auto\" logs and moves on;\n    // \"require\" fails startup unless `failOnError: false`.\n    if (failOnError) {\n      throw new Error(\n        `Databricks AI Tools required but the \"${DATABRICKS_CLI}\" CLI is not available. Install the Databricks CLI (\\`databricks aitools install\\`), or set databricksAITools: \"auto\".`,\n      );\n    }\n    logger.info(\"databricks CLI not available; skipping AI Tools skills\");\n    return empty;\n  } catch (err) {\n    if (failOnError) {\n      throw new Error(\n        `failed to provision Databricks AI Tools skills: ${error.errorMessage(err)}`,\n        { cause: error.toError(err) },\n      );\n    }\n    logger.warn(\"skipped\", { error: error.errorMessage(err) });\n    return empty;\n  }\n}\n\n/** Resolve the `databricks` CLI, returning its invocation path or `undefined`. */\nasync function resolveCli(cli: string | undefined): Promise<string | undefined> {\n  const command = string.trimToNull(cli) ?? DATABRICKS_CLI;\n  try {\n    const result = await exec.spawn(command, [\"aitools\", \"version\"], {\n      stdout: \"capture\",\n      stderr: \"capture\",\n      check: false,\n    });\n    if (result.exitCode === 0) return command;\n  } catch {\n    // CLI absent or `aitools` unsupported - caller falls back / fails.\n  }\n  return undefined;\n}\n\n/**\n * Run `databricks aitools install --path <dir>` to materialize a resolved,\n * agent-agnostic skill set into a directory (writes `<name>/SKILL.md` trees,\n * no agents, no state) Mastra can then scan.\n */\nasync function materializeViaCli(\n  cli: string,\n  options: DatabricksAIToolsOptions,\n): Promise<string | undefined> {\n  const explicit = string.trimToNull(options.path);\n  let dir: string;\n\n  if (explicit) {\n    // An explicit path is the caller's to own - install straight into it.\n    await installSkills(cli, options, explicit);\n    dir = explicit;\n  } else {\n    // The resolved skill set is the same on almost every boot, so rebuild ONE\n    // stable temp tree rather than leaving a fresh scratch dir behind each\n    // time. The CLI writes into a throwaway root that only replaces the stable\n    // one on success, so a failed install keeps the previous skills usable.\n    const stable = await localFS.rebuildFS(SKILLS_CACHE_DIR, (scratch) =>\n      installSkills(cli, options, scratch.root),\n    );\n    dir = stable.root;\n  }\n\n  if (!existsSync(dir)) return undefined;\n  logger.debug(\"materialized aitools skills via CLI\", {\n    path: dir,\n    skills: string.parseList(options.skills),\n  });\n  return dir;\n}\n\n/** Run `databricks aitools install --path <dir>`, failing loudly on a non-zero exit. */\nasync function installSkills(\n  cli: string,\n  options: DatabricksAIToolsOptions,\n  dir: string,\n): Promise<void> {\n  const args = [\"aitools\", \"install\", \"--path\", dir];\n  const skills = string.parseList(options.skills);\n  if (skills.length > 0) args.push(\"--skills\", skills.join(\",\"));\n  if (options.experimental) args.push(\"--experimental\");\n\n  const result = await exec.spawn(cli, args, {\n    stdout: \"capture\",\n    stderr: \"capture\",\n    check: false,\n  });\n  if (result.exitCode !== 0) {\n    throw new Error(\n      `databricks aitools install failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`,\n    );\n  }\n}\n"]}

package/lib/src/filesystems.d.ts

@@ -1,208 +1,90 @@
 /**
- * Mastra {@link WorkspaceFilesystem} implementations for Databricks Apps.
+ * Mastra workspace filesystem adapters.
  *
- * {@link DatabricksWorkspaceFilesystem} maps a Mastra workspace namespace onto
- * an absolute Databricks path (Unity Catalog volume, workspace object tree, or
- * DBFS). {@link emptyFilesystem} is a read-only no-op mount used when no
- * dynamic mounts resolve for a request.
- *
- * Path helpers ({@link normalizeDatabricksBasePath}, {@link isDbfsPath}, …)
- * are exported for tests and callers that need to reason about Databricks
- * paths without constructing a filesystem.
+ * {@link filesystems} wraps any portable `@dbx-tools/shared-fs` {@link FileSystem}
+ * (local disk, Databricks, memory, …) as a Mastra {@link MastraFilesystem}.
+ * {@link scratchFilesystem} always returns a fresh {@link localFS.tmpFS} mount
+ * (random id root) when Mastra needs a filesystem and no other mount resolved.
  *
  * @module
  */
-import { WorkspaceClient } from "@databricks/sdk-experimental";
+import type { FileSystem } from "@dbx-tools/shared-fs";
 import { MastraFilesystem } from "@mastra/core/workspace";
 import type { CopyOptions, FileContent, FileEntry, FileStat, FilesystemInfo, ListOptions, MastraFilesystemOptions, ProviderStatus, ReadOptions, RemoveOptions, WriteOptions } from "@mastra/core/workspace";
-/** How {@link DatabricksWorkspaceFilesystem.init} handles a missing {@link basePath}. */
-export type DatabricksMkdirsMode = boolean | "try";
-/** Options for {@link DatabricksWorkspaceFilesystem}. */
-export interface DatabricksWorkspaceFilesystemOptions extends MastraFilesystemOptions {
-    /** Unique identifier for this filesystem instance. */
+/** Options for {@link filesystems} / {@link MastraFileSystemAdapter}. */
+export interface MastraFileSystemAdapterOptions extends MastraFilesystemOptions {
+    /** Override the Mastra filesystem id. Defaults to the source {@link FileSystem.id}. */
     id?: string;
-    /** Auth-scoped Databricks workspace client. */
-    client?: WorkspaceClient;
+    /** Override the Mastra display name. Defaults to `MastraFileSystemAdapter`. */
+    name?: string;
     /**
-     * Absolute Databricks path that roots the workspace namespace, e.g.
-     * `/Volumes/catalog/schema/volume` or `/dbfs/FileStore/shared`.
+     * Override the Mastra provider id. Defaults to the source
+     * {@link FileSystem.backend}.
      */
-    basePath: string;
+    provider?: string;
     /**
-     * When the {@link basePath} is missing at {@link init}, create it with the
-     * matching Databricks `mkdirs` API. `"try"` (default) logs at debug and
-     * falls back to an empty read-only namespace on failure; `true` fails init;
-     * `false` skips creation and uses the empty namespace.
-     *
-     * A successful mkdir also satisfies the write-access probe when
-     * {@link readOnly} is omitted.
+     * Force read-only mounts even when the source filesystem allows writes.
+     * The source {@link FileSystem.readOnly} flag still applies either way.
      */
-    mkdirs?: DatabricksMkdirsMode;
-    /** Block writes while still allowing reads. When omitted, {@link init} probes write access. */
     readOnly?: boolean;
 }
-/** Normalize a Databricks base path (POSIX, no trailing slash). */
-export declare function normalizeDatabricksBasePath(basePath: string): string;
-/** True when `absolutePath` is served by DBFS rather than the UC Files API. */
-export declare function isDbfsPath(absolutePath: string): boolean;
-/** True when `absolutePath` is a Databricks workspace object path. */
-export declare function isWorkspaceFilesPath(absolutePath: string): boolean;
 /**
- * Resolve a workspace-relative path to an absolute Databricks path under
- * `basePath`.
+ * Wrap a portable {@link FileSystem} as a Mastra {@link MastraFilesystem}.
+ *
+ * @example
+ * ```ts
+ * import { filesystems } from "@dbx-tools/appkit-mastra";
+ * import { DatabricksFileSystem } from "@dbx-tools/databricks";
+ * import { localFS } from "@dbx-tools/fs";
+ *
+ * const volume = filesystems.filesystems(
+ *   new DatabricksFileSystem({ root: "/Volumes/main/default/assets" }),
+ * );
+ * const scratch = filesystems.filesystems(localFS.tmpFS("agent-job"));
+ * ```
  */
-export declare function resolveDatabricksAbsolutePath(basePath: string, inputPath: string): string;
-/** Map an absolute Databricks path back to the workspace namespace. */
-export declare function toDatabricksWorkspacePath(basePath: string, absolutePath: string): string;
+export declare function filesystems(fs: FileSystem, options?: MastraFileSystemAdapterOptions): MastraFileSystemAdapter;
 /**
- * Mastra filesystem provider that reads and writes through a Databricks
- * {@link WorkspaceClient}.
- *
- * Workspace paths are absolute within the namespace (`/notes.md` maps to
- * `<basePath>/notes.md`). Unity Catalog volumes use the Files API;
- * `/dbfs/...` paths use DBFS.
+ * Thin Mastra {@link MastraFilesystem} adapter over a `@dbx-tools/shared-fs`
+ * {@link FileSystem}. Identity fields are getters that read the source on
+ * access; construction does not snapshot them.
  */
-export declare class DatabricksWorkspaceFilesystem extends MastraFilesystem {
-    readonly id: string;
-    readonly name = "DatabricksWorkspaceFilesystem";
-    readonly provider = "databricks";
-    readonly basePath: string;
+export declare class MastraFileSystemAdapter extends MastraFilesystem {
     status: ProviderStatus;
-    private readonly client;
-    private readonly mkdirs;
-    private _readOnly;
-    private _basePathMissing;
-    get readOnly(): boolean | undefined;
-    /**
-     * @param options.client - Defaults to the AppKit execution-context client.
-     * @param options.mkdirs - Default `"try"`; see {@link DatabricksMkdirsMode}.
-     * @param options.readOnly - When omitted, {@link init} probes write access.
-     */
-    constructor(options: DatabricksWorkspaceFilesystemOptions);
-    /** Resolve and sandbox a workspace-relative path under {@link basePath}. */
-    private resolvePath;
-    /** Map a Databricks absolute path back to the workspace namespace. */
-    private workspacePath;
-    /** Throw when the filesystem is read-only. */
-    private assertWritable;
-    /** Map SDK / HTTP errors to Mastra workspace filesystem errors. */
-    private rethrow;
-    /**
-     * Probe whether {@link basePath} exists and cache the result on
-     * {@link _basePathMissing}.
-     */
-    private resolveBasePathStatus;
-    /** Delegate to {@link emptyFilesystem} when the base path is missing. */
-    private emptyFallback;
+    private readonly fs;
+    private readonly options;
+    constructor(fs: FileSystem, options?: MastraFileSystemAdapterOptions);
+    get id(): string;
+    get name(): string;
+    get provider(): string;
+    get readOnly(): boolean;
+    get basePath(): string;
     init(): Promise<void>;
-    /**
-     * Write and delete a ephemeral probe file to detect read-only access when
-     * {@link DatabricksWorkspaceFilesystemOptions.readOnly} was not set.
-     *
-     * @returns `true` when the probe write (and cleanup) succeeded.
-     */
-    private probeReadOnly;
     destroy(): Promise<void>;
-    /** Probe that `absolutePath` exists (file or directory metadata). */
-    private assertAbsoluteReadable;
-    /** Read the full contents of `absolutePath` from the matching backend. */
-    private readAbsolute;
-    /** Write `buffer` to `absolutePath` on the matching backend. */
-    private writeAbsolute;
-    /** Upload a buffer to a Unity Catalog Files API path. */
-    private uploadUcFile;
-    /** Delete a single file at `absolutePath` (non-recursive). */
-    private deleteAbsoluteFile;
-    /**
-     * Delete a file or directory at `absolutePath`.
-     *
-     * DBFS and workspace APIs accept `recursive`; UC volumes recurse manually.
-     */
-    private deleteAbsolutePath;
-    /** Create `absolutePath` and any missing parents on the matching backend. */
-    private mkdirAbsolute;
-    private readDbfsFile;
-    private readWorkspaceFile;
-    private writeDbfsFile;
-    private writeWorkspaceFile;
     getInfo(): FilesystemInfo<{
-        basePath: string;
+        root: string;
+        backend: string;
     }>;
     getInstructions(): string;
-    /** Map a workspace-relative path to the backing Databricks absolute path. */
-    resolveAbsolutePath(inputPath: string): string | undefined;
-    /** Read file contents from the workspace namespace. */
     readFile(inputPath: string, options?: ReadOptions): Promise<string | Buffer>;
-    /** Write file contents into the workspace namespace. */
     writeFile(inputPath: string, content: FileContent, options?: WriteOptions): Promise<void>;
-    /** Append to an existing file, creating it when missing. */
     appendFile(inputPath: string, content: FileContent): Promise<void>;
-    /** Delete a file in the workspace namespace. */
     deleteFile(inputPath: string, options?: RemoveOptions): Promise<void>;
-    /** Copy a file within the workspace namespace. */
     copyFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
-    /** Move or rename a file within the workspace namespace. */
     moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
-    /** Create a directory in the workspace namespace. */
     mkdir(inputPath: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
-    /** Remove a directory from the workspace namespace. */
     rmdir(inputPath: string, options?: RemoveOptions): Promise<void>;
-    /**
-     * Recursively delete a Unity Catalog directory tree.
-     *
-     * DBFS and workspace trees use native recursive delete via
-     * {@link deleteAbsolutePath} instead.
-     */
-    private deleteUcDirectoryRecursive;
-    /** List entries in a workspace directory. */
     readdir(inputPath: string, options?: ListOptions): Promise<FileEntry[]>;
-    private readDirectoryRecursive;
-    private listAbsoluteDirectory;
-    /** Apply Mastra list filters (`extension`, etc.) to directory entries. */
-    private filterEntries;
-    /** Return whether `inputPath` exists in the workspace namespace. */
-    exists(inputPath: string): Promise<boolean>;
-    /** Return file or directory metadata for `inputPath`. */
-    stat(inputPath: string): Promise<FileStat>;
-    /**
-     * Stat a Unity Catalog path by probing file metadata first, then
-     * directory metadata.
-     */
-    private statUcAbsolute;
-}
-/**
- * Read-only in-memory {@link WorkspaceFilesystem} with a single empty root.
- * Use {@link emptyFilesystem} rather than constructing directly.
- */
-declare class EmptyFilesystem extends MastraFilesystem {
-    readonly id = "empty-fs";
-    readonly name = "EmptyFilesystem";
-    readonly provider = "empty";
-    readonly readOnly = true;
-    status: ProviderStatus;
-    constructor();
-    init(): Promise<void>;
-    destroy(): Promise<void>;
-    getInfo(): FilesystemInfo;
-    getInstructions(): string;
-    private rootStat;
-    private assertWritable;
-    readFile(inputPath: string, _options?: ReadOptions): Promise<string | Buffer>;
-    writeFile(_inputPath: string, _content: FileContent, _options?: WriteOptions): Promise<void>;
-    appendFile(_inputPath: string, _content: FileContent): Promise<void>;
-    deleteFile(inputPath: string, options?: RemoveOptions): Promise<void>;
-    copyFile(src: string, _dest: string, _options?: CopyOptions): Promise<void>;
-    moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
-    mkdir(_inputPath: string, _options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    rmdir(inputPath: string, options?: RemoveOptions): Promise<void>;
-    readdir(inputPath: string, _options?: ListOptions): Promise<FileEntry[]>;
     exists(inputPath: string): Promise<boolean>;
     stat(inputPath: string): Promise<FileStat>;
+    private delegate;
+    /** {@link delegate} for a mutation: refuse a read-only mount before doing any work. */
+    private delegateWrite;
+    /** When Mastra asks for non-recursive writes, require the parent directory. */
+    private assertParentExists;
+    private rethrow;
 }
-/** Memoized singleton empty read-only filesystem for no-op mounts. */
-export declare const emptyFilesystem: () => EmptyFilesystem;
-export {};
+/** Fresh writable local temp mount on a root unique to this call. */
+export declare function scratchFilesystem(): MastraFileSystemAdapter;