@langchain/deno 0.0.1

package/dist/index.cjs

@@ -0,0 +1,727 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _deno_sandbox = require("@deno/sandbox");
+let deepagents = require("deepagents");
+
+//#region src/auth.ts
+/**
+* Get the authentication token for Deno Sandbox API.
+*
+* Authentication is resolved in the following priority order:
+*
+* 1. **Explicit token**: If `options.token` is provided, it is used directly.
+* 2. **DENO_DEPLOY_TOKEN**: Environment variable for Deno Deploy access token.
+*
+* If no token is found, an error is thrown with setup instructions.
+*
+* ## Environment Variable Setup
+*
+* ```bash
+* # Go to https://app.deno.com -> Settings -> Organization Tokens
+* # Create a new token and set it as environment variable
+* export DENO_DEPLOY_TOKEN=your_token_here
+* ```
+*
+* @param options - Optional authentication configuration from DenoSandboxOptions
+* @returns The authentication token string
+* @throws {Error} If no authentication token is available
+*
+* @example
+* ```typescript
+* // With explicit token
+* const token = getAuthToken({ token: "my-token" });
+*
+* // Using environment variables (auto-detected)
+* const token = getAuthToken();
+*
+* // From DenoSandboxOptions
+* const options: DenoSandboxOptions = {
+*   auth: { token: "my-token" }
+* };
+* const token = getAuthToken(options.auth);
+* ```
+*/
+function getAuthToken(options) {
+	if (options?.token) return options.token;
+	const deployToken = process.env.DENO_DEPLOY_TOKEN;
+	if (deployToken) return deployToken;
+	throw new Error("Deno Deploy authentication required. Provide a token using one of these methods:\n\n1. Set DENO_DEPLOY_TOKEN environment variable:\n   Go to https://app.deno.com -> Settings -> Organization Tokens\n   Create a new token and run: export DENO_DEPLOY_TOKEN=your_token_here\n\n2. Pass token directly in options:\n   new DenoSandbox({ auth: { token: '...' } })");
+}
+/**
+* Get authentication credentials for Deno Sandbox API.
+*
+* This function returns the credentials needed for the Deno SDK.
+*
+* @param options - Optional authentication configuration from DenoSandboxOptions
+* @returns Complete authentication credentials
+* @throws {Error} If no authentication token is available
+*/
+function getAuthCredentials(options) {
+	return { token: getAuthToken(options) };
+}
+
+//#endregion
+//#region src/types.ts
+const DENO_SANDBOX_ERROR_SYMBOL = Symbol.for("deno.sandbox.error");
+/**
+* Custom error class for Deno Sandbox operations.
+*
+* Provides structured error information including:
+* - Human-readable message
+* - Error code for programmatic handling
+* - Original cause for debugging
+*
+* @example
+* ```typescript
+* try {
+*   await sandbox.execute("some command");
+* } catch (error) {
+*   if (error instanceof DenoSandboxError) {
+*     switch (error.code) {
+*       case "NOT_INITIALIZED":
+*         await sandbox.initialize();
+*         break;
+*       case "COMMAND_TIMEOUT":
+*         console.error("Command took too long");
+*         break;
+*       default:
+*         throw error;
+*     }
+*   }
+* }
+* ```
+*/
+var DenoSandboxError = class DenoSandboxError extends Error {
+	[DENO_SANDBOX_ERROR_SYMBOL];
+	/** Error name for instanceof checks and logging */
+	name = "DenoSandboxError";
+	/**
+	* Creates a new DenoSandboxError.
+	*
+	* @param message - Human-readable error description
+	* @param code - Structured error code for programmatic handling
+	* @param cause - Original error that caused this error (for debugging)
+	*/
+	constructor(message, code, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		Object.setPrototypeOf(this, DenoSandboxError.prototype);
+	}
+	/**
+	* Checks if the error is an instance of DenoSandboxError.
+	*
+	* @param error - The error to check
+	* @returns True if the error is an instance of DenoSandboxError, false otherwise
+	*/
+	static isInstance(error) {
+		return typeof error === "object" && error !== null && error[DENO_SANDBOX_ERROR_SYMBOL] === true;
+	}
+};
+
+//#endregion
+//#region src/sandbox.ts
+/**
+* Deno Sandbox implementation of the SandboxBackendProtocol.
+*
+* This module provides a Deno Sandbox backend for deepagents, enabling agents
+* to execute commands, read/write files, and manage isolated Linux microVM
+* environments using Deno Deploy's Sandbox infrastructure.
+*
+* @packageDocumentation
+*/
+/**
+* Deno Sandbox backend for deepagents.
+*
+* Extends `BaseSandbox` to provide command execution, file operations, and
+* sandbox lifecycle management using Deno Deploy's Sandbox SDK.
+*
+* ## Basic Usage
+*
+* ```typescript
+* import { DenoSandbox } from "@langchain/deno";
+*
+* // Create and initialize a sandbox
+* const sandbox = await DenoSandbox.create({
+*   memoryMb: 1024,
+*   lifetime: "5m",
+* });
+*
+* try {
+*   // Execute commands
+*   const result = await sandbox.execute("deno --version");
+*   console.log(result.output);
+* } finally {
+*   // Always cleanup
+*   await sandbox.close();
+* }
+* ```
+*
+* ## Using with DeepAgent
+*
+* ```typescript
+* import { createDeepAgent } from "deepagents";
+* import { DenoSandbox } from "@langchain/deno";
+*
+* const sandbox = await DenoSandbox.create();
+*
+* const agent = createDeepAgent({
+*   model: new ChatAnthropic({ model: "claude-sonnet-4-20250514" }),
+*   systemPrompt: "You are a coding assistant with sandbox access.",
+*   backend: sandbox,
+* });
+* ```
+*/
+var DenoSandbox = class DenoSandbox extends deepagents.BaseSandbox {
+	/** Private reference to the underlying Deno Sandbox instance */
+	#sandbox = null;
+	/** Configuration options for this sandbox */
+	#options;
+	/** Unique identifier for this sandbox instance */
+	#id;
+	/**
+	* Get the unique identifier for this sandbox.
+	*
+	* Before initialization, returns a temporary ID.
+	* After initialization, returns the actual Deno sandbox ID.
+	*/
+	get id() {
+		return this.#id;
+	}
+	/**
+	* Get the underlying Deno Sandbox instance.
+	*
+	* @throws {DenoSandboxError} If the sandbox is not initialized
+	*
+	* @example
+	* ```typescript
+	* const sandbox = await DenoSandbox.create();
+	* const denoSdk = sandbox.sandbox; // Access the raw SDK
+	* ```
+	*/
+	get sandbox() {
+		if (!this.#sandbox) throw new DenoSandboxError("Sandbox not initialized. Call initialize() or use DenoSandbox.create()", "NOT_INITIALIZED");
+		return this.#sandbox;
+	}
+	/**
+	* Check if the sandbox is initialized and running.
+	*/
+	get isRunning() {
+		return this.#sandbox !== null;
+	}
+	/**
+	* Create a new DenoSandbox instance.
+	*
+	* Note: This only creates the instance. Call `initialize()` to actually
+	* create the Deno Sandbox, or use the static `DenoSandbox.create()` method.
+	*
+	* @param options - Configuration options for the sandbox
+	*
+	* @example
+	* ```typescript
+	* // Two-step initialization
+	* const sandbox = new DenoSandbox({ memoryMb: 1024 });
+	* await sandbox.initialize();
+	*
+	* // Or use the factory method
+	* const sandbox = await DenoSandbox.create({ memoryMb: 1024 });
+	* ```
+	*/
+	constructor(options = {}) {
+		super();
+		this.#options = {
+			memoryMb: 768,
+			lifetime: "session",
+			...options
+		};
+		this.#id = `deno-sandbox-${Date.now()}`;
+	}
+	/**
+	* Initialize the sandbox by creating a new Deno Sandbox instance.
+	*
+	* This method authenticates with Deno Deploy and provisions a new microVM
+	* sandbox. After initialization, the `id` property will reflect the
+	* actual Deno sandbox ID.
+	*
+	* @throws {DenoSandboxError} If already initialized (`ALREADY_INITIALIZED`)
+	* @throws {DenoSandboxError} If authentication fails (`AUTHENTICATION_FAILED`)
+	* @throws {DenoSandboxError} If sandbox creation fails (`SANDBOX_CREATION_FAILED`)
+	*
+	* @example
+	* ```typescript
+	* const sandbox = new DenoSandbox();
+	* await sandbox.initialize();
+	* console.log(`Sandbox ID: ${sandbox.id}`);
+	* ```
+	*/
+	async initialize() {
+		if (this.#sandbox) throw new DenoSandboxError("Sandbox is already initialized. Each DenoSandbox instance can only be initialized once.", "ALREADY_INITIALIZED");
+		let credentials;
+		try {
+			credentials = getAuthCredentials(this.#options.auth);
+		} catch (error) {
+			throw new DenoSandboxError("Failed to authenticate with Deno Deploy. Check your token configuration.", "AUTHENTICATION_FAILED", error instanceof Error ? error : void 0);
+		}
+		try {
+			process.env.DENO_DEPLOY_TOKEN = credentials.token;
+			const createOptions = {};
+			if (this.#options.memoryMb !== void 0) createOptions.memoryMb = this.#options.memoryMb;
+			if (this.#options.lifetime !== void 0) createOptions.lifetime = this.#options.lifetime;
+			if (this.#options.region !== void 0) createOptions.region = this.#options.region;
+			this.#sandbox = await _deno_sandbox.Sandbox.create(createOptions);
+			this.#id = this.#sandbox.id;
+			if (this.#options.initialFiles) await this.#uploadInitialFiles(this.#options.initialFiles);
+		} catch (error) {
+			throw new DenoSandboxError(`Failed to create Deno Sandbox: ${error instanceof Error ? error.message : String(error)}`, "SANDBOX_CREATION_FAILED", error instanceof Error ? error : void 0);
+		}
+	}
+	/**
+	* Upload initial files to the sandbox.
+	*
+	* @param files - A map of file paths to their string contents
+	*/
+	async #uploadInitialFiles(files) {
+		const encoder = new TextEncoder();
+		const fileEntries = Object.entries(files).map(([path, content]) => [path, encoder.encode(content)]);
+		const errors = (await this.uploadFiles(fileEntries)).filter((r) => r.error !== null);
+		if (errors.length > 0) throw new DenoSandboxError(`Failed to upload initial files: ${errors.map((e) => `${e.path}: ${e.error}`).join(", ")}`, "FILE_OPERATION_FAILED");
+	}
+	/**
+	* Execute a command in the sandbox.
+	*
+	* Commands are run using the sandbox's shell in the configured working directory.
+	*
+	* @param command - The shell command to execute
+	* @returns Execution result with output, exit code, and truncation flag
+	* @throws {DenoSandboxError} If the sandbox is not initialized
+	*
+	* @example
+	* ```typescript
+	* const result = await sandbox.execute("echo 'Hello World'");
+	* console.log(result.output); // "Hello World\n"
+	* console.log(result.exitCode); // 0
+	* ```
+	*/
+	async execute(command) {
+		const sandbox = this.sandbox;
+		try {
+			const { status, stdoutText, stderrText } = await (await sandbox.spawn("/bin/bash", {
+				args: ["-c", command],
+				stdout: "piped",
+				stderr: "piped"
+			})).output();
+			return {
+				output: (stdoutText ?? "") + (stderrText ?? ""),
+				exitCode: status.code ?? 0,
+				truncated: false
+			};
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("timeout")) throw new DenoSandboxError(`Command timed out: ${command}`, "COMMAND_TIMEOUT", error);
+			throw new DenoSandboxError(`Command execution failed: ${error instanceof Error ? error.message : String(error)}`, "COMMAND_FAILED", error instanceof Error ? error : void 0);
+		}
+	}
+	/**
+	* Upload files to the sandbox.
+	*
+	* Files are written to the sandbox filesystem. Parent directories are
+	* created automatically if they don't exist.
+	*
+	* @param files - Array of [path, content] tuples to upload
+	* @returns Upload result for each file, with success or error status
+	*
+	* @example
+	* ```typescript
+	* const encoder = new TextEncoder();
+	* const results = await sandbox.uploadFiles([
+	*   ["src/index.js", encoder.encode("console.log('Hello')")],
+	*   ["package.json", encoder.encode('{"name": "test"}')],
+	* ]);
+	* ```
+	*/
+	async uploadFiles(files) {
+		const sandbox = this.sandbox;
+		const results = [];
+		for (const [path, content] of files) try {
+			const parentDir = path.substring(0, path.lastIndexOf("/"));
+			if (parentDir) await (await sandbox.spawn("/bin/bash", {
+				args: ["-c", `mkdir -p "${parentDir}"`],
+				stdout: "piped",
+				stderr: "piped"
+			})).output();
+			const textContent = new TextDecoder().decode(content);
+			await sandbox.writeTextFile(path, textContent);
+			results.push({
+				path,
+				error: null
+			});
+		} catch (error) {
+			results.push({
+				path,
+				error: this.#mapError(error)
+			});
+		}
+		return results;
+	}
+	/**
+	* Download files from the sandbox.
+	*
+	* Each file is read individually, allowing partial success when some
+	* files exist and others don't.
+	*
+	* @param paths - Array of file paths to download
+	* @returns Download result for each file, with content or error
+	*
+	* @example
+	* ```typescript
+	* const results = await sandbox.downloadFiles(["src/index.js", "missing.txt"]);
+	* for (const result of results) {
+	*   if (result.content) {
+	*     console.log(new TextDecoder().decode(result.content));
+	*   } else {
+	*     console.error(`Error: ${result.error}`);
+	*   }
+	* }
+	* ```
+	*/
+	async downloadFiles(paths) {
+		const sandbox = this.sandbox;
+		const results = [];
+		for (const path of paths) try {
+			const { status, stdoutText } = await (await sandbox.spawn("/bin/bash", {
+				args: ["-c", `cat "${path}"`],
+				stdout: "piped",
+				stderr: "piped"
+			})).output();
+			if (!status.success) results.push({
+				path,
+				content: null,
+				error: "file_not_found"
+			});
+			else {
+				const content = new TextEncoder().encode(stdoutText ?? "");
+				results.push({
+					path,
+					content,
+					error: null
+				});
+			}
+		} catch (error) {
+			results.push({
+				path,
+				content: null,
+				error: this.#mapError(error)
+			});
+		}
+		return results;
+	}
+	/**
+	* Read a file's content with line numbers.
+	*
+	* Override of BaseSandbox.read() to use awk instead of Python,
+	* since Deno sandboxes don't have Python installed.
+	*
+	* @param filePath - Absolute path to the file
+	* @param offset - Line offset (0-indexed, default 0)
+	* @param limit - Maximum lines to return (default 500)
+	* @returns Formatted file content with line numbers, or error message
+	*/
+	async read(filePath, offset = 0, limit = 500) {
+		const safeOffset = Number.isFinite(offset) && offset > 0 ? Math.floor(offset) : 0;
+		const safeLimit = Number.isFinite(limit) && limit > 0 && limit < Number.MAX_SAFE_INTEGER ? Math.floor(limit) : 500;
+		const escapedPath = filePath.replace(/'/g, "'\\''");
+		const command = `
+if [ ! -f '${escapedPath}' ]; then
+  echo "Error: File not found"
+  exit 1
+fi
+if [ ! -s '${escapedPath}' ]; then
+  echo "System reminder: File exists but has empty contents"
+  exit 0
+fi
+awk -v offset=${safeOffset} -v limit=${safeLimit} '
+  NR > offset && NR <= offset + limit {
+    printf "%6d\\t%s\\n", NR, $0
+  }
+' '${escapedPath}'
+`;
+		const result = await this.execute(command);
+		if (result.exitCode !== 0) return `Error: File '${filePath}' not found`;
+		return result.output;
+	}
+	/**
+	* Create a new file with content.
+	*
+	* Override of BaseSandbox.write() to use shell commands instead of Python,
+	* since Deno sandboxes don't have Python installed.
+	*
+	* @param filePath - Absolute path for the new file
+	* @param content - File content to write
+	* @returns WriteResult with error populated on failure
+	*/
+	async write(filePath, content) {
+		const escapedPath = filePath.replace(/'/g, "'\\''");
+		if ((await this.execute(`test -f '${escapedPath}'`)).exitCode === 0) return { error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.` };
+		const encoder = new TextEncoder();
+		const uploadResult = await this.uploadFiles([[filePath, encoder.encode(content)]]);
+		if (uploadResult[0]?.error) return { error: `Failed to write file: ${uploadResult[0].error}` };
+		return {
+			path: filePath,
+			filesUpdate: null
+		};
+	}
+	/**
+	* Edit a file by replacing string occurrences.
+	*
+	* Override of BaseSandbox.edit() to use shell commands instead of Python,
+	* since Deno sandboxes don't have Python installed.
+	*
+	* Uses sed for in-place replacement with proper escaping.
+	*
+	* @param filePath - Absolute path to the file
+	* @param oldString - String to find and replace
+	* @param newString - Replacement string
+	* @param replaceAll - If true, replace all occurrences (default: false)
+	* @returns EditResult with error, path, and occurrences
+	*/
+	async edit(filePath, oldString, newString, replaceAll = false) {
+		const escapedPath = filePath.replace(/'/g, "'\\''");
+		if ((await this.execute(`test -f '${escapedPath}'`)).exitCode !== 0) return { error: `Error: File '${filePath}' not found` };
+		const escapedOldForGrep = oldString.replace(/'/g, "'\\''");
+		const countResult = await this.execute(`grep -oF '${escapedOldForGrep}' '${escapedPath}' | wc -l`);
+		const count = parseInt(countResult.output.trim(), 10) || 0;
+		if (count === 0) return { error: `String not found in file '${filePath}'` };
+		if (count > 1 && !replaceAll) return { error: `Multiple occurrences found in '${filePath}'. Use replaceAll=true to replace all.` };
+		const awkCommand = `
+OLD=$(echo '${Buffer.from(oldString, "utf-8").toString("base64")}' | base64 -d)
+NEW=$(echo '${Buffer.from(newString, "utf-8").toString("base64")}' | base64 -d)
+awk -v old="$OLD" -v new="$NEW" -v replace_all=${replaceAll ? 1 : 0} '
+{
+  if (replace_all) {
+    gsub(old, new)
+  } else {
+    sub(old, new)
+  }
+  print
+}
+' '${escapedPath}' > '${escapedPath}.tmp' && mv '${escapedPath}.tmp' '${escapedPath}'
+`;
+		if ((await this.execute(awkCommand)).exitCode !== 0) return { error: `Unknown error editing file '${filePath}'` };
+		return {
+			path: filePath,
+			filesUpdate: null,
+			occurrences: count
+		};
+	}
+	/**
+	* Close the sandbox and release all resources.
+	*
+	* After closing, the sandbox cannot be used again. Any unsaved data
+	* will be lost.
+	*
+	* @example
+	* ```typescript
+	* try {
+	*   await sandbox.execute("deno run build.ts");
+	* } finally {
+	*   await sandbox.close();
+	* }
+	* ```
+	*/
+	async close() {
+		if (this.#sandbox) try {
+			await this.#sandbox.close();
+		} finally {
+			this.#sandbox = null;
+		}
+	}
+	/**
+	* Forcefully terminate the sandbox.
+	*
+	* Use this when you need to immediately stop the sandbox, even if
+	* operations are in progress.
+	*
+	* @example
+	* ```typescript
+	* await sandbox.kill();
+	* ```
+	*/
+	async kill() {
+		if (this.#sandbox) try {
+			await this.#sandbox.kill();
+		} finally {
+			this.#sandbox = null;
+		}
+	}
+	/**
+	* Alias for close() to maintain compatibility with other sandbox implementations.
+	*/
+	async stop() {
+		await this.close();
+	}
+	/**
+	* Set the sandbox from an existing Deno Sandbox instance.
+	* Used internally by the static `connect()` method.
+	*/
+	#setFromExisting(existingSandbox, sandboxId) {
+		this.#sandbox = existingSandbox;
+		this.#id = sandboxId;
+	}
+	/**
+	* Map Deno SDK errors to standardized FileOperationError codes.
+	*
+	* @param error - The error from the Deno SDK
+	* @returns A standardized error code
+	*/
+	#mapError(error) {
+		if (error instanceof Error) {
+			const msg = error.message.toLowerCase();
+			if (msg.includes("not found") || msg.includes("enoent")) return "file_not_found";
+			if (msg.includes("permission") || msg.includes("eacces")) return "permission_denied";
+			if (msg.includes("directory") || msg.includes("eisdir")) return "is_directory";
+		}
+		return "invalid_path";
+	}
+	/**
+	* Create and initialize a new DenoSandbox in one step.
+	*
+	* This is the recommended way to create a sandbox. It combines
+	* construction and initialization into a single async operation.
+	*
+	* @param options - Configuration options for the sandbox
+	* @returns An initialized and ready-to-use sandbox
+	*
+	* @example
+	* ```typescript
+	* const sandbox = await DenoSandbox.create({
+	*   memoryMb: 1024,
+	*   lifetime: "10m",
+	*   region: "iad",
+	* });
+	* ```
+	*/
+	static async create(options) {
+		const sandbox = new DenoSandbox(options);
+		await sandbox.initialize();
+		return sandbox;
+	}
+	/**
+	* Reconnect to an existing sandbox by ID.
+	*
+	* This allows you to resume working with a sandbox that was created
+	* earlier with a duration-based lifetime.
+	*
+	* @param sandboxId - The ID of the sandbox to reconnect to
+	* @param options - Optional auth configuration (for token)
+	* @returns A connected sandbox instance
+	*
+	* @example
+	* ```typescript
+	* // Resume a sandbox from a stored ID
+	* const sandbox = await DenoSandbox.connect("sandbox-abc123");
+	* const result = await sandbox.execute("ls -la");
+	* ```
+	*/
+	static async connect(sandboxId, options) {
+		let credentials;
+		try {
+			credentials = getAuthCredentials(options?.auth);
+		} catch (error) {
+			throw new DenoSandboxError("Failed to authenticate with Deno Deploy. Check your token configuration.", "AUTHENTICATION_FAILED", error instanceof Error ? error : void 0);
+		}
+		try {
+			process.env.DENO_DEPLOY_TOKEN = credentials.token;
+			const existingSandbox = await _deno_sandbox.Sandbox.connect({ id: sandboxId });
+			const denoSandbox = new DenoSandbox();
+			denoSandbox.#setFromExisting(existingSandbox, sandboxId);
+			return denoSandbox;
+		} catch (error) {
+			throw new DenoSandboxError(`Sandbox not found: ${sandboxId}`, "SANDBOX_NOT_FOUND", error instanceof Error ? error : void 0);
+		}
+	}
+};
+/**
+* Create an async factory function that creates a new Deno Sandbox per invocation.
+*
+* Each call to the factory will create and initialize a new sandbox.
+* This is useful when you want fresh, isolated environments for each
+* agent invocation.
+*
+* **Important**: This returns an async factory. For use with middleware that
+* requires synchronous BackendFactory, use `createDenoSandboxFactoryFromSandbox()`
+* with a pre-created sandbox instead.
+*
+* @param options - Optional configuration for sandbox creation
+* @returns An async factory function that creates new sandboxes
+*
+* @example
+* ```typescript
+* import { DenoSandbox, createDenoSandboxFactory } from "@langchain/deno";
+*
+* // Create a factory for new sandboxes
+* const factory = createDenoSandboxFactory({ memoryMb: 1024 });
+*
+* // Each call creates a new sandbox
+* const sandbox1 = await factory();
+* const sandbox2 = await factory();
+*
+* try {
+*   // Use sandboxes...
+* } finally {
+*   await sandbox1.close();
+*   await sandbox2.close();
+* }
+* ```
+*/
+function createDenoSandboxFactory(options) {
+	return async () => {
+		return await DenoSandbox.create(options);
+	};
+}
+/**
+* Create a backend factory that reuses an existing Deno Sandbox.
+*
+* This allows multiple agent invocations to share the same sandbox,
+* avoiding the startup overhead of creating new sandboxes.
+*
+* Important: You are responsible for managing the sandbox lifecycle
+* (calling `close()` when done).
+*
+* @param sandbox - An existing DenoSandbox instance (must be initialized)
+* @returns A BackendFactory that returns the provided sandbox
+*
+* @example
+* ```typescript
+* import { createDeepAgent, createFilesystemMiddleware } from "deepagents";
+* import { DenoSandbox, createDenoSandboxFactoryFromSandbox } from "@langchain/deno";
+*
+* // Create and initialize a sandbox
+* const sandbox = await DenoSandbox.create({ memoryMb: 1024 });
+*
+* try {
+*   const agent = createDeepAgent({
+*     model: new ChatAnthropic({ model: "claude-sonnet-4-20250514" }),
+*     systemPrompt: "You are a coding assistant.",
+*     middlewares: [
+*       createFilesystemMiddleware({
+*         backend: createDenoSandboxFactoryFromSandbox(sandbox),
+*       }),
+*     ],
+*   });
+*
+*   await agent.invoke({ messages: [...] });
+* } finally {
+*   await sandbox.close();
+* }
+* ```
+*/
+function createDenoSandboxFactoryFromSandbox(sandbox) {
+	return () => sandbox;
+}
+
+//#endregion
+exports.DenoSandbox = DenoSandbox;
+exports.DenoSandboxError = DenoSandboxError;
+exports.createDenoSandboxFactory = createDenoSandboxFactory;
+exports.createDenoSandboxFactoryFromSandbox = createDenoSandboxFactoryFromSandbox;
+exports.getAuthCredentials = getAuthCredentials;
+exports.getAuthToken = getAuthToken;
+//# sourceMappingURL=index.cjs.map