@dbx-tools/appkit-mastra 0.6.216 → 0.6.217

package/lib/src/sandbox.js

@@ -0,0 +1,418 @@
+/**
+ * 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 { databricks } from "@dbx-tools/appkit";
+import { async, error, log, string } from "@dbx-tools/shared-core";
+import { z } from "zod";
+import { MontySandbox } from "./monty-sandbox.js";
+const SANDBOX_API_PATH = "/api/2.0/sandboxes";
+const SANDBOX_EXEC_API_PATH = "/api/2.0/sandbox-exec/sandboxes";
+const DEFAULT_INACTIVITY_TIMEOUT = "900s";
+const DEFAULT_STARTUP_TIMEOUT_MS = 120_000;
+const DEFAULT_COMMAND_TIMEOUT_MS = 30_000;
+const SANDBOX_POLL_INTERVAL_MS = 500;
+const logger = log.logger("mastra/sandbox");
+const SandboxStateSchema = z.object({
+    state: z.string().optional(),
+});
+const SandboxResponseSchema = z.object({
+    name: z.string(),
+    display_name: z.string().optional(),
+    create_time: z.string().optional(),
+    update_time: z.string().optional(),
+    status: SandboxStateSchema.optional(),
+});
+const ExecuteResponseSchema = z.object({
+    exit_code: z.number().int().optional(),
+    status: z.string(),
+    stdout: z.string().optional(),
+    stderr: z.string().optional(),
+    command_id: z.string().optional(),
+    truncated: z.boolean().optional(),
+});
+/** Mastra sandbox backed by Databricks serverless Sandbox compute. */
+export class DatabricksSandbox {
+    id;
+    name;
+    status = "pending";
+    error;
+    client;
+    displayName;
+    inactivityTimeout;
+    startupTimeoutMs;
+    commandTimeoutMs;
+    fallbackConfig;
+    createdAt = new Date();
+    remoteCreatedAt;
+    lastUsedAt;
+    activeFallback;
+    startPromise;
+    constructor(options) {
+        const id = string.trimToNull(options.sandboxId.replace(/^sandboxes\//, ""));
+        if (!id)
+            throw new TypeError("Databricks sandbox id must not be blank");
+        this.id = id;
+        this.name = options.displayName?.trim() || `Mastra sandbox ${id}`;
+        this.client = options.client;
+        this.displayName = this.name;
+        this.inactivityTimeout = options.inactivityTimeout ?? DEFAULT_INACTIVITY_TIMEOUT;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+        this.commandTimeoutMs = options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+        this.fallbackConfig = options.fallback ?? "monty";
+    }
+    get provider() {
+        return this.activeFallback?.provider ?? "databricks";
+    }
+    /** Ensure the remote sandbox exists and has reached its running state. */
+    async start() {
+        await this.startWithSignal();
+    }
+    async startWithSignal(signal) {
+        if (this.status === "running")
+            return;
+        if (this.startPromise) {
+            await this.startPromise;
+            return;
+        }
+        const pending = this.performStart(signal);
+        this.startPromise = pending;
+        try {
+            await pending;
+        }
+        finally {
+            if (this.startPromise === pending)
+                this.startPromise = undefined;
+        }
+    }
+    async performStart(signal) {
+        if (this.activeFallback) {
+            await this.activeFallback.start?.();
+            this.status = this.activeFallback.status;
+            return;
+        }
+        this.status = "starting";
+        this.error = undefined;
+        try {
+            let sandbox = await this.getOrCreate(signal);
+            if (sandbox.status?.state === "SANDBOX_STATE_STOPPED") {
+                sandbox = await this.mutate("start", signal);
+            }
+            if (sandbox.status?.state === "SANDBOX_STATE_STOPPING") {
+                await this.waitForState("SANDBOX_STATE_STOPPED", signal);
+                sandbox = await this.mutate("start", signal);
+            }
+            if (sandbox.status?.state !== "SANDBOX_STATE_RUNNING") {
+                await this.waitForState("SANDBOX_STATE_RUNNING", signal);
+            }
+            this.status = "running";
+            this.lastUsedAt = new Date();
+        }
+        catch (caught) {
+            if (this.fallbackConfig !== false && isDatabricksSandboxUnavailable(caught)) {
+                const fallback = resolveFallback(this.fallbackConfig);
+                logger.warn("Databricks Sandbox unavailable; using fallback", {
+                    sandboxId: this.id,
+                    fallback: fallback.provider,
+                    error: error.errorMessage(caught),
+                });
+                await fallback.start?.();
+                this.activeFallback = fallback;
+                this.status = fallback.status;
+                this.error = fallback.error;
+                return;
+            }
+            this.status = "error";
+            this.error = error.errorMessage(caught);
+            throw caught;
+        }
+    }
+    /** Databricks home persistence is not a cloneable Mastra checkpoint. */
+    async snapshot() {
+        await this.activeFallback?.snapshot();
+    }
+    get supportsCheckpoints() {
+        return this.activeFallback?.supportsCheckpoints ?? false;
+    }
+    /** Stop compute while preserving the sandbox home directory. */
+    async stop() {
+        if (this.activeFallback) {
+            await this.activeFallback.stop?.();
+            this.status = this.activeFallback.status;
+            return;
+        }
+        if (this.status === "stopped" || this.status === "destroyed")
+            return;
+        this.status = "stopping";
+        try {
+            await this.mutate("stop");
+            this.status = "stopped";
+        }
+        catch (caught) {
+            if (isStatus(caught, 404)) {
+                this.status = "stopped";
+                return;
+            }
+            this.status = "error";
+            this.error = error.errorMessage(caught);
+            throw caught;
+        }
+    }
+    /** Permanently delete the sandbox and its persisted home directory. */
+    async destroy() {
+        if (this.activeFallback) {
+            await this.activeFallback.destroy?.();
+            this.status = this.activeFallback.status;
+            return;
+        }
+        if (this.status === "destroyed")
+            return;
+        this.status = "destroying";
+        try {
+            await this.request(`${this.resourcePath}`, "DELETE", z.object({}).passthrough());
+            this.status = "destroyed";
+        }
+        catch (caught) {
+            if (isStatus(caught, 404)) {
+                this.status = "destroyed";
+                return;
+            }
+            this.status = "error";
+            this.error = error.errorMessage(caught);
+            throw caught;
+        }
+    }
+    /** Execute one foreground shell command in the remote sandbox. */
+    async executeCommand(command, args = [], options = {}) {
+        await this.startWithSignal(options.abortSignal);
+        if (this.activeFallback) {
+            if (!this.activeFallback.executeCommand) {
+                return {
+                    command,
+                    args,
+                    success: false,
+                    exitCode: 1,
+                    stdout: "",
+                    stderr: `Fallback sandbox ${this.activeFallback.provider} does not support command execution.`,
+                    executionTimeMs: 0,
+                };
+            }
+            return this.activeFallback.executeCommand(command, args, options);
+        }
+        const timeout = options.timeout ?? this.commandTimeoutMs;
+        const script = commandScript(command, args, options.cwd);
+        const started = performance.now();
+        const response = await this.request(`${SANDBOX_EXEC_API_PATH}/${encodeURIComponent(this.id)}/exec-sync`, "POST", ExecuteResponseSchema, {
+            payload: {
+                cmd: "/bin/bash",
+                args: ["-lc", script],
+                envs: definedEnvironment(options.env),
+                execution_timeout: `${Math.max(1, Math.ceil(timeout / 1_000))}s`,
+            },
+            signal: options.abortSignal,
+        });
+        const stdout = response.stdout ?? "";
+        const stderr = response.stderr ?? "";
+        options.onStdout?.(stdout);
+        options.onStderr?.(stderr);
+        this.lastUsedAt = new Date();
+        const timedOut = response.status === "EXECUTE_COMMAND_STATUS_TIMED_OUT";
+        const exitCode = response.exit_code ?? -1;
+        return {
+            command,
+            args,
+            success: response.status === "EXECUTE_COMMAND_STATUS_COMPLETED" && exitCode === 0,
+            exitCode,
+            stdout,
+            stderr,
+            executionTimeMs: performance.now() - started,
+            ...(timedOut ? { timedOut: true, killed: true } : {}),
+            ...(response.truncated
+                ? {
+                    stdoutTruncated: true,
+                    stderrTruncated: true,
+                }
+                : {}),
+        };
+    }
+    /** Whether the adapter currently knows the remote sandbox to be running. */
+    async isReady() {
+        if (this.activeFallback) {
+            return this.activeFallback.isReady?.() ?? this.activeFallback.status === "running";
+        }
+        if (this.status === "running")
+            return true;
+        try {
+            const sandbox = await this.get();
+            this.status =
+                sandbox.status?.state === "SANDBOX_STATE_RUNNING" ? "running" : remoteStatus(sandbox);
+            return this.status === "running";
+        }
+        catch (caught) {
+            if (isStatus(caught, 404))
+                return false;
+            throw caught;
+        }
+    }
+    /** Report Mastra-facing sandbox metadata. */
+    async getInfo() {
+        if (this.activeFallback) {
+            return ((await this.activeFallback.getInfo?.()) ?? {
+                id: this.activeFallback.id,
+                name: this.activeFallback.name,
+                provider: this.activeFallback.provider,
+                status: this.activeFallback.status,
+                createdAt: this.createdAt,
+            });
+        }
+        const sandbox = await this.get();
+        this.status = remoteStatus(sandbox);
+        return {
+            id: this.id,
+            name: sandbox.display_name ?? this.name,
+            provider: this.provider,
+            status: this.status,
+            createdAt: this.remoteCreatedAt ?? this.createdAt,
+            ...(this.lastUsedAt ? { lastUsedAt: this.lastUsedAt } : {}),
+            metadata: {
+                resourceName: sandbox.name,
+                remoteState: sandbox.status?.state,
+                updateTime: sandbox.update_time,
+            },
+        };
+    }
+    /** Explain the Databricks execution boundary to the agent. */
+    getInstructions() {
+        return [
+            "Commands run in a persistent Databricks serverless sandbox, not in the App container.",
+            "Use shell commands normally. The sandbox home directory survives inactivity stops.",
+            "If Databricks Sandbox is unavailable, commands fall back to Pydantic Monty and must be Python source.",
+            "Databricks Workspace filesystem mounts remain separate unless a command copies data explicitly.",
+        ].join(" ");
+    }
+    get resourcePath() {
+        return `${SANDBOX_API_PATH}/${encodeURIComponent(this.id)}`;
+    }
+    async getOrCreate(signal) {
+        try {
+            return await this.get(signal);
+        }
+        catch (caught) {
+            if (!isStatus(caught, 404))
+                throw caught;
+        }
+        try {
+            const sandbox = await this.request(SANDBOX_API_PATH, "POST", SandboxResponseSchema, {
+                query: { sandbox_id: this.id },
+                payload: {
+                    display_name: this.displayName,
+                    spec: {
+                        compute: {
+                            inactivity_timeout: this.inactivityTimeout,
+                        },
+                    },
+                },
+                signal,
+            });
+            this.rememberCreatedAt(sandbox.create_time);
+            return sandbox;
+        }
+        catch (caught) {
+            if (!isStatus(caught, 409))
+                throw caught;
+            return this.get(signal);
+        }
+    }
+    async get(signal) {
+        const sandbox = await this.request(this.resourcePath, "GET", SandboxResponseSchema, {
+            signal,
+        });
+        this.rememberCreatedAt(sandbox.create_time);
+        return sandbox;
+    }
+    mutate(operation, signal) {
+        return this.request(`${this.resourcePath}/${operation}`, "POST", SandboxResponseSchema, {
+            signal,
+        });
+    }
+    async waitForState(expected, signal) {
+        const deadline = Date.now() + this.startupTimeoutMs;
+        while (Date.now() < deadline) {
+            const sandbox = await this.get(signal);
+            if (sandbox.status?.state === expected)
+                return sandbox;
+            await async.sleep(SANDBOX_POLL_INTERVAL_MS, signal);
+        }
+        throw new Error(`Databricks sandbox ${this.id} did not reach ${expected} within ${this.startupTimeoutMs}ms`);
+    }
+    rememberCreatedAt(value) {
+        if (!value)
+            return;
+        const parsed = new Date(value);
+        if (!Number.isNaN(parsed.getTime()))
+            this.remoteCreatedAt = parsed;
+    }
+    async request(path, method, schema, options = {}) {
+        const response = await this.client.apiClient.request({
+            path,
+            method,
+            query: options.query,
+            headers: new Headers({
+                Accept: "application/json",
+                ...(options.payload === undefined ? {} : { "Content-Type": "application/json" }),
+            }),
+            raw: false,
+            ...(options.payload === undefined ? {} : { payload: options.payload }),
+        }, options.signal ? databricks.toContext(options.signal) : undefined);
+        return schema.parse(response);
+    }
+}
+function commandScript(command, args, cwd) {
+    const invocation = args.length ? [command, ...args].map(shellQuote).join(" ") : command;
+    return cwd ? `cd -- ${shellQuote(cwd)} && ${invocation}` : invocation;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function definedEnvironment(input) {
+    return Object.fromEntries(Object.entries(input ?? {}).filter((entry) => entry[1] !== undefined));
+}
+function isStatus(caught, status) {
+    return error.errorContext(caught).statusCode === status;
+}
+function remoteStatus(sandbox) {
+    switch (sandbox.status?.state) {
+        case "SANDBOX_STATE_RUNNING":
+            return "running";
+        case "SANDBOX_STATE_STOPPED":
+            return "stopped";
+        case "SANDBOX_STATE_STOPPING":
+            return "stopping";
+        case "SANDBOX_STATE_PENDING":
+            return "starting";
+        default:
+            return "pending";
+    }
+}
+function resolveFallback(configured) {
+    if (typeof configured === "object" && "provider" in configured && "status" in configured) {
+        return configured;
+    }
+    return new MontySandbox(configured === "monty" ? {} : configured);
+}
+function isDatabricksSandboxUnavailable(caught) {
+    const context = error.errorContext(caught);
+    return (context.statusCode === 404 ||
+        context.hasMessage("feature", "disabled") ||
+        context.hasMessage("sandbox", "not", "enabled") ||
+        context.hasMessage("preview", "not", "enabled") ||
+        context.hasMessage("preview", "unavailable") ||
+        context.hasMessage("preview", "disabled"));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sandbox.js","sourceRoot":"","sources":["../../src/sandbox.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Databricks Sandbox adapter for Mastra workspaces.\n *\n * Implements Mastra's foreground command surface over the Databricks Sandbox\n * REST API. Sandboxes are created lazily, retain their home directory across\n * inactivity stops, and execute untrusted shell commands outside the App\n * container.\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/appkit\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { async, error, log, string } from \"@dbx-tools/shared-core\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport type {\n  CommandResult,\n  ExecuteCommandOptions,\n  ProviderStatus,\n  SandboxInfo,\n  WorkspaceSandbox,\n} from \"@mastra/core/workspace\";\nimport { z } from \"zod\";\nimport { MontySandbox, type MontySandboxOptions } from \"./monty-sandbox.ts\";\n\nconst SANDBOX_API_PATH = \"/api/2.0/sandboxes\";\nconst SANDBOX_EXEC_API_PATH = \"/api/2.0/sandbox-exec/sandboxes\";\nconst DEFAULT_INACTIVITY_TIMEOUT = \"900s\";\nconst DEFAULT_STARTUP_TIMEOUT_MS = 120_000;\nconst DEFAULT_COMMAND_TIMEOUT_MS = 30_000;\nconst SANDBOX_POLL_INTERVAL_MS = 500;\nconst logger = log.logger(\"mastra/sandbox\");\n\nconst SandboxStateSchema = z.object({\n  state: z.string().optional(),\n});\n\nconst SandboxResponseSchema = z.object({\n  name: z.string(),\n  display_name: z.string().optional(),\n  create_time: z.string().optional(),\n  update_time: z.string().optional(),\n  status: SandboxStateSchema.optional(),\n});\n\nconst ExecuteResponseSchema = z.object({\n  exit_code: z.number().int().optional(),\n  status: z.string(),\n  stdout: z.string().optional(),\n  stderr: z.string().optional(),\n  command_id: z.string().optional(),\n  truncated: z.boolean().optional(),\n});\n\n/** Options for one Databricks-backed Mastra sandbox. */\nexport interface DatabricksSandboxOptions {\n  /** AppKit workspace client used for every sandbox API call. */\n  client: WorkspaceClient;\n  /** Resource id, with or without the `sandboxes/` prefix. */\n  sandboxId: string;\n  /** Human-readable Databricks label. */\n  displayName?: string;\n  /** Server-side idle timeout in protobuf duration form. Defaults to `900s`. */\n  inactivityTimeout?: string;\n  /** Maximum time to wait for the sandbox to become runnable. */\n  startupTimeoutMs?: number;\n  /** Default command timeout. Per-call `options.timeout` wins. */\n  commandTimeoutMs?: number;\n  /**\n   * Provider used only when Databricks Sandbox is definitively unavailable.\n   * Defaults to the Node Pydantic Monty runtime; `false` fails instead.\n   */\n  fallback?: false | \"monty\" | MontySandboxOptions | WorkspaceSandbox;\n}\n\n/** Databricks options accepted by the higher-level workspace factory. */\nexport interface DatabricksWorkspaceSandboxOptions extends Omit<\n  DatabricksSandboxOptions,\n  \"client\" | \"sandboxId\"\n> {\n  /** Provider discriminator. Defaults to `databricks`. */\n  provider?: \"databricks\";\n  /**\n   * Credential source. Defaults to a fresh AppKit client using the normal\n   * environment/profile chain, which is the app service principal in a\n   * Databricks App.\n   */\n  client?: WorkspaceClient | ((context: { requestContext: RequestContext }) => WorkspaceClient);\n  /**\n   * Fixed id or per-request resolver. Omit to derive a stable, opaque id from\n   * the workspace and attributed user.\n   */\n  sandboxId?: string | ((context: { requestContext: RequestContext }) => string);\n}\n\n/** Mastra sandbox backed by Databricks serverless Sandbox compute. */\nexport class DatabricksSandbox implements WorkspaceSandbox {\n  readonly id: string;\n  readonly name: string;\n  status: ProviderStatus = \"pending\";\n  error?: string;\n\n  private readonly client: WorkspaceClient;\n  private readonly displayName: string;\n  private readonly inactivityTimeout: string;\n  private readonly startupTimeoutMs: number;\n  private readonly commandTimeoutMs: number;\n  private readonly fallbackConfig: Exclude<DatabricksSandboxOptions[\"fallback\"], undefined>;\n  private readonly createdAt = new Date();\n  private remoteCreatedAt?: Date;\n  private lastUsedAt?: Date;\n  private activeFallback?: WorkspaceSandbox;\n  private startPromise?: Promise<void>;\n\n  constructor(options: DatabricksSandboxOptions) {\n    const id = string.trimToNull(options.sandboxId.replace(/^sandboxes\\//, \"\"));\n    if (!id) throw new TypeError(\"Databricks sandbox id must not be blank\");\n    this.id = id;\n    this.name = options.displayName?.trim() || `Mastra sandbox ${id}`;\n    this.client = options.client;\n    this.displayName = this.name;\n    this.inactivityTimeout = options.inactivityTimeout ?? DEFAULT_INACTIVITY_TIMEOUT;\n    this.startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;\n    this.commandTimeoutMs = options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;\n    this.fallbackConfig = options.fallback ?? \"monty\";\n  }\n\n  get provider(): string {\n    return this.activeFallback?.provider ?? \"databricks\";\n  }\n\n  /** Ensure the remote sandbox exists and has reached its running state. */\n  async start(): Promise<void> {\n    await this.startWithSignal();\n  }\n\n  private async startWithSignal(signal?: AbortSignal): Promise<void> {\n    if (this.status === \"running\") return;\n    if (this.startPromise) {\n      await this.startPromise;\n      return;\n    }\n    const pending = this.performStart(signal);\n    this.startPromise = pending;\n    try {\n      await pending;\n    } finally {\n      if (this.startPromise === pending) this.startPromise = undefined;\n    }\n  }\n\n  private async performStart(signal?: AbortSignal): Promise<void> {\n    if (this.activeFallback) {\n      await this.activeFallback.start?.();\n      this.status = this.activeFallback.status;\n      return;\n    }\n    this.status = \"starting\";\n    this.error = undefined;\n    try {\n      let sandbox = await this.getOrCreate(signal);\n      if (sandbox.status?.state === \"SANDBOX_STATE_STOPPED\") {\n        sandbox = await this.mutate(\"start\", signal);\n      }\n      if (sandbox.status?.state === \"SANDBOX_STATE_STOPPING\") {\n        await this.waitForState(\"SANDBOX_STATE_STOPPED\", signal);\n        sandbox = await this.mutate(\"start\", signal);\n      }\n      if (sandbox.status?.state !== \"SANDBOX_STATE_RUNNING\") {\n        await this.waitForState(\"SANDBOX_STATE_RUNNING\", signal);\n      }\n      this.status = \"running\";\n      this.lastUsedAt = new Date();\n    } catch (caught) {\n      if (this.fallbackConfig !== false && isDatabricksSandboxUnavailable(caught)) {\n        const fallback = resolveFallback(this.fallbackConfig);\n        logger.warn(\"Databricks Sandbox unavailable; using fallback\", {\n          sandboxId: this.id,\n          fallback: fallback.provider,\n          error: error.errorMessage(caught),\n        });\n        await fallback.start?.();\n        this.activeFallback = fallback;\n        this.status = fallback.status;\n        this.error = fallback.error;\n        return;\n      }\n      this.status = \"error\";\n      this.error = error.errorMessage(caught);\n      throw caught;\n    }\n  }\n\n  /** Databricks home persistence is not a cloneable Mastra checkpoint. */\n  async snapshot(): Promise<void> {\n    await this.activeFallback?.snapshot();\n  }\n\n  get supportsCheckpoints(): boolean {\n    return this.activeFallback?.supportsCheckpoints ?? false;\n  }\n\n  /** Stop compute while preserving the sandbox home directory. */\n  async stop(): Promise<void> {\n    if (this.activeFallback) {\n      await this.activeFallback.stop?.();\n      this.status = this.activeFallback.status;\n      return;\n    }\n    if (this.status === \"stopped\" || this.status === \"destroyed\") return;\n    this.status = \"stopping\";\n    try {\n      await this.mutate(\"stop\");\n      this.status = \"stopped\";\n    } catch (caught) {\n      if (isStatus(caught, 404)) {\n        this.status = \"stopped\";\n        return;\n      }\n      this.status = \"error\";\n      this.error = error.errorMessage(caught);\n      throw caught;\n    }\n  }\n\n  /** Permanently delete the sandbox and its persisted home directory. */\n  async destroy(): Promise<void> {\n    if (this.activeFallback) {\n      await this.activeFallback.destroy?.();\n      this.status = this.activeFallback.status;\n      return;\n    }\n    if (this.status === \"destroyed\") return;\n    this.status = \"destroying\";\n    try {\n      await this.request(`${this.resourcePath}`, \"DELETE\", z.object({}).passthrough());\n      this.status = \"destroyed\";\n    } catch (caught) {\n      if (isStatus(caught, 404)) {\n        this.status = \"destroyed\";\n        return;\n      }\n      this.status = \"error\";\n      this.error = error.errorMessage(caught);\n      throw caught;\n    }\n  }\n\n  /** Execute one foreground shell command in the remote sandbox. */\n  async executeCommand(\n    command: string,\n    args: string[] = [],\n    options: ExecuteCommandOptions = {},\n  ): Promise<CommandResult> {\n    await this.startWithSignal(options.abortSignal);\n    if (this.activeFallback) {\n      if (!this.activeFallback.executeCommand) {\n        return {\n          command,\n          args,\n          success: false,\n          exitCode: 1,\n          stdout: \"\",\n          stderr: `Fallback sandbox ${this.activeFallback.provider} does not support command execution.`,\n          executionTimeMs: 0,\n        };\n      }\n      return this.activeFallback.executeCommand(command, args, options);\n    }\n    const timeout = options.timeout ?? this.commandTimeoutMs;\n    const script = commandScript(command, args, options.cwd);\n    const started = performance.now();\n    const response = await this.request(\n      `${SANDBOX_EXEC_API_PATH}/${encodeURIComponent(this.id)}/exec-sync`,\n      \"POST\",\n      ExecuteResponseSchema,\n      {\n        payload: {\n          cmd: \"/bin/bash\",\n          args: [\"-lc\", script],\n          envs: definedEnvironment(options.env),\n          execution_timeout: `${Math.max(1, Math.ceil(timeout / 1_000))}s`,\n        },\n        signal: options.abortSignal,\n      },\n    );\n    const stdout = response.stdout ?? \"\";\n    const stderr = response.stderr ?? \"\";\n    options.onStdout?.(stdout);\n    options.onStderr?.(stderr);\n    this.lastUsedAt = new Date();\n    const timedOut = response.status === \"EXECUTE_COMMAND_STATUS_TIMED_OUT\";\n    const exitCode = response.exit_code ?? -1;\n    return {\n      command,\n      args,\n      success: response.status === \"EXECUTE_COMMAND_STATUS_COMPLETED\" && exitCode === 0,\n      exitCode,\n      stdout,\n      stderr,\n      executionTimeMs: performance.now() - started,\n      ...(timedOut ? { timedOut: true, killed: true } : {}),\n      ...(response.truncated\n        ? {\n            stdoutTruncated: true,\n            stderrTruncated: true,\n          }\n        : {}),\n    };\n  }\n\n  /** Whether the adapter currently knows the remote sandbox to be running. */\n  async isReady(): Promise<boolean> {\n    if (this.activeFallback) {\n      return this.activeFallback.isReady?.() ?? this.activeFallback.status === \"running\";\n    }\n    if (this.status === \"running\") return true;\n    try {\n      const sandbox = await this.get();\n      this.status =\n        sandbox.status?.state === \"SANDBOX_STATE_RUNNING\" ? \"running\" : remoteStatus(sandbox);\n      return this.status === \"running\";\n    } catch (caught) {\n      if (isStatus(caught, 404)) return false;\n      throw caught;\n    }\n  }\n\n  /** Report Mastra-facing sandbox metadata. */\n  async getInfo(): Promise<SandboxInfo> {\n    if (this.activeFallback) {\n      return (\n        (await this.activeFallback.getInfo?.()) ?? {\n          id: this.activeFallback.id,\n          name: this.activeFallback.name,\n          provider: this.activeFallback.provider,\n          status: this.activeFallback.status,\n          createdAt: this.createdAt,\n        }\n      );\n    }\n    const sandbox = await this.get();\n    this.status = remoteStatus(sandbox);\n    return {\n      id: this.id,\n      name: sandbox.display_name ?? this.name,\n      provider: this.provider,\n      status: this.status,\n      createdAt: this.remoteCreatedAt ?? this.createdAt,\n      ...(this.lastUsedAt ? { lastUsedAt: this.lastUsedAt } : {}),\n      metadata: {\n        resourceName: sandbox.name,\n        remoteState: sandbox.status?.state,\n        updateTime: sandbox.update_time,\n      },\n    };\n  }\n\n  /** Explain the Databricks execution boundary to the agent. */\n  getInstructions(): string {\n    return [\n      \"Commands run in a persistent Databricks serverless sandbox, not in the App container.\",\n      \"Use shell commands normally. The sandbox home directory survives inactivity stops.\",\n      \"If Databricks Sandbox is unavailable, commands fall back to Pydantic Monty and must be Python source.\",\n      \"Databricks Workspace filesystem mounts remain separate unless a command copies data explicitly.\",\n    ].join(\" \");\n  }\n\n  private get resourcePath(): string {\n    return `${SANDBOX_API_PATH}/${encodeURIComponent(this.id)}`;\n  }\n\n  private async getOrCreate(signal?: AbortSignal) {\n    try {\n      return await this.get(signal);\n    } catch (caught) {\n      if (!isStatus(caught, 404)) throw caught;\n    }\n    try {\n      const sandbox = await this.request(SANDBOX_API_PATH, \"POST\", SandboxResponseSchema, {\n        query: { sandbox_id: this.id },\n        payload: {\n          display_name: this.displayName,\n          spec: {\n            compute: {\n              inactivity_timeout: this.inactivityTimeout,\n            },\n          },\n        },\n        signal,\n      });\n      this.rememberCreatedAt(sandbox.create_time);\n      return sandbox;\n    } catch (caught) {\n      if (!isStatus(caught, 409)) throw caught;\n      return this.get(signal);\n    }\n  }\n\n  private async get(signal?: AbortSignal) {\n    const sandbox = await this.request(this.resourcePath, \"GET\", SandboxResponseSchema, {\n      signal,\n    });\n    this.rememberCreatedAt(sandbox.create_time);\n    return sandbox;\n  }\n\n  private mutate(operation: \"start\" | \"stop\", signal?: AbortSignal) {\n    return this.request(`${this.resourcePath}/${operation}`, \"POST\", SandboxResponseSchema, {\n      signal,\n    });\n  }\n\n  private async waitForState(expected: string, signal?: AbortSignal) {\n    const deadline = Date.now() + this.startupTimeoutMs;\n    while (Date.now() < deadline) {\n      const sandbox = await this.get(signal);\n      if (sandbox.status?.state === expected) return sandbox;\n      await async.sleep(SANDBOX_POLL_INTERVAL_MS, signal);\n    }\n    throw new Error(\n      `Databricks sandbox ${this.id} did not reach ${expected} within ${this.startupTimeoutMs}ms`,\n    );\n  }\n\n  private rememberCreatedAt(value: string | undefined): void {\n    if (!value) return;\n    const parsed = new Date(value);\n    if (!Number.isNaN(parsed.getTime())) this.remoteCreatedAt = parsed;\n  }\n\n  private async request<T>(\n    path: string,\n    method: \"GET\" | \"POST\" | \"DELETE\",\n    schema: z.ZodType<T>,\n    options: {\n      payload?: unknown;\n      query?: Record<string, string>;\n      signal?: AbortSignal;\n    } = {},\n  ): Promise<T> {\n    const response = await this.client.apiClient.request(\n      {\n        path,\n        method,\n        query: options.query,\n        headers: new Headers({\n          Accept: \"application/json\",\n          ...(options.payload === undefined ? {} : { \"Content-Type\": \"application/json\" }),\n        }),\n        raw: false,\n        ...(options.payload === undefined ? {} : { payload: options.payload }),\n      },\n      options.signal ? databricks.toContext(options.signal) : undefined,\n    );\n    return schema.parse(response);\n  }\n}\n\nfunction commandScript(command: string, args: readonly string[], cwd: string | undefined): string {\n  const invocation = args.length ? [command, ...args].map(shellQuote).join(\" \") : command;\n  return cwd ? `cd -- ${shellQuote(cwd)} && ${invocation}` : invocation;\n}\n\nfunction shellQuote(value: string): string {\n  return `'${value.replaceAll(\"'\", \"'\\\\''\")}'`;\n}\n\nfunction definedEnvironment(input: NodeJS.ProcessEnv | undefined): Record<string, string> {\n  return Object.fromEntries(\n    Object.entries(input ?? {}).filter(\n      (entry): entry is [string, string] => entry[1] !== undefined,\n    ),\n  );\n}\n\nfunction isStatus(caught: unknown, status: number): boolean {\n  return error.errorContext(caught).statusCode === status;\n}\n\nfunction remoteStatus(sandbox: z.infer<typeof SandboxResponseSchema>): ProviderStatus {\n  switch (sandbox.status?.state) {\n    case \"SANDBOX_STATE_RUNNING\":\n      return \"running\";\n    case \"SANDBOX_STATE_STOPPED\":\n      return \"stopped\";\n    case \"SANDBOX_STATE_STOPPING\":\n      return \"stopping\";\n    case \"SANDBOX_STATE_PENDING\":\n      return \"starting\";\n    default:\n      return \"pending\";\n  }\n}\n\nfunction resolveFallback(\n  configured: Exclude<DatabricksSandboxOptions[\"fallback\"], false | undefined>,\n): WorkspaceSandbox {\n  if (typeof configured === \"object\" && \"provider\" in configured && \"status\" in configured) {\n    return configured;\n  }\n  return new MontySandbox(configured === \"monty\" ? {} : configured);\n}\n\nfunction isDatabricksSandboxUnavailable(caught: unknown): boolean {\n  const context = error.errorContext(caught);\n  return (\n    context.statusCode === 404 ||\n    context.hasMessage(\"feature\", \"disabled\") ||\n    context.hasMessage(\"sandbox\", \"not\", \"enabled\") ||\n    context.hasMessage(\"preview\", \"not\", \"enabled\") ||\n    context.hasMessage(\"preview\", \"unavailable\") ||\n    context.hasMessage(\"preview\", \"disabled\")\n  );\n}\n"]}

package/lib/src/serving-sanitize.d.ts

@@ -5,7 +5,8 @@
  * Outbound ({@link rewriteServingBody}), because the transcript Mastra
  * persists is not always a transcript the provider will accept back:
  * Databricks-hosted Claude rejects replayed extended-thinking blocks and reads
- * a trailing assistant message as a prefill request.
+ * a trailing assistant message as a prefill request, while GPT Astra requires
+ * `reasoning_effort: "none"` when Chat Completions carries function tools.
  *
  * Inbound ({@link rewriteServingResponseBody} and
  * {@link rewriteServingResponseStream}), because Databricks-hosted Gemini and
@@ -38,6 +39,22 @@ export interface ServingChatMessage extends ChatMessage {
  * JSON or no rewrite was needed.
  */
 export declare function rewriteServingBody(body: string): string;
+/** Prepared fetch arguments plus the post-sanitize body used for diagnostics. */
+export interface RewrittenServingRequest {
+    input: Parameters<typeof fetch>[0];
+    init: Parameters<typeof fetch>[1];
+    body: string;
+}
+/**
+ * Read and rewrite a serving POST whether its JSON body lives on `init` or on
+ * a `Request`. A changed Request is rebuilt without stale byte headers.
+ */
+export declare function rewriteServingRequest(input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]): Promise<RewrittenServingRequest>;
+/**
+ * Add the Chat Completions option Databricks-hosted GPT Astra requires when
+ * function tools are present. An explicit caller value always wins.
+ */
+export declare function applyAstraToolCompatibility(body: Record<string, unknown>): boolean;
 /**
  * Drop extended-thinking / reasoning blocks from a replayed transcript.
  *