@dbx-tools/appkit-mastra 0.6.216 → 0.6.217

package/lib/src/monty-sandbox.js

@@ -0,0 +1,331 @@
+/**
+ * Pydantic Monty fallback for Mastra command execution.
+ *
+ * Uses the Node subprocess-worker build of Monty. It executes Python source
+ * with no host filesystem, network, environment, shell, or third-party package
+ * access unless a future caller explicitly adds those capabilities.
+ *
+ * @module
+ */
+import { error, functionModule } from "@dbx-tools/shared-core";
+const DEFAULT_COMMAND_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_MEMORY_BYTES = 10_000_000;
+const montyModule = functionModule.memoize(() => import("@pydantic/monty/node"));
+const montyPool = functionModule.memoize(async () => {
+    const { Monty } = await montyModule();
+    return Monty.create({
+        minProcesses: 1,
+        maxProcesses: 4,
+        requestTimeout: 35,
+    });
+});
+/** Python-only, deny-by-default sandbox backed by Monty's Node worker pool. */
+export class MontySandbox {
+    id;
+    name;
+    provider = "monty";
+    status = "pending";
+    error;
+    commandTimeoutMs;
+    maxMemoryBytes;
+    typeCheck;
+    createdAt = new Date();
+    lastUsedAt;
+    constructor(options = {}) {
+        this.id = options.id ?? "monty";
+        this.name = options.name ?? "Pydantic Monty";
+        this.commandTimeoutMs = options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+        this.maxMemoryBytes = options.maxMemoryBytes ?? DEFAULT_MAX_MEMORY_BYTES;
+        this.typeCheck = options.typeCheck ?? false;
+    }
+    /** Warm the shared crash-isolated worker pool. */
+    async start() {
+        if (this.status === "running")
+            return;
+        this.status = "starting";
+        this.error = undefined;
+        try {
+            await montyPool();
+            this.status = "running";
+        }
+        catch (caught) {
+            this.status = "error";
+            this.error = error.errorMessage(caught);
+            throw caught;
+        }
+    }
+    /** The process-wide pool stays warm; this instance carries no open session. */
+    async stop() {
+        this.status = "stopped";
+    }
+    /** The process-wide pool stays warm; each command closes its own checkout. */
+    async destroy() {
+        this.status = "destroyed";
+    }
+    /** Monty sessions are ephemeral and do not provide persistent checkpoints. */
+    async snapshot() { }
+    supportsCheckpoints = false;
+    /** Execute Python source and map Monty output to Mastra's command result. */
+    async executeCommand(command, args = [], options = {}) {
+        const started = performance.now();
+        const code = montyCode(command, args);
+        if (code === undefined) {
+            return failedResult(command, args, started, "Monty fallback accepts Python source directly, or python/python3 with a single -c script.");
+        }
+        const environment = Object.entries(options.env ?? {}).filter(([, value]) => value !== undefined);
+        if (environment.length > 0) {
+            return failedResult(command, args, started, "Monty fallback does not expose host environment variables.");
+        }
+        if (options.cwd) {
+            return failedResult(command, args, started, "Monty fallback does not expose a host working directory.");
+        }
+        if (options.abortSignal?.aborted)
+            throw options.abortSignal.reason;
+        await this.start();
+        const timeout = options.timeout ?? this.commandTimeoutMs;
+        const pool = await montyPool();
+        const session = await checkoutSession(pool, {
+            limits: {
+                maxDurationSecs: Math.max(0.001, timeout / 1_000),
+                maxMemory: this.maxMemoryBytes,
+            },
+            typeCheck: this.typeCheck,
+        }, options.abortSignal);
+        const output = new RetainedOutput(options);
+        const workerPid = session.workerPid;
+        let aborted = false;
+        const onAbort = () => {
+            aborted = true;
+            terminateWorker(workerPid);
+        };
+        options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+        if (options.abortSignal?.aborted)
+            onAbort();
+        try {
+            if (aborted)
+                throw abortReason(options.abortSignal);
+            const value = await session.feedRun(stripPythonFence(code), {
+                printCallback: (stream, text) => output.emit(stream, text),
+            });
+            const returned = formatResult(value);
+            if (returned) {
+                const suffix = returned.endsWith("\n") ? returned : `${returned}\n`;
+                output.emit("stdout", suffix);
+            }
+            this.lastUsedAt = new Date();
+            return {
+                command,
+                args,
+                success: true,
+                exitCode: 0,
+                stdout: output.stdout.value,
+                stderr: output.stderr.value,
+                executionTimeMs: performance.now() - started,
+                ...output.metadata(),
+            };
+        }
+        catch (caught) {
+            if (aborted || options.abortSignal?.aborted) {
+                throw abortReason(options.abortSignal);
+            }
+            const message = error.errorMessage(caught);
+            output.emit("stderr", output.stderr.value ? `\n${message}` : message);
+            const { MontyCrashedError } = await montyModule();
+            const timedOut = caught instanceof MontyCrashedError && caught.timedOut;
+            return {
+                command,
+                args,
+                success: false,
+                exitCode: timedOut ? -1 : 1,
+                stdout: output.stdout.value,
+                stderr: output.stderr.value,
+                executionTimeMs: performance.now() - started,
+                ...(timedOut ? { timedOut: true, killed: true } : {}),
+                ...output.metadata(),
+            };
+        }
+        finally {
+            options.abortSignal?.removeEventListener("abort", onAbort);
+            await session.close();
+        }
+    }
+    async isReady() {
+        return this.status === "running";
+    }
+    getInfo() {
+        return {
+            id: this.id,
+            name: this.name,
+            provider: this.provider,
+            status: this.status,
+            createdAt: this.createdAt,
+            ...(this.lastUsedAt ? { lastUsedAt: this.lastUsedAt } : {}),
+            metadata: {
+                language: "python",
+                hostAccess: false,
+            },
+        };
+    }
+    getInstructions() {
+        return [
+            "Commands run as Python source in the Pydantic Monty fallback.",
+            "Pass Python code directly rather than shell syntax.",
+            "There is no host filesystem, network, environment, shell, or third-party package access.",
+        ].join(" ");
+    }
+}
+function montyCode(command, args) {
+    if (args.length === 0)
+        return command;
+    if ((command === "python" || command === "python3") && args.length === 2 && args[0] === "-c") {
+        return args[1];
+    }
+    return undefined;
+}
+function stripPythonFence(code) {
+    const trimmed = code.trim();
+    const match = /^```(?:python|py)?\s*\n([\s\S]*?)\n```$/i.exec(trimmed);
+    return match?.[1] ?? code;
+}
+function formatResult(value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value, null, 2) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+class RetainedOutput {
+    stdout;
+    stderr;
+    onStdout;
+    onStderr;
+    constructor(options) {
+        this.stdout = new RetainedText(options.maxRetainedBytes);
+        this.stderr = new RetainedText(options.maxRetainedBytes);
+        this.onStdout = options.onStdout;
+        this.onStderr = options.onStderr;
+    }
+    emit(stream, text) {
+        if (stream === "stdout") {
+            this.onStdout?.(text);
+            this.stdout.append(text);
+        }
+        else {
+            this.onStderr?.(text);
+            this.stderr.append(text);
+        }
+    }
+    metadata() {
+        return {
+            ...(this.stdout.droppedBytes > 0
+                ? {
+                    stdoutTruncated: true,
+                    stdoutDroppedBytes: this.stdout.droppedBytes,
+                }
+                : {}),
+            ...(this.stderr.droppedBytes > 0
+                ? {
+                    stderrTruncated: true,
+                    stderrDroppedBytes: this.stderr.droppedBytes,
+                }
+                : {}),
+        };
+    }
+}
+class RetainedText {
+    value = "";
+    droppedBytes = 0;
+    maxBytes;
+    encoder = new TextEncoder();
+    decoder = new TextDecoder();
+    constructor(maxBytes) {
+        const resolved = maxBytes ?? Number.POSITIVE_INFINITY;
+        if (resolved !== Number.POSITIVE_INFINITY &&
+            (!Number.isSafeInteger(resolved) || resolved < 0)) {
+            throw new TypeError("maxRetainedBytes must be a non-negative safe integer or Infinity");
+        }
+        this.maxBytes = resolved;
+    }
+    append(text) {
+        if (!text)
+            return;
+        if (this.maxBytes === Number.POSITIVE_INFINITY) {
+            this.value += text;
+            return;
+        }
+        const combined = this.encoder.encode(this.value + text);
+        if (combined.length <= this.maxBytes) {
+            this.value += text;
+            return;
+        }
+        let start = combined.length - this.maxBytes;
+        while (start < combined.length && (combined[start] & 0xc0) === 0x80)
+            start++;
+        const retained = combined.subarray(start);
+        this.droppedBytes += combined.length - retained.length;
+        this.value = this.decoder.decode(retained);
+    }
+}
+function terminateWorker(workerPid) {
+    if (workerPid === undefined)
+        return;
+    try {
+        process.kill(workerPid, "SIGKILL");
+    }
+    catch {
+        // The command can finish between the abort event and the kill request.
+    }
+}
+async function checkoutSession(pool, options, signal) {
+    const checkout = pool.checkout(options);
+    if (!signal)
+        return checkout;
+    if (signal.aborted) {
+        void checkout.then((session) => session.close()).catch(() => undefined);
+        throw abortReason(signal);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            reject(abortReason(signal));
+            void checkout.then((session) => session.close()).catch(() => undefined);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        checkout.then((session) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            resolve(session);
+        }, (caught) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            reject(caught);
+        });
+    });
+}
+function abortReason(signal) {
+    return signal?.reason ?? new DOMException("The command was aborted", "AbortError");
+}
+function failedResult(command, args, started, stderr) {
+    return {
+        command,
+        args,
+        success: false,
+        exitCode: 1,
+        stdout: "",
+        stderr,
+        executionTimeMs: performance.now() - started,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monty-sandbox.js","sourceRoot":"","sources":["../../src/monty-sandbox.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pydantic Monty fallback for Mastra command execution.\n *\n * Uses the Node subprocess-worker build of Monty. It executes Python source\n * with no host filesystem, network, environment, shell, or third-party package\n * access unless a future caller explicitly adds those capabilities.\n *\n * @module\n */\n\nimport { error, functionModule } from \"@dbx-tools/shared-core\";\nimport type {\n  CommandResult,\n  ExecuteCommandOptions,\n  SandboxInfo,\n  WorkspaceSandbox,\n} from \"@mastra/core/workspace\";\nimport type { CheckoutOptions, Monty as MontyPool, MontySession } from \"@pydantic/monty/node\";\n\nconst DEFAULT_COMMAND_TIMEOUT_MS = 30_000;\nconst DEFAULT_MAX_MEMORY_BYTES = 10_000_000;\n\nconst montyModule = functionModule.memoize(() => import(\"@pydantic/monty/node\"));\nconst montyPool = functionModule.memoize(async (): Promise<MontyPool> => {\n  const { Monty } = await montyModule();\n  return Monty.create({\n    minProcesses: 1,\n    maxProcesses: 4,\n    requestTimeout: 35,\n  });\n});\n\n/** Resource controls for the Monty Python fallback. */\nexport interface MontySandboxOptions {\n  /** Mastra provider id. */\n  id?: string;\n  /** Display name. */\n  name?: string;\n  /** Default execution timeout. Per-call `options.timeout` wins. */\n  commandTimeoutMs?: number;\n  /** Maximum Monty heap bytes for one checkout. */\n  maxMemoryBytes?: number;\n  /** Type-check each Python snippet before running it. Defaults to false. */\n  typeCheck?: boolean;\n}\n\n/** Python-only, deny-by-default sandbox backed by Monty's Node worker pool. */\nexport class MontySandbox implements WorkspaceSandbox {\n  readonly id: string;\n  readonly name: string;\n  readonly provider = \"monty\";\n  status: WorkspaceSandbox[\"status\"] = \"pending\";\n  error?: string;\n\n  private readonly commandTimeoutMs: number;\n  private readonly maxMemoryBytes: number;\n  private readonly typeCheck: boolean;\n  private readonly createdAt = new Date();\n  private lastUsedAt?: Date;\n\n  constructor(options: MontySandboxOptions = {}) {\n    this.id = options.id ?? \"monty\";\n    this.name = options.name ?? \"Pydantic Monty\";\n    this.commandTimeoutMs = options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;\n    this.maxMemoryBytes = options.maxMemoryBytes ?? DEFAULT_MAX_MEMORY_BYTES;\n    this.typeCheck = options.typeCheck ?? false;\n  }\n\n  /** Warm the shared crash-isolated worker pool. */\n  async start(): Promise<void> {\n    if (this.status === \"running\") return;\n    this.status = \"starting\";\n    this.error = undefined;\n    try {\n      await montyPool();\n      this.status = \"running\";\n    } catch (caught) {\n      this.status = \"error\";\n      this.error = error.errorMessage(caught);\n      throw caught;\n    }\n  }\n\n  /** The process-wide pool stays warm; this instance carries no open session. */\n  async stop(): Promise<void> {\n    this.status = \"stopped\";\n  }\n\n  /** The process-wide pool stays warm; each command closes its own checkout. */\n  async destroy(): Promise<void> {\n    this.status = \"destroyed\";\n  }\n\n  /** Monty sessions are ephemeral and do not provide persistent checkpoints. */\n  async snapshot(): Promise<void> {}\n\n  readonly supportsCheckpoints = false;\n\n  /** Execute Python source and map Monty output to Mastra's command result. */\n  async executeCommand(\n    command: string,\n    args: string[] = [],\n    options: ExecuteCommandOptions = {},\n  ): Promise<CommandResult> {\n    const started = performance.now();\n    const code = montyCode(command, args);\n    if (code === undefined) {\n      return failedResult(\n        command,\n        args,\n        started,\n        \"Monty fallback accepts Python source directly, or python/python3 with a single -c script.\",\n      );\n    }\n    const environment = Object.entries(options.env ?? {}).filter(\n      ([, value]) => value !== undefined,\n    );\n    if (environment.length > 0) {\n      return failedResult(\n        command,\n        args,\n        started,\n        \"Monty fallback does not expose host environment variables.\",\n      );\n    }\n    if (options.cwd) {\n      return failedResult(\n        command,\n        args,\n        started,\n        \"Monty fallback does not expose a host working directory.\",\n      );\n    }\n    if (options.abortSignal?.aborted) throw options.abortSignal.reason;\n\n    await this.start();\n    const timeout = options.timeout ?? this.commandTimeoutMs;\n    const pool = await montyPool();\n    const session = await checkoutSession(\n      pool,\n      {\n        limits: {\n          maxDurationSecs: Math.max(0.001, timeout / 1_000),\n          maxMemory: this.maxMemoryBytes,\n        },\n        typeCheck: this.typeCheck,\n      },\n      options.abortSignal,\n    );\n    const output = new RetainedOutput(options);\n    const workerPid = session.workerPid;\n    let aborted = false;\n    const onAbort = (): void => {\n      aborted = true;\n      terminateWorker(workerPid);\n    };\n    options.abortSignal?.addEventListener(\"abort\", onAbort, { once: true });\n    if (options.abortSignal?.aborted) onAbort();\n    try {\n      if (aborted) throw abortReason(options.abortSignal);\n      const value = await session.feedRun(stripPythonFence(code), {\n        printCallback: (stream, text) => output.emit(stream, text),\n      });\n      const returned = formatResult(value);\n      if (returned) {\n        const suffix = returned.endsWith(\"\\n\") ? returned : `${returned}\\n`;\n        output.emit(\"stdout\", suffix);\n      }\n      this.lastUsedAt = new Date();\n      return {\n        command,\n        args,\n        success: true,\n        exitCode: 0,\n        stdout: output.stdout.value,\n        stderr: output.stderr.value,\n        executionTimeMs: performance.now() - started,\n        ...output.metadata(),\n      };\n    } catch (caught) {\n      if (aborted || options.abortSignal?.aborted) {\n        throw abortReason(options.abortSignal);\n      }\n      const message = error.errorMessage(caught);\n      output.emit(\"stderr\", output.stderr.value ? `\\n${message}` : message);\n      const { MontyCrashedError } = await montyModule();\n      const timedOut = caught instanceof MontyCrashedError && caught.timedOut;\n      return {\n        command,\n        args,\n        success: false,\n        exitCode: timedOut ? -1 : 1,\n        stdout: output.stdout.value,\n        stderr: output.stderr.value,\n        executionTimeMs: performance.now() - started,\n        ...(timedOut ? { timedOut: true, killed: true } : {}),\n        ...output.metadata(),\n      };\n    } finally {\n      options.abortSignal?.removeEventListener(\"abort\", onAbort);\n      await session.close();\n    }\n  }\n\n  async isReady(): Promise<boolean> {\n    return this.status === \"running\";\n  }\n\n  getInfo(): SandboxInfo {\n    return {\n      id: this.id,\n      name: this.name,\n      provider: this.provider,\n      status: this.status,\n      createdAt: this.createdAt,\n      ...(this.lastUsedAt ? { lastUsedAt: this.lastUsedAt } : {}),\n      metadata: {\n        language: \"python\",\n        hostAccess: false,\n      },\n    };\n  }\n\n  getInstructions(): string {\n    return [\n      \"Commands run as Python source in the Pydantic Monty fallback.\",\n      \"Pass Python code directly rather than shell syntax.\",\n      \"There is no host filesystem, network, environment, shell, or third-party package access.\",\n    ].join(\" \");\n  }\n}\n\nfunction montyCode(command: string, args: readonly string[]): string | undefined {\n  if (args.length === 0) return command;\n  if ((command === \"python\" || command === \"python3\") && args.length === 2 && args[0] === \"-c\") {\n    return args[1];\n  }\n  return undefined;\n}\n\nfunction stripPythonFence(code: string): string {\n  const trimmed = code.trim();\n  const match = /^```(?:python|py)?\\s*\\n([\\s\\S]*?)\\n```$/i.exec(trimmed);\n  return match?.[1] ?? code;\n}\n\nfunction formatResult(value: unknown): string {\n  if (value === undefined || value === null) return \"\";\n  if (typeof value === \"string\") return value;\n  try {\n    return JSON.stringify(value, null, 2) ?? String(value);\n  } catch {\n    return String(value);\n  }\n}\n\nclass RetainedOutput {\n  readonly stdout: RetainedText;\n  readonly stderr: RetainedText;\n\n  private readonly onStdout: ExecuteCommandOptions[\"onStdout\"];\n  private readonly onStderr: ExecuteCommandOptions[\"onStderr\"];\n\n  constructor(options: ExecuteCommandOptions) {\n    this.stdout = new RetainedText(options.maxRetainedBytes);\n    this.stderr = new RetainedText(options.maxRetainedBytes);\n    this.onStdout = options.onStdout;\n    this.onStderr = options.onStderr;\n  }\n\n  emit(stream: \"stdout\" | \"stderr\", text: string): void {\n    if (stream === \"stdout\") {\n      this.onStdout?.(text);\n      this.stdout.append(text);\n    } else {\n      this.onStderr?.(text);\n      this.stderr.append(text);\n    }\n  }\n\n  metadata(): Pick<\n    CommandResult,\n    \"stdoutTruncated\" | \"stderrTruncated\" | \"stdoutDroppedBytes\" | \"stderrDroppedBytes\"\n  > {\n    return {\n      ...(this.stdout.droppedBytes > 0\n        ? {\n            stdoutTruncated: true,\n            stdoutDroppedBytes: this.stdout.droppedBytes,\n          }\n        : {}),\n      ...(this.stderr.droppedBytes > 0\n        ? {\n            stderrTruncated: true,\n            stderrDroppedBytes: this.stderr.droppedBytes,\n          }\n        : {}),\n    };\n  }\n}\n\nclass RetainedText {\n  value = \"\";\n  droppedBytes = 0;\n\n  private readonly maxBytes: number;\n  private readonly encoder = new TextEncoder();\n  private readonly decoder = new TextDecoder();\n\n  constructor(maxBytes: number | undefined) {\n    const resolved = maxBytes ?? Number.POSITIVE_INFINITY;\n    if (\n      resolved !== Number.POSITIVE_INFINITY &&\n      (!Number.isSafeInteger(resolved) || resolved < 0)\n    ) {\n      throw new TypeError(\"maxRetainedBytes must be a non-negative safe integer or Infinity\");\n    }\n    this.maxBytes = resolved;\n  }\n\n  append(text: string): void {\n    if (!text) return;\n    if (this.maxBytes === Number.POSITIVE_INFINITY) {\n      this.value += text;\n      return;\n    }\n    const combined = this.encoder.encode(this.value + text);\n    if (combined.length <= this.maxBytes) {\n      this.value += text;\n      return;\n    }\n    let start = combined.length - this.maxBytes;\n    while (start < combined.length && (combined[start]! & 0xc0) === 0x80) start++;\n    const retained = combined.subarray(start);\n    this.droppedBytes += combined.length - retained.length;\n    this.value = this.decoder.decode(retained);\n  }\n}\n\nfunction terminateWorker(workerPid: number | undefined): void {\n  if (workerPid === undefined) return;\n  try {\n    process.kill(workerPid, \"SIGKILL\");\n  } catch {\n    // The command can finish between the abort event and the kill request.\n  }\n}\n\nasync function checkoutSession(\n  pool: MontyPool,\n  options: CheckoutOptions,\n  signal: AbortSignal | undefined,\n): Promise<MontySession> {\n  const checkout = pool.checkout(options);\n  if (!signal) return checkout;\n  if (signal.aborted) {\n    void checkout.then((session) => session.close()).catch(() => undefined);\n    throw abortReason(signal);\n  }\n\n  return new Promise<MontySession>((resolve, reject) => {\n    let settled = false;\n    const onAbort = (): void => {\n      if (settled) return;\n      settled = true;\n      reject(abortReason(signal));\n      void checkout.then((session) => session.close()).catch(() => undefined);\n    };\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    checkout.then(\n      (session) => {\n        if (settled) return;\n        settled = true;\n        signal.removeEventListener(\"abort\", onAbort);\n        resolve(session);\n      },\n      (caught: unknown) => {\n        if (settled) return;\n        settled = true;\n        signal.removeEventListener(\"abort\", onAbort);\n        reject(caught);\n      },\n    );\n  });\n}\n\nfunction abortReason(signal: AbortSignal | undefined): unknown {\n  return signal?.reason ?? new DOMException(\"The command was aborted\", \"AbortError\");\n}\n\nfunction failedResult(\n  command: string,\n  args: string[],\n  started: number,\n  stderr: string,\n): CommandResult {\n  return {\n    command,\n    args,\n    success: false,\n    exitCode: 1,\n    stdout: \"\",\n    stderr,\n    executionTimeMs: performance.now() - started,\n  };\n}\n"]}

