@5ss/ai-tools 2.11.1

package/dist/cloudflare-sandbox-Dp_uNaqW.js

@@ -0,0 +1,982 @@
+import { t as ToolError } from "./errors-DoSpNHvs.js";
+import { n as defineModule, r as defineTool } from "./define-CvpJ_pNP.js";
+import { n as requireAuth } from "./provider-CgDAlg6K.js";
+import { t as HttpService } from "./http-service-DDNCO1s4.js";
+import { a as toArrayBuffer, n as bytesToBase64, o as utf8ToBytes, r as bytesToUtf8, t as base64ToBytes } from "./bytes-BxpimpQx.js";
+import { m as s3AuthSchema, p as S3Client } from "./s3-CsOaPWMP.js";
+import { isPlainObject, isString, trimEnd } from "es-toolkit";
+import { z } from "zod";
+//#region src/vendors/cloudflare-sandbox/contracts.ts
+/**
+* Cloudflare Sandbox Bridge HTTP API contracts.
+* Host deploys the bridge Worker; this pack is a Bearer client.
+* @see https://developers.cloudflare.com/sandbox/bridge/http-api/
+*/
+const MAX_ARGV = 64;
+const MAX_ARG_CHARS = 1e5;
+const MAX_FILE_PATH = 1024;
+const MAX_FILE_TEXT = 2e6;
+/** Bridge hard cap is 32 MiB; package tool path uses the same bound. */
+const MAX_FILE_BYTES = 32 * 1024 * 1024;
+const MAX_WRITE_FILES = 20;
+const MAX_READ_PATHS = 50;
+const MAX_LIST_FILES = 500;
+const DEFAULT_EXEC_TIMEOUT_MS = 3e4;
+const MAX_EXEC_TIMEOUT_MS = 6e5;
+const cloudflareSandboxAuthSchema = z.object({
+	base_url: z.string().min(1).describe("Sandbox bridge Worker origin, for example https://sandbox-bridge.example.workers.dev"),
+	api_key: z.string().min(1).describe("Bridge SANDBOX_API_KEY Bearer token"),
+	storage: s3AuthSchema.optional().describe("Optional S3-compatible storage for importArtifact / exportArtifact (ArtifactRef)")
+});
+/** Object-store ArtifactRef for sandbox import/export. */
+const sandboxObjectArtifactRefSchema = z.object({
+	store: z.literal("object").describe("Object store containing the artifact"),
+	key: z.string().min(1).describe("Object key"),
+	media_type: z.string().min(1).optional().describe("MIME or format hint when known"),
+	filename: z.string().min(1).optional().describe("Original or display file name"),
+	byte_length: z.int().min(0).optional().describe("Size in bytes when known")
+});
+const sandboxId = z.string().min(1).max(200).describe("Sandbox id returned by create");
+const sandboxIdInputSchema = z.object({ sandbox_id: sandboxId });
+const createSandboxOutputSchema = z.object({ sandbox_id: z.string().describe("Created sandbox id") });
+const destroySandboxOutputSchema = z.object({
+	sandbox_id: z.string(),
+	destroyed: z.literal(true)
+});
+const runningOutputSchema = z.object({
+	sandbox_id: z.string(),
+	running: z.boolean().describe("Whether the container is live")
+});
+const healthOutputSchema = z.object({ ok: z.boolean() });
+const execInputSchema = z.object({
+	sandbox_id: sandboxId,
+	argv: z.array(z.string().min(1).max(MAX_ARG_CHARS)).min(1).max(64).describe("Command argv array (not a shell string). Example: [\"python3\",\"-c\",\"print(1)\"]"),
+	timeout_ms: z.int().min(1).max(MAX_EXEC_TIMEOUT_MS).optional().describe(`Exec timeout in ms (default ${DEFAULT_EXEC_TIMEOUT_MS})`),
+	cwd: z.string().min(1).max(MAX_FILE_PATH).optional().describe("Working directory (default /workspace)"),
+	session_id: z.string().min(1).max(200).optional().describe("Optional bridge session id for isolated working directory and runtime state"),
+	env: z.record(z.string().min(1).max(128), z.string().max(8192)).optional().describe("Optional environment variables for the process when the bridge supports env")
+});
+const execOutputSchema = z.object({
+	sandbox_id: z.string(),
+	stdout: z.string().describe("Decoded standard output"),
+	stderr: z.string().describe("Decoded standard error"),
+	exit_code: z.number().int().optional().describe("Process exit code when the stream ends with exit"),
+	success: z.boolean().describe("True when exit_code is 0"),
+	error: z.string().optional().describe("Bridge error message when the stream ends with error"),
+	error_code: z.string().optional().describe("Bridge error code when present")
+});
+const filePathField = z.string().min(1).max(MAX_FILE_PATH).describe("Path under workspace (with or without /workspace/ prefix)");
+const sessionIdField = z.string().min(1).max(200).optional().describe("Optional Session-Id header");
+const writeFileBodyFields = {
+	text: z.string().max(MAX_FILE_TEXT).optional().describe("Utf-8 file contents (omit when body_base64 is set)"),
+	body_base64: z.string().min(1).optional().describe("Base64 file bytes for binary content (omit when text is set; max 32 MiB decoded)")
+};
+function refineExactlyOneBody(val, ctx) {
+	if (val.text !== void 0 === (val.body_base64 !== void 0)) ctx.addIssue({
+		code: "custom",
+		message: "Provide exactly one of text or body_base64"
+	});
+}
+const writeFileInputSchema = z.object({
+	sandbox_id: sandboxId,
+	path: filePathField,
+	...writeFileBodyFields,
+	session_id: sessionIdField
+}).superRefine(refineExactlyOneBody);
+const writeFileOutputSchema = z.object({
+	sandbox_id: z.string(),
+	path: z.string(),
+	ok: z.literal(true),
+	byte_length: z.number().int().nonnegative().optional().describe("Decoded byte length written when known")
+});
+const readFileInputSchema = z.object({
+	sandbox_id: sandboxId,
+	path: filePathField,
+	encoding: z.enum(["utf8", "base64"]).optional().describe("Response encoding (default utf8 for text; use base64 for binary)"),
+	session_id: sessionIdField
+});
+const readFileOutputSchema = z.object({
+	sandbox_id: z.string(),
+	path: z.string(),
+	text: z.string().optional().describe("Utf-8 contents when encoding is utf8 (default)"),
+	body_base64: z.string().optional().describe("Base64 contents when encoding is base64"),
+	byte_length: z.number().int().nonnegative().optional().describe("Decoded byte length")
+});
+const writeFilesInputSchema = z.object({
+	sandbox_id: sandboxId,
+	files: z.array(z.object({
+		path: z.string().min(1).max(MAX_FILE_PATH).describe("Path under workspace"),
+		...writeFileBodyFields
+	}).superRefine(refineExactlyOneBody)).min(1).max(20).describe("Files to write under workspace (text or body_base64 each)"),
+	session_id: sessionIdField
+});
+const writeFilesOutputSchema = z.object({
+	sandbox_id: z.string(),
+	paths: z.array(z.string()),
+	ok: z.literal(true)
+});
+const readFilesInputSchema = z.object({
+	sandbox_id: sandboxId,
+	paths: z.array(z.string().min(1).max(MAX_FILE_PATH).describe("Path under workspace")).min(1).max(50).describe("Paths to read under workspace"),
+	encoding: z.enum(["utf8", "base64"]).optional().describe("Response encoding for all files (default utf8)"),
+	session_id: sessionIdField
+});
+const readFilesOutputSchema = z.object({
+	sandbox_id: z.string(),
+	files: z.array(z.object({
+		path: z.string(),
+		text: z.string().optional(),
+		body_base64: z.string().optional(),
+		byte_length: z.number().int().nonnegative().optional()
+	}))
+});
+const listFilesInputSchema = z.object({
+	sandbox_id: sandboxId,
+	directory_path: z.string().max(MAX_FILE_PATH).optional().describe("Directory to list (default /workspace)"),
+	session_id: sessionIdField
+});
+const listFilesOutputSchema = z.object({
+	sandbox_id: z.string(),
+	paths: z.array(z.string()).describe("Absolute or workspace-relative file paths found"),
+	raw: z.unknown().optional().describe("Provider listing payload when available")
+});
+const removeFilesInputSchema = z.object({
+	sandbox_id: sandboxId,
+	paths: z.array(z.string().min(1).max(MAX_FILE_PATH)).min(1).max(50).describe("Paths to remove under workspace"),
+	session_id: sessionIdField
+});
+const removeFilesOutputSchema = z.object({
+	sandbox_id: z.string(),
+	paths: z.array(z.string()),
+	ok: z.literal(true)
+});
+const importArtifactInputSchema = z.object({
+	sandbox_id: sandboxId,
+	path: filePathField,
+	source: sandboxObjectArtifactRefSchema.describe("Object-store ArtifactRef to copy into the sandbox"),
+	session_id: sessionIdField
+});
+const importArtifactOutputSchema = z.object({
+	sandbox_id: z.string(),
+	path: z.string(),
+	ok: z.literal(true),
+	byte_length: z.number().int().nonnegative()
+});
+const exportArtifactInputSchema = z.object({
+	sandbox_id: sandboxId,
+	path: filePathField,
+	destination_key: z.string().min(1).describe("Object key to write under bound storage"),
+	session_id: sessionIdField
+});
+const exportArtifactOutputSchema = z.object({
+	sandbox_id: z.string(),
+	path: z.string(),
+	artifact: sandboxObjectArtifactRefSchema
+});
+const createBridgeSessionOutputSchema = z.object({
+	sandbox_id: z.string(),
+	session_id: z.string().describe("Bridge session id for Session-Id header")
+});
+const deleteBridgeSessionInputSchema = z.object({
+	sandbox_id: sandboxId,
+	session_id: z.string().min(1).max(200).describe("Bridge session id to delete")
+});
+const deleteBridgeSessionOutputSchema = z.object({
+	sandbox_id: z.string(),
+	session_id: z.string(),
+	deleted: z.literal(true)
+});
+const executeCodeInputSchema = z.object({
+	sandbox_id: sandboxId,
+	code: z.string().min(1).max(MAX_ARG_CHARS).describe("Source code to run"),
+	language: z.enum([
+		"python",
+		"javascript",
+		"typescript",
+		"shell"
+	]).optional().describe("Runtime language (default python)"),
+	timeout_ms: z.int().min(1).max(MAX_EXEC_TIMEOUT_MS).optional().describe(`Exec timeout in ms (default ${DEFAULT_EXEC_TIMEOUT_MS})`),
+	session_id: z.string().min(1).max(200).optional().describe("Optional bridge session id for isolated working directory and runtime state")
+});
+/**
+* Mount an S3-compatible bucket into the sandbox filesystem.
+* @see https://developers.cloudflare.com/sandbox/bridge/http-api/#bucket-mounts
+*
+* Two bridge modes:
+* - **R2 binding:** omit `endpoint`; `bucket` is the Worker R2 binding name.
+* - **Remote S3/R2/GCS:** set `endpoint` (+ optional credentials; bridge may use Worker secrets).
+*/
+const mountBucketInputSchema = z.object({
+	sandbox_id: sandboxId,
+	bucket: z.string().min(1).max(256).describe("R2 Worker binding name when endpoint is omitted; otherwise the remote bucket name (e.g. for S3/R2 endpoint mounts)"),
+	mount_path: z.string().min(1).max(MAX_FILE_PATH).refine((p) => p.startsWith("/"), { message: "mount_path must be an absolute path (start with /)" }).describe("Absolute path inside the sandbox to mount at (e.g. /data or /mnt/workspace)"),
+	endpoint: z.url().optional().describe("S3-compatible endpoint URL (e.g. https://s3.amazonaws.com or https://ACCOUNT.r2.cloudflarestorage.com). Omit for Worker R2 binding mounts"),
+	provider: z.enum([
+		"r2",
+		"s3",
+		"gcs"
+	]).optional().describe("Provider hint for s3fs optimizations when using endpoint mounts"),
+	read_only: z.boolean().optional().describe("Mount read-only (default false)"),
+	prefix: z.string().min(1).max(MAX_FILE_PATH).optional().describe("Bucket prefix/subdirectory to expose at the mount (must start with / when set)"),
+	access_key_id: z.string().min(1).optional().describe("Access key for endpoint mounts (maps to bridge credentials.accessKeyId)"),
+	secret_access_key: z.string().min(1).optional().describe("Secret key for endpoint mounts (maps to bridge credentials.secretAccessKey)"),
+	credential_proxy: z.boolean().optional().describe("When true, bridge keeps credentials out of the container (egress signing). Endpoint mounts only; requires ContainerProxy on the bridge Worker"),
+	local_bucket: z.boolean().optional().describe("When true, use local R2 binding sync (wrangler dev). Mutually exclusive with endpoint"),
+	s3fs_options: z.array(z.string().min(1).max(256)).max(32).optional().describe("Advanced s3fs mount flags (e.g. use_cache=/tmp/cache)")
+});
+const mountBucketOutputSchema = z.object({
+	sandbox_id: z.string(),
+	bucket: z.string(),
+	mount_path: z.string(),
+	ok: z.literal(true)
+});
+const unmountBucketInputSchema = z.object({
+	sandbox_id: sandboxId,
+	mount_path: z.string().min(1).max(MAX_FILE_PATH).refine((p) => p.startsWith("/"), { message: "mount_path must be an absolute path (start with /)" }).describe("Absolute mount path previously passed to mount")
+});
+const unmountBucketOutputSchema = z.object({
+	sandbox_id: z.string(),
+	mount_path: z.string(),
+	ok: z.literal(true)
+});
+//#endregion
+//#region src/vendors/cloudflare-sandbox/domain.ts
+/**
+* Cloudflare Sandbox Bridge pure helpers (no HTTP).
+*/
+/** Normalize a host path to the bridge URL segment under /file/… (no leading slash). */
+function workspaceFileKey(path) {
+	const trimmed = path.trim();
+	if (!trimmed) throw new ToolError("File path is empty", { code: "bad_input" });
+	const noLead = trimmed.replace(/^\/+/, "");
+	const under = noLead.startsWith("workspace/") ? noLead : `workspace/${noLead}`;
+	if (under.split("/").some((p) => p === ".." || p === "")) throw new ToolError("File path must stay under workspace", {
+		code: "bad_input",
+		details: { path: trimmed }
+	});
+	return under;
+}
+/** Absolute workspace path for shell list/rm (leading slash). */
+function workspaceAbsolutePath(path) {
+	return `/${workspaceFileKey(path)}`;
+}
+/** Shell-safe single-quoted string. */
+function shellQuote(value) {
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+/**
+* Resolve write-file body to raw bytes (text UTF-8 or base64).
+* Enforces MAX_FILE_BYTES (bridge limit).
+*/
+function resolveWriteFileBytes(input) {
+	if (input.body_base64 !== void 0 && input.text !== void 0) throw new ToolError("Provide exactly one of text or body_base64", { code: "bad_input" });
+	if (input.body_base64 !== void 0) {
+		const bytes = base64ToBytes(input.body_base64);
+		if (bytes.byteLength > 33554432) throw new ToolError("Sandbox file exceeds max byte limit", {
+			code: "too_large",
+			details: {
+				max_bytes: MAX_FILE_BYTES,
+				content_length: bytes.byteLength
+			}
+		});
+		return bytes;
+	}
+	if (input.text !== void 0) {
+		const bytes = utf8ToBytes(input.text);
+		if (bytes.byteLength > 33554432) throw new ToolError("Sandbox file exceeds max byte limit", {
+			code: "too_large",
+			details: {
+				max_bytes: MAX_FILE_BYTES,
+				content_length: bytes.byteLength
+			}
+		});
+		return bytes;
+	}
+	throw new ToolError("Provide exactly one of text or body_base64", { code: "bad_input" });
+}
+/**
+* Parse bridge /exec text/event-stream body.
+* Events: stdout/stderr (base64 data), exit ({"exit_code":N}), error ({"error","code"}).
+*/
+function parseExecSse(body, options = {}) {
+	const stdoutChunks = [];
+	const stderrChunks = [];
+	let exit_code;
+	let error;
+	let error_code;
+	const blocks = body.replaceAll("\r\n", "\n").split("\n\n");
+	for (const block of blocks) {
+		const lines = block.split("\n").filter((line) => line.length > 0);
+		if (lines.length === 0) continue;
+		let event = "message";
+		const dataLines = [];
+		for (const line of lines) if (line.startsWith("event:")) event = line.slice(6).trim();
+		else if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+		const data = dataLines.join("\n");
+		if (event === "stdout" && data.length > 0) {
+			const chunk = decodeBase64Chunk(data);
+			stdoutChunks.push(chunk);
+			options.onStdout?.(chunk);
+		} else if (event === "stderr" && data.length > 0) {
+			const chunk = decodeBase64Chunk(data);
+			stderrChunks.push(chunk);
+			options.onStderr?.(chunk);
+		} else if (event === "exit" && data.length > 0) {
+			const parsed = safeJson(data);
+			if (isPlainObject(parsed)) {
+				const code = parsed["exit_code"];
+				if (typeof code === "number" && Number.isFinite(code)) exit_code = code;
+			}
+		} else if (event === "error" && data.length > 0) {
+			const parsed = safeJson(data);
+			if (isPlainObject(parsed)) {
+				if (isString(parsed["error"])) error = parsed["error"];
+				if (isString(parsed["code"])) error_code = parsed["code"];
+			} else error = data;
+		}
+	}
+	const out = {
+		stdout: stdoutChunks.join(""),
+		stderr: stderrChunks.join("")
+	};
+	if (exit_code !== void 0) out.exit_code = exit_code;
+	if (error !== void 0) out.error = error;
+	if (error_code !== void 0) out.error_code = error_code;
+	return out;
+}
+function decodeBase64Chunk(data) {
+	try {
+		if (typeof Buffer !== "undefined") return Buffer.from(data, "base64").toString("utf8");
+		const binary = atob(data);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+		return new TextDecoder().decode(bytes);
+	} catch {
+		return data;
+	}
+}
+function safeJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/** Build argv for executeCode over the bridge (no native runCode route). */
+function executeCodeArgv(language, code) {
+	switch (language) {
+		case "javascript":
+		case "typescript": return [
+			"node",
+			"-e",
+			code
+		];
+		case "shell": return [
+			"sh",
+			"-lc",
+			code
+		];
+		default: return [
+			"python3",
+			"-c",
+			code
+		];
+	}
+}
+//#endregion
+//#region src/vendors/cloudflare-sandbox/client.ts
+/**
+* Cloudflare Sandbox Bridge vendor client (HttpService + Bearer).
+* Host: `new CloudflareSandboxClient(auth)`. Agent: `fromContext(ctx)`.
+* Gold: `src/vendors/resend/client.ts` + messaging ArtifactRef storage pattern.
+* @see https://developers.cloudflare.com/sandbox/bridge/http-api/
+*/
+var CloudflareSandboxClient = class CloudflareSandboxClient {
+	#http;
+	#storage;
+	/** Optional S3 auth fields for endpoint mount credential fallback (Mastra workspace FS). */
+	#storageAuth;
+	constructor(auth, options = {}) {
+		const parsed = cloudflareSandboxAuthSchema.safeParse(auth);
+		if (!parsed.success) throw new ToolError("Invalid Cloudflare Sandbox auth credentials", {
+			code: "bad_auth",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		this.#http = new HttpService({
+			baseURL: trimEnd(parsed.data.base_url, "/"),
+			headers: { Authorization: `Bearer ${parsed.data.api_key}` },
+			timeout: 12e4,
+			label: "Cloudflare Sandbox",
+			...options.fetch && { fetch: options.fetch },
+			...options.signal && { signal: options.signal }
+		});
+		this.#storage = parsed.data.storage ? new S3Client(parsed.data.storage, {
+			...options.fetch && { fetch: options.fetch },
+			...options.signal && { signal: options.signal }
+		}) : void 0;
+		this.#storageAuth = parsed.data.storage ? {
+			access_key_id: parsed.data.storage.access_key_id,
+			secret_access_key: parsed.data.storage.secret_access_key,
+			...parsed.data.storage.endpoint && { endpoint: parsed.data.storage.endpoint }
+		} : void 0;
+	}
+	static fromContext(ctx) {
+		return new CloudflareSandboxClient(requireAuth(ctx, cloudflareSandboxAuthSchema), {
+			...ctx.fetch && { fetch: ctx.fetch },
+			...ctx.signal && { signal: ctx.signal }
+		});
+	}
+	/** Liveness probe on the bridge. */
+	async health() {
+		const { data } = await this.#http.get("/health", { label: "Cloudflare Sandbox health" });
+		if (isPlainObject(data) && data["ok"] === true) return { ok: true };
+		if (isPlainObject(data) && data["ok"] === false) return { ok: false };
+		return { ok: true };
+	}
+	async create() {
+		const { data } = await this.#http.post("/v1/sandbox", void 0, { label: "Cloudflare Sandbox create" });
+		if (!isPlainObject(data) || !isString(data["id"])) throw new ToolError("Unexpected create sandbox response", { code: "upstream" });
+		return { sandbox_id: data["id"] };
+	}
+	async destroy(input) {
+		await this.#http.delete(`/v1/sandbox/${encodeURIComponent(input.sandbox_id)}`, { label: "Cloudflare Sandbox destroy" });
+		return {
+			sandbox_id: input.sandbox_id,
+			destroyed: true
+		};
+	}
+	async running(input) {
+		const { data } = await this.#http.get(`/v1/sandbox/${encodeURIComponent(input.sandbox_id)}/running`, { label: "Cloudflare Sandbox running" });
+		if (!isPlainObject(data) || typeof data["running"] !== "boolean") throw new ToolError("Unexpected running response", { code: "upstream" });
+		return {
+			sandbox_id: input.sandbox_id,
+			running: data["running"]
+		};
+	}
+	/**
+	* Run a command. Bridge returns text/event-stream (stdout/stderr base64 + exit).
+	* Uses HttpService.bytes so ofetch does not try to JSON-parse the SSE body.
+	* Optional onStdout/onStderr fire while walking the buffered SSE (not true wire streaming).
+	*/
+	async exec(input, stream = {}) {
+		const body = {
+			argv: input.argv,
+			timeout_ms: input.timeout_ms ?? 3e4
+		};
+		if (input.cwd) body["cwd"] = input.cwd;
+		if (input.env && Object.keys(input.env).length > 0) body["env"] = input.env;
+		const headers = {
+			"Content-Type": "application/json",
+			Accept: "text/event-stream"
+		};
+		if (input.session_id) headers["Session-Id"] = input.session_id;
+		const { bytes } = await this.#http.bytes("POST", `/v1/sandbox/${encodeURIComponent(input.sandbox_id)}/exec`, {
+			body,
+			headers,
+			label: "Cloudflare Sandbox exec"
+		});
+		const parsed = parseExecSse(new TextDecoder().decode(bytes), {
+			...stream.onStdout && { onStdout: stream.onStdout },
+			...stream.onStderr && { onStderr: stream.onStderr }
+		});
+		if (parsed.error && parsed.exit_code === void 0) throw new ToolError(parsed.error, {
+			code: "upstream",
+			details: {
+				...parsed.error_code && { error_code: parsed.error_code },
+				sandbox_id: input.sandbox_id
+			}
+		});
+		const exit_code = parsed.exit_code ?? (parsed.error ? 1 : 0);
+		const out = {
+			sandbox_id: input.sandbox_id,
+			stdout: parsed.stdout,
+			stderr: parsed.stderr,
+			exit_code,
+			success: exit_code === 0
+		};
+		if (parsed.error) out.error = parsed.error;
+		if (parsed.error_code) out.error_code = parsed.error_code;
+		return out;
+	}
+	/** Execute source via python3/node/sh on the bridge (no native runCode route). */
+	async executeCode(input) {
+		const language = input.language ?? "python";
+		return this.exec({
+			sandbox_id: input.sandbox_id,
+			argv: executeCodeArgv(language, input.code),
+			...input.timeout_ms !== void 0 && { timeout_ms: input.timeout_ms },
+			...input.session_id && { session_id: input.session_id }
+		});
+	}
+	async writeFile(input) {
+		const bytes = resolveWriteFileBytes(input);
+		await this.#putFileBytes(input.sandbox_id, input.path, bytes, input.session_id);
+		return {
+			sandbox_id: input.sandbox_id,
+			path: input.path,
+			ok: true,
+			byte_length: bytes.byteLength
+		};
+	}
+	async readFile(input) {
+		const bytes = await this.#getFileBytes(input.sandbox_id, input.path, input.session_id);
+		const encoding = input.encoding ?? "utf8";
+		const out = {
+			sandbox_id: input.sandbox_id,
+			path: input.path,
+			byte_length: bytes.byteLength
+		};
+		if (encoding === "base64") out.body_base64 = bytesToBase64(bytes);
+		else out.text = bytesToUtf8(bytes);
+		return out;
+	}
+	async writeFiles(input) {
+		const paths = [];
+		for (const file of input.files) {
+			await this.writeFile({
+				sandbox_id: input.sandbox_id,
+				path: file.path,
+				...file.text !== void 0 && { text: file.text },
+				...file.body_base64 !== void 0 && { body_base64: file.body_base64 },
+				...input.session_id && { session_id: input.session_id }
+			});
+			paths.push(file.path);
+		}
+		return {
+			sandbox_id: input.sandbox_id,
+			paths,
+			ok: true
+		};
+	}
+	async readFiles(input) {
+		const files = [];
+		for (const path of input.paths) {
+			const row = await this.readFile({
+				sandbox_id: input.sandbox_id,
+				path,
+				...input.encoding && { encoding: input.encoding },
+				...input.session_id && { session_id: input.session_id }
+			});
+			files.push({
+				path: row.path,
+				...row.text !== void 0 && { text: row.text },
+				...row.body_base64 !== void 0 && { body_base64: row.body_base64 },
+				...row.byte_length !== void 0 && { byte_length: row.byte_length }
+			});
+		}
+		return {
+			sandbox_id: input.sandbox_id,
+			files
+		};
+	}
+	/** List files via find in the workspace (bridge has no list route). */
+	async listFiles(input) {
+		const dir = input.directory_path?.trim() || "/workspace";
+		const abs = dir.startsWith("/") ? dir : workspaceAbsolutePath(dir);
+		const out = await this.exec({
+			sandbox_id: input.sandbox_id,
+			argv: [
+				"sh",
+				"-lc",
+				`find ${shellQuote(abs)} -maxdepth 4 -type f 2>/dev/null | head -n 500`
+			],
+			...input.session_id && { session_id: input.session_id }
+		});
+		const paths = out.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+		return {
+			sandbox_id: input.sandbox_id,
+			paths,
+			raw: {
+				stdout: out.stdout,
+				stderr: out.stderr,
+				exit_code: out.exit_code
+			}
+		};
+	}
+	/** Remove files via rm (bridge has no delete-file route). */
+	async removeFiles(input) {
+		for (const path of input.paths) {
+			const abs = path.startsWith("/") ? path : workspaceAbsolutePath(path);
+			await this.exec({
+				sandbox_id: input.sandbox_id,
+				argv: [
+					"rm",
+					"-f",
+					"--",
+					abs
+				],
+				...input.session_id && { session_id: input.session_id }
+			});
+		}
+		return {
+			sandbox_id: input.sandbox_id,
+			paths: input.paths,
+			ok: true
+		};
+	}
+	/**
+	* Copy an object-store ArtifactRef into the sandbox workspace.
+	* Requires auth.storage.
+	*/
+	async importArtifact(input) {
+		const storage = this.#requireStorage("importArtifact");
+		if (input.source.store !== "object") throw new ToolError("Sandbox importArtifact only supports store=object ArtifactRefs", { code: "bad_input" });
+		const bytes = await storage.getBytes(input.source.key, { maxBytes: MAX_FILE_BYTES });
+		await this.#putFileBytes(input.sandbox_id, input.path, bytes, input.session_id);
+		return {
+			sandbox_id: input.sandbox_id,
+			path: input.path,
+			ok: true,
+			byte_length: bytes.byteLength
+		};
+	}
+	/**
+	* Copy a sandbox workspace file to object storage and return an ArtifactRef.
+	* Requires auth.storage.
+	*/
+	async exportArtifact(input) {
+		const storage = this.#requireStorage("exportArtifact");
+		const bytes = await this.#getFileBytes(input.sandbox_id, input.path, input.session_id);
+		await storage.putBytes(input.destination_key, bytes);
+		return {
+			sandbox_id: input.sandbox_id,
+			path: input.path,
+			artifact: {
+				store: "object",
+				key: input.destination_key,
+				byte_length: bytes.byteLength
+			}
+		};
+	}
+	async createSession(input) {
+		const { data } = await this.#http.post(`/v1/sandbox/${encodeURIComponent(input.sandbox_id)}/session`, void 0, { label: "Cloudflare Sandbox createSession" });
+		if (!isPlainObject(data) || !isString(data["id"])) throw new ToolError("Unexpected create session response", { code: "upstream" });
+		return {
+			sandbox_id: input.sandbox_id,
+			session_id: data["id"]
+		};
+	}
+	async deleteSession(input) {
+		await this.#http.delete(`/v1/sandbox/${encodeURIComponent(input.sandbox_id)}/session/${encodeURIComponent(input.session_id)}`, { label: "Cloudflare Sandbox deleteSession" });
+		return {
+			sandbox_id: input.sandbox_id,
+			session_id: input.session_id,
+			deleted: true
+		};
+	}
+	/**
+	* Mount an S3-compatible bucket (or Worker R2 binding) at an absolute path in the sandbox.
+	* Bridge: `POST /v1/sandbox/:id/mount`.
+	* For Mastra / host workspace S3 FS: pass `endpoint` + credentials (or rely on auth.storage).
+	* @see https://developers.cloudflare.com/sandbox/bridge/http-api/#bucket-mounts
+	*/
+	async mount(input) {
+		const parsed = mountBucketInputSchema.safeParse(input);
+		if (!parsed.success) throw new ToolError("Invalid sandbox mount input", {
+			code: "bad_input",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		const data = parsed.data;
+		if (data.local_bucket && data.endpoint) throw new ToolError("local_bucket and endpoint are mutually exclusive on mount", { code: "bad_input" });
+		if (data.prefix !== void 0 && !data.prefix.startsWith("/")) throw new ToolError("mount prefix must start with /", { code: "bad_input" });
+		const endpoint = data.local_bucket ? void 0 : data.endpoint;
+		const accessKeyId = data.access_key_id ?? (endpoint !== void 0 ? this.#storageAuth?.access_key_id : void 0);
+		const secretAccessKey = data.secret_access_key ?? (endpoint !== void 0 ? this.#storageAuth?.secret_access_key : void 0);
+		const options = {};
+		if (endpoint) options["endpoint"] = endpoint;
+		if (data.provider) options["provider"] = data.provider;
+		if (data.read_only !== void 0) options["readOnly"] = data.read_only;
+		if (data.prefix) options["prefix"] = data.prefix;
+		if (data.credential_proxy !== void 0) options["credentialProxy"] = data.credential_proxy;
+		if (data.local_bucket) options["localBucket"] = true;
+		if (data.s3fs_options && data.s3fs_options.length > 0) options["s3fsOptions"] = data.s3fs_options;
+		if (endpoint && accessKeyId && secretAccessKey) options["credentials"] = {
+			accessKeyId,
+			secretAccessKey
+		};
+		const body = {
+			bucket: data.bucket,
+			mountPath: data.mount_path
+		};
+		if (Object.keys(options).length > 0) body["options"] = options;
+		await this.#http.post(`/v1/sandbox/${encodeURIComponent(data.sandbox_id)}/mount`, body, { label: "Cloudflare Sandbox mount" });
+		return {
+			sandbox_id: data.sandbox_id,
+			bucket: data.bucket,
+			mount_path: data.mount_path,
+			ok: true
+		};
+	}
+	/**
+	* Unmount a previously mounted bucket path.
+	* Bridge: `POST /v1/sandbox/:id/unmount` with `{ mountPath }`.
+	* Mounts are also cleared when the sandbox is destroyed.
+	*/
+	async unmount(input) {
+		const parsed = unmountBucketInputSchema.safeParse(input);
+		if (!parsed.success) throw new ToolError("Invalid sandbox unmount input", {
+			code: "bad_input",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		const data = parsed.data;
+		await this.#http.post(`/v1/sandbox/${encodeURIComponent(data.sandbox_id)}/unmount`, { mountPath: data.mount_path }, { label: "Cloudflare Sandbox unmount" });
+		return {
+			sandbox_id: data.sandbox_id,
+			mount_path: data.mount_path,
+			ok: true
+		};
+	}
+	#requireStorage(op) {
+		if (!this.#storage) throw new ToolError(`${op} requires storage credentials on sandbox auth`, { code: "bad_auth" });
+		return this.#storage;
+	}
+	async #putFileBytes(sandboxId, path, bytes, sessionId) {
+		const key = workspaceFileKey(path);
+		const headers = { "Content-Type": "application/octet-stream" };
+		if (sessionId) headers["Session-Id"] = sessionId;
+		const { data } = await this.#http.put(`/v1/sandbox/${encodeURIComponent(sandboxId)}/file/${key.split("/").map(encodeURIComponent).join("/")}`, toArrayBuffer(bytes), {
+			headers,
+			label: "Cloudflare Sandbox writeFile"
+		});
+		if (isPlainObject(data) && data["ok"] === false) throw new ToolError("Sandbox writeFile failed", { code: "upstream" });
+	}
+	async #getFileBytes(sandboxId, path, sessionId) {
+		const key = workspaceFileKey(path);
+		const headers = {};
+		if (sessionId) headers["Session-Id"] = sessionId;
+		const { bytes } = await this.#http.bytes("GET", `/v1/sandbox/${encodeURIComponent(sandboxId)}/file/${key.split("/").map(encodeURIComponent).join("/")}`, {
+			headers,
+			label: "Cloudflare Sandbox readFile",
+			maxBytes: MAX_FILE_BYTES
+		});
+		return bytes;
+	}
+};
+//#endregion
+//#region src/vendors/cloudflare-sandbox/module.ts
+const id = "cloudflare-sandbox";
+const emptyInputSchema = z.object({});
+const cloudflareSandboxHealthTool = defineTool({
+	id: `${id}-health`,
+	name: "cloudflareSandboxHealth",
+	description: "Check whether the Cloudflare Sandbox bridge is reachable. Use only for explicit availability diagnostics; ordinary sandbox work should begin with cloudflare-sandbox-create.",
+	inputSchema: emptyInputSchema,
+	outputSchema: healthOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	network: true,
+	execute: async (_input, ctx) => CloudflareSandboxClient.fromContext(ctx).health()
+});
+const cloudflareSandboxCreateTool = defineTool({
+	id: `${id}-create`,
+	name: "cloudflareSandboxCreate",
+	description: "Create an isolated Cloudflare sandbox and return sandbox_id. Use only when arbitrary code, commands, or temporary files are required and no purpose-built tool covers the task. Do not create a sandbox to build or edit supported deliverables.",
+	inputSchema: emptyInputSchema,
+	outputSchema: createSandboxOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (_input, ctx) => CloudflareSandboxClient.fromContext(ctx).create()
+});
+const cloudflareSandboxDestroyTool = defineTool({
+	id: `${id}-destroy`,
+	name: "cloudflareSandboxDestroy",
+	description: "Destroy a Cloudflare sandbox by sandbox_id and release its temporary files and resources. Call after the sandbox workflow is complete and any required output file has been exported.",
+	inputSchema: sandboxIdInputSchema,
+	outputSchema: destroySandboxOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).destroy(input)
+});
+const cloudflareSandboxRunningTool = defineTool({
+	id: `${id}-running`,
+	name: "cloudflareSandboxRunning",
+	description: "Check whether a Cloudflare sandbox is currently running. Use before continuing work on an existing sandbox_id; this does not execute code or inspect files.",
+	inputSchema: sandboxIdInputSchema,
+	outputSchema: runningOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).running(input)
+});
+const cloudflareSandboxExecTool = defineTool({
+	id: `${id}-exec`,
+	name: "cloudflareSandboxExec",
+	description: "One-shot argv exec in a Cloudflare sandbox (stdout/stderr/exit_code). Prefer a host workspace agent for multi-step shell; use tools for workflow one-shots. Optional env when the bridge supports it.",
+	inputSchema: execInputSchema,
+	outputSchema: execOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	tags: [
+		"exec",
+		"one-shot",
+		"compute"
+	],
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).exec(input)
+});
+const cloudflareSandboxExecuteCodeTool = defineTool({
+	id: `${id}-execute-code`,
+	name: "cloudflareSandboxExecuteCode",
+	description: "Execute Python, JavaScript, or shell source in a Cloudflare sandbox. Use as a fallback for computation or automation with no dedicated tool. Do not generate or edit supported documents, spreadsheets, presentations, PDFs, or images here when a purpose-built tool is available.",
+	inputSchema: executeCodeInputSchema,
+	outputSchema: execOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).executeCode(input)
+});
+const cloudflareSandboxWriteFileTool = defineTool({
+	id: `${id}-write-file`,
+	name: "cloudflareSandboxWriteFile",
+	description: "Write one temporary file under the Cloudflare sandbox workspace from UTF-8 text or base64 bytes, up to 32 MiB decoded. Use for sandbox intermediates. This is not durable delivery; export a genuinely sandbox-produced final file with cloudflare-sandbox-export-artifact.",
+	inputSchema: writeFileInputSchema,
+	outputSchema: writeFileOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).writeFile(input)
+});
+const cloudflareSandboxReadFileTool = defineTool({
+	id: `${id}-read-file`,
+	name: "cloudflareSandboxReadFile",
+	description: "Read one temporary file from the Cloudflare sandbox workspace as UTF-8 or base64. Use for sandbox intermediates; use format-aware readers for supported ArtifactRefs.",
+	inputSchema: readFileInputSchema,
+	outputSchema: readFileOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).readFile(input)
+});
+const cloudflareSandboxWriteFilesTool = defineTool({
+	id: `${id}-write-files`,
+	name: "cloudflareSandboxWriteFiles",
+	description: "Write multiple temporary files under the Cloudflare sandbox workspace from text or base64. Use for sandbox intermediates, not final document generation. Export only a final file that the sandbox genuinely had to produce.",
+	inputSchema: writeFilesInputSchema,
+	outputSchema: writeFilesOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).writeFiles(input)
+});
+const cloudflareSandboxReadFilesTool = defineTool({
+	id: `${id}-read-files`,
+	name: "cloudflareSandboxReadFiles",
+	description: "Read multiple temporary files from the Cloudflare sandbox workspace as UTF-8 or base64. Use only within an active sandbox workflow; use format-aware readers for supported ArtifactRefs.",
+	inputSchema: readFilesInputSchema,
+	outputSchema: readFilesOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).readFiles(input)
+});
+const cloudflareSandboxListFilesTool = defineTool({
+	id: `${id}-list-files`,
+	name: "cloudflareSandboxListFiles",
+	description: "List temporary files under a Cloudflare sandbox directory, defaulting to /workspace. Use to locate sandbox intermediates, not durable workspace files or ArtifactRefs.",
+	inputSchema: listFilesInputSchema,
+	outputSchema: listFilesOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).listFiles(input)
+});
+const cloudflareSandboxRemoveFilesTool = defineTool({
+	id: `${id}-remove-files`,
+	name: "cloudflareSandboxRemoveFiles",
+	description: "Remove temporary files from the Cloudflare sandbox workspace by path. Use only for sandbox cleanup; this does not delete durable workspace files or ArtifactRefs.",
+	inputSchema: removeFilesInputSchema,
+	outputSchema: removeFilesOutputSchema,
+	sideEffect: "delete",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).removeFiles(input)
+});
+const cloudflareSandboxImportArtifactTool = defineTool({
+	id: `${id}-import-artifact`,
+	name: "cloudflareSandboxImportArtifact",
+	description: "Copy an existing object-store ArtifactRef into a Cloudflare sandbox workspace. Use only when arbitrary sandbox computation must consume that file. Do not import a supported document merely to read or edit it with general code.",
+	inputSchema: importArtifactInputSchema,
+	outputSchema: importArtifactOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).importArtifact(input)
+});
+const cloudflareSandboxExportArtifactTool = defineTool({
+	id: `${id}-export-artifact`,
+	name: "cloudflareSandboxExportArtifact",
+	description: "Persist a final file that was genuinely created inside the Cloudflare sandbox and return its ArtifactRef for delivery. Use only after sandbox work. Do not call for files returned by document, presentation, PDF, image, render, or conversion tools; those ArtifactRefs are already final.",
+	inputSchema: exportArtifactInputSchema,
+	outputSchema: exportArtifactOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).exportArtifact(input)
+});
+const cloudflareSandboxCreateSessionTool = defineTool({
+	id: `${id}-create-session`,
+	name: "cloudflareSandboxCreateSession",
+	description: "Create an isolated execution session inside an existing Cloudflare sandbox and return session_id. Use only when separate working directories or runtime state are needed; pass the id to later command and file calls.",
+	inputSchema: sandboxIdInputSchema,
+	outputSchema: createBridgeSessionOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).createSession(input)
+});
+const cloudflareSandboxDeleteSessionTool = defineTool({
+	id: `${id}-delete-session`,
+	name: "cloudflareSandboxDeleteSession",
+	description: "Delete an isolated execution session inside a Cloudflare sandbox. Use after session-specific work is complete; this does not destroy the parent sandbox.",
+	inputSchema: deleteBridgeSessionInputSchema,
+	outputSchema: deleteBridgeSessionOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	network: true,
+	execute: async (input, ctx) => CloudflareSandboxClient.fromContext(ctx).deleteSession(input)
+});
+const cloudflareSandboxModule = defineModule({
+	id,
+	title: "Cloudflare Sandbox",
+	description: "Cloudflare sandbox bridge: one-shot exec/files/sessions for workflows. Prefer a host workspace agent for multi-step shell. Client export remains first-class for Workspace hybrids. Prefer purpose-built document tools over sandbox for office formats.",
+	runtime: "both",
+	auth: {
+		type: "custom",
+		schema: cloudflareSandboxAuthSchema
+	},
+	categories: [
+		"compute",
+		"sandbox",
+		"cloudflare"
+	],
+	classification: "standard",
+	tags: [
+		"exec",
+		"workspace",
+		"bridge"
+	],
+	tools: [
+		cloudflareSandboxHealthTool,
+		cloudflareSandboxCreateTool,
+		cloudflareSandboxDestroyTool,
+		cloudflareSandboxRunningTool,
+		cloudflareSandboxExecTool,
+		cloudflareSandboxExecuteCodeTool,
+		cloudflareSandboxWriteFileTool,
+		cloudflareSandboxReadFileTool,
+		cloudflareSandboxWriteFilesTool,
+		cloudflareSandboxReadFilesTool,
+		cloudflareSandboxListFilesTool,
+		cloudflareSandboxRemoveFilesTool,
+		cloudflareSandboxImportArtifactTool,
+		cloudflareSandboxExportArtifactTool,
+		cloudflareSandboxCreateSessionTool,
+		cloudflareSandboxDeleteSessionTool
+	]
+});
+//#endregion
+export { readFileInputSchema as $, MAX_FILE_PATH as A, destroySandboxOutputSchema as B, workspaceAbsolutePath as C, MAX_ARG_CHARS as D, MAX_ARGV as E, cloudflareSandboxAuthSchema as F, exportArtifactOutputSchema as G, execOutputSchema as H, createBridgeSessionOutputSchema as I, importArtifactOutputSchema as J, healthOutputSchema as K, createSandboxOutputSchema as L, MAX_LIST_FILES as M, MAX_READ_PATHS as N, MAX_EXEC_TIMEOUT_MS as O, MAX_WRITE_FILES as P, mountBucketOutputSchema as Q, deleteBridgeSessionInputSchema as R, shellQuote as S, DEFAULT_EXEC_TIMEOUT_MS as T, executeCodeInputSchema as U, execInputSchema as V, exportArtifactInputSchema as W, listFilesOutputSchema as X, listFilesInputSchema as Y, mountBucketInputSchema as Z, cloudflareSandboxWriteFilesTool as _, cloudflareSandboxExecTool as a, runningOutputSchema as at, parseExecSse as b, cloudflareSandboxHealthTool as c, unmountBucketInputSchema as ct, cloudflareSandboxModule as d, writeFileOutputSchema as dt, readFileOutputSchema as et, cloudflareSandboxReadFileTool as f, writeFilesInputSchema as ft, cloudflareSandboxWriteFileTool as g, cloudflareSandboxRunningTool as h, cloudflareSandboxDestroyTool as i, removeFilesOutputSchema as it, MAX_FILE_TEXT as j, MAX_FILE_BYTES as k, cloudflareSandboxImportArtifactTool as l, unmountBucketOutputSchema as lt, cloudflareSandboxRemoveFilesTool as m, cloudflareSandboxCreateTool as n, readFilesOutputSchema as nt, cloudflareSandboxExecuteCodeTool as o, sandboxIdInputSchema as ot, cloudflareSandboxReadFilesTool as p, writeFilesOutputSchema as pt, importArtifactInputSchema as q, cloudflareSandboxDeleteSessionTool as r, removeFilesInputSchema as rt, cloudflareSandboxExportArtifactTool as s, sandboxObjectArtifactRefSchema as st, cloudflareSandboxCreateSessionTool as t, readFilesInputSchema as tt, cloudflareSandboxListFilesTool as u, writeFileInputSchema as ut, CloudflareSandboxClient as v, workspaceFileKey as w, resolveWriteFileBytes as x, executeCodeArgv as y, deleteBridgeSessionOutputSchema as z };
+
+//# sourceMappingURL=cloudflare-sandbox-Dp_uNaqW.js.map