package/lib/src/plugin.d.ts

@@ -176,7 +176,7 @@ export declare class MastraPlugin extends Plugin<MastraPluginConfig> {
          */
         getDefault: () => Agent | null;
         /** Underlying Mastra instance for advanced use (custom routes etc.). */
-        getMastra: () => Mastra<Record<string, Agent<any, import("@mastra/core/agent").ToolsInput, undefined, unknown, import("@mastra/core/agent").AgentEditorConfig | undefined>>, Record<string, import("@mastra/core/workflows").AnyWorkflow>, Record<string, import("@mastra/core/vector").MastraVector<any>>, Record<string, import("@mastra/core/tts").MastraTTS>, import("@mastra/core/logger").IMastraLogger, Record<string, import("@mastra/core/mcp").MCPServerBase<any>>, Record<string, import("@mastra/core/evals").MastraScorer<any, any, any, any>>, Record<string, import("@mastra/core/tools").ToolAction<any, any, any, any, any, any, unknown>>, Record<string, import("@mastra/core/processors").Processor<any, unknown>>, Record<string, import("@mastra/core/memory").MastraMemory>, Record<string, import("@mastra/core/channels").ChannelProvider>> | null;
+        getMastra: () => Mastra<Record<string, Agent<any, import("@mastra/core/agent").ToolsInput, undefined, any, import("@mastra/core/agent").AgentEditorConfig | undefined>>, Record<string, import("@mastra/core/workflows").AnyWorkflow>, Record<string, import("@mastra/core/vector").MastraVector<any>>, Record<string, import("@mastra/core/tts").MastraTTS>, import("@mastra/core/logger").IMastraLogger, Record<string, import("@mastra/core/mcp").MCPServerBase<any>>, Record<string, import("@mastra/core/evals").MastraScorer<any, any, any, any>>, Record<string, import("@mastra/core/tools").ToolAction<any, any, any, any, any, any, unknown>>, Record<string, import("@mastra/core/processors").Processor<any, unknown>>, Record<string, import("@mastra/core/memory").MastraMemory>, Record<string, import("@mastra/core/channels").ChannelProvider>> | null;
         /**
          * Build the `RequestContext` an agent turn driven from OUTSIDE this
          * plugin's routes needs (a Teams activity on another plugin's endpoint, a

package/lib/src/sandbox.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Databricks Sandbox adapter for Mastra workspaces.
+ *
+ * Implements Mastra's foreground command surface over the Databricks Sandbox
+ * REST API. Sandboxes are created lazily, retain their home directory across
+ * inactivity stops, and execute untrusted shell commands outside the App
+ * container.
+ *
+ * @module
+ */
+import type { WorkspaceClient } from "@databricks/appkit";
+import type { RequestContext } from "@mastra/core/request-context";
+import type { CommandResult, ExecuteCommandOptions, ProviderStatus, SandboxInfo, WorkspaceSandbox } from "@mastra/core/workspace";
+import { type MontySandboxOptions } from "./monty-sandbox.ts";
+/** Options for one Databricks-backed Mastra sandbox. */
+export interface DatabricksSandboxOptions {
+    /** AppKit workspace client used for every sandbox API call. */
+    client: WorkspaceClient;
+    /** Resource id, with or without the `sandboxes/` prefix. */
+    sandboxId: string;
+    /** Human-readable Databricks label. */
+    displayName?: string;
+    /** Server-side idle timeout in protobuf duration form. Defaults to `900s`. */
+    inactivityTimeout?: string;
+    /** Maximum time to wait for the sandbox to become runnable. */
+    startupTimeoutMs?: number;
+    /** Default command timeout. Per-call `options.timeout` wins. */
+    commandTimeoutMs?: number;
+    /**
+     * Provider used only when Databricks Sandbox is definitively unavailable.
+     * Defaults to the Node Pydantic Monty runtime; `false` fails instead.
+     */
+    fallback?: false | "monty" | MontySandboxOptions | WorkspaceSandbox;
+}
+/** Databricks options accepted by the higher-level workspace factory. */
+export interface DatabricksWorkspaceSandboxOptions extends Omit<DatabricksSandboxOptions, "client" | "sandboxId"> {
+    /** Provider discriminator. Defaults to `databricks`. */
+    provider?: "databricks";
+    /**
+     * Credential source. Defaults to a fresh AppKit client using the normal
+     * environment/profile chain, which is the app service principal in a
+     * Databricks App.
+     */
+    client?: WorkspaceClient | ((context: {
+        requestContext: RequestContext;
+    }) => WorkspaceClient);
+    /**
+     * Fixed id or per-request resolver. Omit to derive a stable, opaque id from
+     * the workspace and attributed user.
+     */
+    sandboxId?: string | ((context: {
+        requestContext: RequestContext;
+    }) => string);
+}
+/** Mastra sandbox backed by Databricks serverless Sandbox compute. */
+export declare class DatabricksSandbox implements WorkspaceSandbox {
+    readonly id: string;
+    readonly name: string;
+    status: ProviderStatus;
+    error?: string;
+    private readonly client;
+    private readonly displayName;
+    private readonly inactivityTimeout;
+    private readonly startupTimeoutMs;
+    private readonly commandTimeoutMs;
+    private readonly fallbackConfig;
+    private readonly createdAt;
+    private remoteCreatedAt?;
+    private lastUsedAt?;
+    private activeFallback?;
+    private startPromise?;
+    constructor(options: DatabricksSandboxOptions);
+    get provider(): string;
+    /** Ensure the remote sandbox exists and has reached its running state. */
+    start(): Promise<void>;
+    private startWithSignal;
+    private performStart;
+    /** Databricks home persistence is not a cloneable Mastra checkpoint. */
+    snapshot(): Promise<void>;
+    get supportsCheckpoints(): boolean;
+    /** Stop compute while preserving the sandbox home directory. */
+    stop(): Promise<void>;
+    /** Permanently delete the sandbox and its persisted home directory. */
+    destroy(): Promise<void>;
+    /** Execute one foreground shell command in the remote sandbox. */
+    executeCommand(command: string, args?: string[], options?: ExecuteCommandOptions): Promise<CommandResult>;
+    /** Whether the adapter currently knows the remote sandbox to be running. */
+    isReady(): Promise<boolean>;
+    /** Report Mastra-facing sandbox metadata. */
+    getInfo(): Promise<SandboxInfo>;
+    /** Explain the Databricks execution boundary to the agent. */
+    getInstructions(): string;
+    private get resourcePath();
+    private getOrCreate;
+    private get;
+    private mutate;
+    private waitForState;
+    private rememberCreatedAt;
+    private request;
+}