deepagentsdk 0.11.1 → 0.12.0

package/dist/index.cjs

@@ -0,0 +1,1471 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_agent = require('./agent-Cuks-Idh.cjs');
+const require_file_saver = require('./file-saver-C6O2LAvg.cjs');
+const require_load = require('./load-79a2H4m0.cjs');
+let ai = require("ai");
+let micromatch = require("micromatch");
+micromatch = require_chunk.__toESM(micromatch);
+let path = require("path");
+path = require_chunk.__toESM(path);
+let fs_promises = require("fs/promises");
+fs_promises = require_chunk.__toESM(fs_promises);
+let fs = require("fs");
+fs = require_chunk.__toESM(fs);
+let child_process = require("child_process");
+let fast_glob = require("fast-glob");
+fast_glob = require_chunk.__toESM(fast_glob);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_chunk.__toESM(node_fs_promises);
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
+
+//#region src/types/structured-output.ts
+/**
+* Type guard for checking if a result has structured output
+*/
+function hasStructuredOutput(result) {
+	return result && typeof result === "object" && "output" in result;
+}
+/**
+* Type guard for checking if an event has structured output
+*/
+function eventHasStructuredOutput(event) {
+	return event && event.type === "done" && "output" in event;
+}
+/**
+* Extract structured output from agent result with type safety
+*/
+function getStructuredOutput(result) {
+	return hasStructuredOutput(result) ? result.output : void 0;
+}
+/**
+* Extract structured output from event with type safety
+*/
+function getEventOutput(event) {
+	return eventHasStructuredOutput(event) ? event.output : void 0;
+}
+
+//#endregion
+//#region src/backends/filesystem.ts
+/**
+* FilesystemBackend: Read and write files directly from the filesystem.
+*/
+const SUPPORTS_NOFOLLOW = fs.constants.O_NOFOLLOW !== void 0;
+/**
+* Backend that reads and writes files directly from the filesystem.
+*
+* Files are persisted to disk, making them available across agent invocations.
+* This backend provides real file I/O operations with security checks to prevent
+* directory traversal attacks.
+*
+* @example Basic usage
+* ```typescript
+* const backend = new FilesystemBackend({ rootDir: './workspace' });
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend,
+* });
+* ```
+*
+* @example With custom options
+* ```typescript
+* const backend = new FilesystemBackend({
+*   rootDir: './my-project',
+*   virtualMode: false,
+*   maxFileSizeMb: 50, // Allow larger files
+* });
+* ```
+*/
+var FilesystemBackend = class {
+	cwd;
+	virtualMode;
+	maxFileSizeBytes;
+	/**
+	* Create a new FilesystemBackend instance.
+	*
+	* @param options - Configuration options
+	* @param options.rootDir - Optional root directory for file operations (default: current working directory).
+	*                          All file paths are resolved relative to this directory.
+	* @param options.virtualMode - Optional flag for virtual mode (default: false).
+	*                              When true, files are stored in memory but paths are validated against filesystem.
+	* @param options.maxFileSizeMb - Optional maximum file size in MB (default: 10).
+	*                                Files larger than this will be rejected.
+	*/
+	constructor(options = {}) {
+		const { rootDir, virtualMode = false, maxFileSizeMb = require_agent.MAX_FILE_SIZE_MB } = options;
+		this.cwd = rootDir ? path.resolve(rootDir) : process.cwd();
+		this.virtualMode = virtualMode;
+		this.maxFileSizeBytes = maxFileSizeMb * 1024 * 1024;
+	}
+	/**
+	* Resolve a file path with security checks.
+	*/
+	resolvePath(key) {
+		if (this.virtualMode) {
+			const vpath = key.startsWith("/") ? key : "/" + key;
+			if (vpath.includes("..") || vpath.startsWith("~")) throw new Error("Path traversal not allowed");
+			const full = path.resolve(this.cwd, vpath.substring(1));
+			const relative = path.relative(this.cwd, full);
+			if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Path: ${full} outside root directory: ${this.cwd}`);
+			return full;
+		}
+		if (path.isAbsolute(key)) return key;
+		return path.resolve(this.cwd, key);
+	}
+	/**
+	* List files and directories in the specified directory (non-recursive).
+	*/
+	async lsInfo(dirPath) {
+		try {
+			const resolvedPath = this.resolvePath(dirPath);
+			if (!(await fs_promises.stat(resolvedPath)).isDirectory()) return [];
+			const entries = await fs_promises.readdir(resolvedPath, { withFileTypes: true });
+			const results = [];
+			const cwdStr = this.cwd.endsWith(path.sep) ? this.cwd : this.cwd + path.sep;
+			for (const entry of entries) {
+				const fullPath = path.join(resolvedPath, entry.name);
+				try {
+					const entryStat = await fs_promises.stat(fullPath);
+					const isFile = entryStat.isFile();
+					const isDir = entryStat.isDirectory();
+					if (!this.virtualMode) {
+						if (isFile) results.push({
+							path: fullPath,
+							is_dir: false,
+							size: entryStat.size,
+							modified_at: entryStat.mtime.toISOString()
+						});
+						else if (isDir) results.push({
+							path: fullPath + path.sep,
+							is_dir: true,
+							size: 0,
+							modified_at: entryStat.mtime.toISOString()
+						});
+					} else {
+						let relativePath;
+						if (fullPath.startsWith(cwdStr)) relativePath = fullPath.substring(cwdStr.length);
+						else if (fullPath.startsWith(this.cwd)) relativePath = fullPath.substring(this.cwd.length).replace(/^[/\\]/, "");
+						else relativePath = fullPath;
+						relativePath = relativePath.split(path.sep).join("/");
+						const virtPath = "/" + relativePath;
+						if (isFile) results.push({
+							path: virtPath,
+							is_dir: false,
+							size: entryStat.size,
+							modified_at: entryStat.mtime.toISOString()
+						});
+						else if (isDir) results.push({
+							path: virtPath + "/",
+							is_dir: true,
+							size: 0,
+							modified_at: entryStat.mtime.toISOString()
+						});
+					}
+				} catch {
+					continue;
+				}
+			}
+			results.sort((a, b) => a.path.localeCompare(b.path));
+			return results;
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Read file content with line numbers.
+	*/
+	async read(filePath, offset = 0, limit = require_agent.DEFAULT_READ_LIMIT) {
+		try {
+			const resolvedPath = this.resolvePath(filePath);
+			let content;
+			if (SUPPORTS_NOFOLLOW) {
+				if (!(await fs_promises.stat(resolvedPath)).isFile()) return require_agent.FILE_NOT_FOUND(filePath);
+				const fd = await fs_promises.open(resolvedPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+				try {
+					content = await fd.readFile({ encoding: "utf-8" });
+				} finally {
+					await fd.close();
+				}
+			} else {
+				const stat = await fs_promises.lstat(resolvedPath);
+				if (stat.isSymbolicLink()) return `Error: Symlinks are not allowed: ${filePath}`;
+				if (!stat.isFile()) return require_agent.FILE_NOT_FOUND(filePath);
+				content = await fs_promises.readFile(resolvedPath, "utf-8");
+			}
+			const emptyMsg = require_agent.checkEmptyContent(content);
+			if (emptyMsg) return emptyMsg;
+			const lines = content.split("\n");
+			const startIdx = offset;
+			const endIdx = Math.min(startIdx + limit, lines.length);
+			if (startIdx >= lines.length) return `Error: Line offset ${offset} exceeds file length (${lines.length} lines)`;
+			return require_agent.formatContentWithLineNumbers(lines.slice(startIdx, endIdx), startIdx + 1);
+		} catch (e) {
+			return `Error reading file '${filePath}': ${e.message}`;
+		}
+	}
+	/**
+	* Read file content as raw FileData.
+	*/
+	async readRaw(filePath) {
+		const resolvedPath = this.resolvePath(filePath);
+		let content;
+		let stat;
+		if (SUPPORTS_NOFOLLOW) {
+			stat = await fs_promises.stat(resolvedPath);
+			if (!stat.isFile()) throw new Error(`File '${filePath}' not found`);
+			const fd = await fs_promises.open(resolvedPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+			try {
+				content = await fd.readFile({ encoding: "utf-8" });
+			} finally {
+				await fd.close();
+			}
+		} else {
+			stat = await fs_promises.lstat(resolvedPath);
+			if (stat.isSymbolicLink()) throw new Error(`Symlinks are not allowed: ${filePath}`);
+			if (!stat.isFile()) throw new Error(`File '${filePath}' not found`);
+			content = await fs_promises.readFile(resolvedPath, "utf-8");
+		}
+		return {
+			content: content.split("\n"),
+			created_at: stat.ctime.toISOString(),
+			modified_at: stat.mtime.toISOString()
+		};
+	}
+	/**
+	* Create a new file with content.
+	*/
+	async write(filePath, content) {
+		try {
+			const resolvedPath = this.resolvePath(filePath);
+			try {
+				if ((await fs_promises.lstat(resolvedPath)).isSymbolicLink()) return {
+					success: false,
+					error: `Cannot write to ${filePath} because it is a symlink. Symlinks are not allowed.`
+				};
+				return {
+					success: false,
+					error: require_agent.FILE_ALREADY_EXISTS(filePath)
+				};
+			} catch {}
+			await fs_promises.mkdir(path.dirname(resolvedPath), { recursive: true });
+			if (SUPPORTS_NOFOLLOW) {
+				const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_TRUNC | fs.constants.O_NOFOLLOW;
+				const fd = await fs_promises.open(resolvedPath, flags, 420);
+				try {
+					await fd.writeFile(content, "utf-8");
+				} finally {
+					await fd.close();
+				}
+			} else await fs_promises.writeFile(resolvedPath, content, "utf-8");
+			return {
+				success: true,
+				path: filePath
+			};
+		} catch (e) {
+			return {
+				success: false,
+				error: `Error writing file '${filePath}': ${e.message}`
+			};
+		}
+	}
+	/**
+	* Edit a file by replacing string occurrences.
+	*/
+	async edit(filePath, oldString, newString, replaceAll = false) {
+		try {
+			const resolvedPath = this.resolvePath(filePath);
+			let content;
+			if (SUPPORTS_NOFOLLOW) {
+				if (!(await fs_promises.stat(resolvedPath)).isFile()) return {
+					success: false,
+					error: require_agent.FILE_NOT_FOUND(filePath)
+				};
+				const fd = await fs_promises.open(resolvedPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+				try {
+					content = await fd.readFile({ encoding: "utf-8" });
+				} finally {
+					await fd.close();
+				}
+			} else {
+				const stat = await fs_promises.lstat(resolvedPath);
+				if (stat.isSymbolicLink()) return {
+					success: false,
+					error: `Error: Symlinks are not allowed: ${filePath}`
+				};
+				if (!stat.isFile()) return {
+					success: false,
+					error: require_agent.FILE_NOT_FOUND(filePath)
+				};
+				content = await fs_promises.readFile(resolvedPath, "utf-8");
+			}
+			const result = require_agent.performStringReplacement(content, oldString, newString, replaceAll);
+			if (typeof result === "string") return {
+				success: false,
+				error: result
+			};
+			const [newContent, occurrences] = result;
+			if (SUPPORTS_NOFOLLOW) {
+				const flags = fs.constants.O_WRONLY | fs.constants.O_TRUNC | fs.constants.O_NOFOLLOW;
+				const fd = await fs_promises.open(resolvedPath, flags);
+				try {
+					await fd.writeFile(newContent, "utf-8");
+				} finally {
+					await fd.close();
+				}
+			} else await fs_promises.writeFile(resolvedPath, newContent, "utf-8");
+			return {
+				success: true,
+				path: filePath,
+				occurrences
+			};
+		} catch (e) {
+			return {
+				success: false,
+				error: `Error editing file '${filePath}': ${e.message}`
+			};
+		}
+	}
+	/**
+	* Structured search results or error string for invalid input.
+	*/
+	async grepRaw(pattern, dirPath = "/", glob$1 = null) {
+		try {
+			new RegExp(pattern);
+		} catch (e) {
+			return `Invalid regex pattern: ${e.message}`;
+		}
+		let baseFull;
+		try {
+			baseFull = this.resolvePath(dirPath || ".");
+		} catch {
+			return [];
+		}
+		try {
+			await fs_promises.stat(baseFull);
+		} catch {
+			return [];
+		}
+		let results = await this.ripgrepSearch(pattern, baseFull, glob$1);
+		if (results === null) results = await this.regexSearch(pattern, baseFull, glob$1);
+		const matches = [];
+		for (const [fpath, items] of Object.entries(results)) for (const [lineNum, lineText] of items) matches.push({
+			path: fpath,
+			line: lineNum,
+			text: lineText
+		});
+		return matches;
+	}
+	/**
+	* Try to use ripgrep for fast searching.
+	*/
+	async ripgrepSearch(pattern, baseFull, includeGlob) {
+		return new Promise((resolve) => {
+			const args = ["--json"];
+			if (includeGlob) args.push("--glob", includeGlob);
+			args.push("--", pattern, baseFull);
+			const proc = (0, child_process.spawn)("rg", args, { timeout: 3e4 });
+			const results = {};
+			let output = "";
+			proc.stdout.on("data", (data) => {
+				output += data.toString();
+			});
+			proc.on("close", (code) => {
+				if (code !== 0 && code !== 1) {
+					resolve(null);
+					return;
+				}
+				for (const line of output.split("\n")) {
+					if (!line.trim()) continue;
+					try {
+						const data = JSON.parse(line);
+						if (data.type !== "match") continue;
+						const pdata = data.data || {};
+						const ftext = pdata.path?.text;
+						if (!ftext) continue;
+						let virtPath;
+						if (this.virtualMode) try {
+							const resolved = path.resolve(ftext);
+							const relative = path.relative(this.cwd, resolved);
+							if (relative.startsWith("..")) continue;
+							virtPath = "/" + relative.split(path.sep).join("/");
+						} catch {
+							continue;
+						}
+						else virtPath = ftext;
+						const ln = pdata.line_number;
+						const lt = pdata.lines?.text?.replace(/\n$/, "") || "";
+						if (ln === void 0) continue;
+						if (!results[virtPath]) results[virtPath] = [];
+						results[virtPath].push([ln, lt]);
+					} catch {
+						continue;
+					}
+				}
+				resolve(results);
+			});
+			proc.on("error", () => {
+				resolve(null);
+			});
+		});
+	}
+	/**
+	* Fallback regex search implementation.
+	*/
+	async regexSearch(pattern, baseFull, includeGlob) {
+		let regex;
+		try {
+			regex = new RegExp(pattern);
+		} catch {
+			return {};
+		}
+		const results = {};
+		const files = await (0, fast_glob.default)("**/*", {
+			cwd: (await fs_promises.stat(baseFull)).isDirectory() ? baseFull : path.dirname(baseFull),
+			absolute: true,
+			onlyFiles: true,
+			dot: true
+		});
+		for (const fp of files) try {
+			if (includeGlob && !micromatch.default.isMatch(path.basename(fp), includeGlob)) continue;
+			if ((await fs_promises.stat(fp)).size > this.maxFileSizeBytes) continue;
+			const lines = (await fs_promises.readFile(fp, "utf-8")).split("\n");
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i];
+				if (line && regex.test(line)) {
+					let virtPath;
+					if (this.virtualMode) try {
+						const relative = path.relative(this.cwd, fp);
+						if (relative.startsWith("..")) continue;
+						virtPath = "/" + relative.split(path.sep).join("/");
+					} catch {
+						continue;
+					}
+					else virtPath = fp;
+					if (!results[virtPath]) results[virtPath] = [];
+					results[virtPath].push([i + 1, line]);
+				}
+			}
+		} catch {
+			continue;
+		}
+		return results;
+	}
+	/**
+	* Structured glob matching returning FileInfo objects.
+	*/
+	async globInfo(pattern, searchPath = "/") {
+		if (pattern.startsWith("/")) pattern = pattern.substring(1);
+		const resolvedSearchPath = searchPath === "/" ? this.cwd : this.resolvePath(searchPath);
+		try {
+			if (!(await fs_promises.stat(resolvedSearchPath)).isDirectory()) return [];
+		} catch {
+			return [];
+		}
+		const results = [];
+		try {
+			const matches = await (0, fast_glob.default)(pattern, {
+				cwd: resolvedSearchPath,
+				absolute: true,
+				onlyFiles: true,
+				dot: true
+			});
+			for (const matchedPath of matches) try {
+				const fileStat = await fs_promises.stat(matchedPath);
+				if (!fileStat.isFile()) continue;
+				const normalizedPath = matchedPath.split("/").join(path.sep);
+				if (!this.virtualMode) results.push({
+					path: normalizedPath,
+					is_dir: false,
+					size: fileStat.size,
+					modified_at: fileStat.mtime.toISOString()
+				});
+				else {
+					const cwdStr = this.cwd.endsWith(path.sep) ? this.cwd : this.cwd + path.sep;
+					let relativePath;
+					if (normalizedPath.startsWith(cwdStr)) relativePath = normalizedPath.substring(cwdStr.length);
+					else if (normalizedPath.startsWith(this.cwd)) relativePath = normalizedPath.substring(this.cwd.length).replace(/^[/\\]/, "");
+					else relativePath = normalizedPath;
+					relativePath = relativePath.split(path.sep).join("/");
+					const virt = "/" + relativePath;
+					results.push({
+						path: virt,
+						is_dir: false,
+						size: fileStat.size,
+						modified_at: fileStat.mtime.toISOString()
+					});
+				}
+			} catch {
+				continue;
+			}
+		} catch {}
+		results.sort((a, b) => a.path.localeCompare(b.path));
+		return results;
+	}
+};
+
+//#endregion
+//#region src/backends/composite.ts
+/**
+* Backend that routes file operations to different backends based on path prefix.
+*
+* This enables hybrid storage strategies by routing files to different backends
+* based on their path prefix. Useful for separating persistent and ephemeral storage,
+* or using different storage backends for different types of files.
+*
+* @example Hybrid storage strategy
+* ```typescript
+* import { CompositeBackend, FilesystemBackend, StateBackend } from 'deepagentsdk';
+*
+* const state = { todos: [], files: {} };
+* const backend = new CompositeBackend(
+*   new StateBackend(state), // Default: ephemeral storage
+*   {
+*     '/persistent/': new FilesystemBackend({ rootDir: './persistent' }), // Persistent files
+*     '/cache/': new StateBackend(state), // Cached files (ephemeral)
+*   }
+* );
+*
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend,
+* });
+* ```
+*
+* @example Multiple persistent backends
+* ```typescript
+* const backend = new CompositeBackend(
+*   new FilesystemBackend({ rootDir: './default' }),
+*   {
+*     '/user-data/': new FilesystemBackend({ rootDir: './user-data' }),
+*     '/system/': new FilesystemBackend({ rootDir: './system' }),
+*   }
+* );
+* ```
+*/
+var CompositeBackend = class {
+	defaultBackend;
+	routes;
+	sortedRoutes;
+	/**
+	* Create a new CompositeBackend instance.
+	*
+	* @param defaultBackend - Backend to use for paths that don't match any route prefix
+	* @param routes - Record mapping path prefixes to backends.
+	*                 Routes are matched by longest prefix first.
+	*                 Example: `{ '/persistent/': filesystemBackend, '/cache/': stateBackend }`
+	*/
+	constructor(defaultBackend, routes) {
+		this.defaultBackend = defaultBackend;
+		this.routes = routes;
+		this.sortedRoutes = Object.entries(routes).sort((a, b) => b[0].length - a[0].length);
+	}
+	/**
+	* Determine which backend handles this key and strip prefix.
+	*/
+	getBackendAndKey(key) {
+		for (const [prefix, backend] of this.sortedRoutes) if (key.startsWith(prefix)) {
+			const suffix = key.substring(prefix.length);
+			return [backend, suffix ? "/" + suffix : "/"];
+		}
+		return [this.defaultBackend, key];
+	}
+	/**
+	* List files and directories in the specified directory (non-recursive).
+	*/
+	async lsInfo(path$1) {
+		for (const [routePrefix, backend] of this.sortedRoutes) if (path$1.startsWith(routePrefix.replace(/\/$/, ""))) {
+			const suffix = path$1.substring(routePrefix.length);
+			const searchPath = suffix ? "/" + suffix : "/";
+			const infos = await backend.lsInfo(searchPath);
+			const prefixed = [];
+			for (const fi of infos) prefixed.push({
+				...fi,
+				path: routePrefix.slice(0, -1) + fi.path
+			});
+			return prefixed;
+		}
+		if (path$1 === "/") {
+			const results = [];
+			const defaultInfos = await this.defaultBackend.lsInfo(path$1);
+			results.push(...defaultInfos);
+			for (const [routePrefix] of this.sortedRoutes) results.push({
+				path: routePrefix,
+				is_dir: true,
+				size: 0,
+				modified_at: ""
+			});
+			results.sort((a, b) => a.path.localeCompare(b.path));
+			return results;
+		}
+		return await this.defaultBackend.lsInfo(path$1);
+	}
+	/**
+	* Read file content, routing to appropriate backend.
+	*/
+	async read(filePath, offset = 0, limit = 2e3) {
+		const [backend, strippedKey] = this.getBackendAndKey(filePath);
+		return await backend.read(strippedKey, offset, limit);
+	}
+	/**
+	* Read file content as raw FileData.
+	*/
+	async readRaw(filePath) {
+		const [backend, strippedKey] = this.getBackendAndKey(filePath);
+		return await backend.readRaw(strippedKey);
+	}
+	/**
+	* Structured search results or error string for invalid input.
+	*/
+	async grepRaw(pattern, path$1 = "/", glob$1 = null) {
+		for (const [routePrefix, backend] of this.sortedRoutes) if (path$1.startsWith(routePrefix.replace(/\/$/, ""))) {
+			const suffix = path$1.substring(routePrefix.length);
+			const searchPath = suffix ? "/" + suffix : "/";
+			const raw = await backend.grepRaw(pattern, searchPath, glob$1);
+			if (typeof raw === "string") return raw;
+			return raw.map((m) => ({
+				...m,
+				path: routePrefix.slice(0, -1) + m.path
+			}));
+		}
+		const allMatches = [];
+		const rawDefault = await this.defaultBackend.grepRaw(pattern, path$1, glob$1);
+		if (typeof rawDefault === "string") return rawDefault;
+		allMatches.push(...rawDefault);
+		for (const [routePrefix, backend] of Object.entries(this.routes)) {
+			const raw = await backend.grepRaw(pattern, "/", glob$1);
+			if (typeof raw === "string") return raw;
+			allMatches.push(...raw.map((m) => ({
+				...m,
+				path: routePrefix.slice(0, -1) + m.path
+			})));
+		}
+		return allMatches;
+	}
+	/**
+	* Structured glob matching returning FileInfo objects.
+	*/
+	async globInfo(pattern, path$1 = "/") {
+		const results = [];
+		for (const [routePrefix, backend] of this.sortedRoutes) if (path$1.startsWith(routePrefix.replace(/\/$/, ""))) {
+			const suffix = path$1.substring(routePrefix.length);
+			const searchPath = suffix ? "/" + suffix : "/";
+			return (await backend.globInfo(pattern, searchPath)).map((fi) => ({
+				...fi,
+				path: routePrefix.slice(0, -1) + fi.path
+			}));
+		}
+		const defaultInfos = await this.defaultBackend.globInfo(pattern, path$1);
+		results.push(...defaultInfos);
+		for (const [routePrefix, backend] of Object.entries(this.routes)) {
+			const infos = await backend.globInfo(pattern, "/");
+			results.push(...infos.map((fi) => ({
+				...fi,
+				path: routePrefix.slice(0, -1) + fi.path
+			})));
+		}
+		results.sort((a, b) => a.path.localeCompare(b.path));
+		return results;
+	}
+	/**
+	* Create a new file, routing to appropriate backend.
+	*/
+	async write(filePath, content) {
+		const [backend, strippedKey] = this.getBackendAndKey(filePath);
+		return await backend.write(strippedKey, content);
+	}
+	/**
+	* Edit a file, routing to appropriate backend.
+	*/
+	async edit(filePath, oldString, newString, replaceAll = false) {
+		const [backend, strippedKey] = this.getBackendAndKey(filePath);
+		return await backend.edit(strippedKey, oldString, newString, replaceAll);
+	}
+};
+
+//#endregion
+//#region src/backends/persistent.ts
+/**
+* Simple in-memory implementation of KeyValueStore.
+*
+* Useful for testing or single-session persistence. Data is stored in a Map
+* and does not persist across application restarts.
+*
+* @example Basic usage
+* ```typescript
+* const store = new InMemoryStore();
+* const backend = new PersistentBackend({ store });
+* ```
+*
+* @example For testing
+* ```typescript
+* const store = new InMemoryStore();
+* // ... run tests ...
+* store.clear(); // Clean up after tests
+* ```
+*/
+var InMemoryStore = class {
+	data = /* @__PURE__ */ new Map();
+	makeKey(namespace, key) {
+		return [...namespace, key].join(":");
+	}
+	parseKey(fullKey, namespace) {
+		const prefix = namespace.join(":") + ":";
+		if (fullKey.startsWith(prefix)) return fullKey.substring(prefix.length);
+		return null;
+	}
+	async get(namespace, key) {
+		return this.data.get(this.makeKey(namespace, key));
+	}
+	async put(namespace, key, value) {
+		this.data.set(this.makeKey(namespace, key), value);
+	}
+	async delete(namespace, key) {
+		this.data.delete(this.makeKey(namespace, key));
+	}
+	async list(namespace) {
+		const results = [];
+		const prefix = namespace.join(":") + ":";
+		for (const [fullKey, value] of this.data.entries()) if (fullKey.startsWith(prefix)) {
+			const key = fullKey.substring(prefix.length);
+			if (!key.includes(":")) results.push({
+				key,
+				value
+			});
+		}
+		return results;
+	}
+	/**
+	* Clear all data (useful for testing).
+	*/
+	clear() {
+		this.data.clear();
+	}
+	/**
+	* Get the number of stored items.
+	*/
+	size() {
+		return this.data.size;
+	}
+};
+/**
+* Backend that stores files in a persistent key-value store.
+*
+* This provides cross-conversation file persistence that survives between agent sessions.
+* Files are stored in the provided key-value store, allowing you to use any storage backend
+* (Redis, SQLite, cloud storage, etc.) by implementing the `KeyValueStore` interface.
+*
+* @example Using InMemoryStore (for testing or single-session persistence)
+* ```typescript
+* import { createDeepAgent } from 'deepagentsdk';
+* import { PersistentBackend, InMemoryStore } from 'deepagentsdk';
+* import { anthropic } from '@ai-sdk/anthropic';
+*
+* const store = new InMemoryStore();
+* const backend = new PersistentBackend({ store });
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend,
+* });
+* ```
+*
+* @example With custom namespace for project isolation
+* ```typescript
+* import { createDeepAgent } from 'deepagentsdk';
+* import { PersistentBackend, InMemoryStore } from 'deepagentsdk';
+* import { anthropic } from '@ai-sdk/anthropic';
+*
+* const store = new InMemoryStore();
+* const backend = new PersistentBackend({
+*   store,
+*   namespace: 'project-123', // Isolate files for this project
+* });
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend,
+* });
+* ```
+*
+* @example Custom KeyValueStore implementation (Redis)
+* ```typescript
+* import { createDeepAgent } from 'deepagentsdk';
+* import { PersistentBackend, type KeyValueStore } from 'deepagentsdk';
+* import { anthropic } from '@ai-sdk/anthropic';
+* import { createClient } from 'redis';
+*
+* class RedisStore implements KeyValueStore {
+*   constructor(private redis: ReturnType<typeof createClient>) {}
+*
+*   async get(namespace: string[], key: string) {
+*     const redisKey = [...namespace, key].join(':');
+*     const data = await this.redis.get(redisKey);
+*     return data ? JSON.parse(data) : undefined;
+*   }
+*
+*   async put(namespace: string[], key: string, value: Record<string, unknown>) {
+*     const redisKey = [...namespace, key].join(':');
+*     await this.redis.set(redisKey, JSON.stringify(value));
+*   }
+*
+*   async delete(namespace: string[], key: string) {
+*     const redisKey = [...namespace, key].join(':');
+*     await this.redis.del(redisKey);
+*   }
+*
+*   async list(namespace: string[]) {
+*     const prefix = [...namespace].join(':') + ':';
+*     const keys = await this.redis.keys(prefix + '*');
+*     const results = [];
+*     for (const key of keys) {
+*       const data = await this.redis.get(key);
+*       if (data) {
+*         const relativeKey = key.substring(prefix.length);
+*         results.push({ key: relativeKey, value: JSON.parse(data) });
+*       }
+*     }
+*     return results;
+*   }
+* }
+*
+* const redis = createClient();
+* await redis.connect();
+*
+* const backend = new PersistentBackend({ 
+*   store: new RedisStore(redis),
+*   namespace: 'production'
+* });
+*
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend,
+* });
+* ```
+*/
+var PersistentBackend = class {
+	store;
+	namespacePrefix;
+	/**
+	* Create a new PersistentBackend instance.
+	*
+	* @param options - Configuration options
+	* @param options.store - The key-value store implementation to use
+	* @param options.namespace - Optional namespace prefix for file isolation
+	*/
+	constructor(options) {
+		this.store = options.store;
+		this.namespacePrefix = options.namespace || "default";
+	}
+	/**
+	* Get the namespace for store operations.
+	*/
+	getNamespace() {
+		return [this.namespacePrefix, "filesystem"];
+	}
+	/**
+	* Convert a store value to FileData format.
+	*/
+	convertToFileData(value) {
+		if (!value.content || !Array.isArray(value.content) || typeof value.created_at !== "string" || typeof value.modified_at !== "string") throw new Error(`Store item does not contain valid FileData fields. Got keys: ${Object.keys(value).join(", ")}`);
+		return {
+			content: value.content,
+			created_at: value.created_at,
+			modified_at: value.modified_at
+		};
+	}
+	/**
+	* Convert FileData to a value suitable for store.put().
+	*/
+	convertFromFileData(fileData) {
+		return {
+			content: fileData.content,
+			created_at: fileData.created_at,
+			modified_at: fileData.modified_at
+		};
+	}
+	/**
+	* List files and directories in the specified directory (non-recursive).
+	*/
+	async lsInfo(path$1) {
+		const namespace = this.getNamespace();
+		const items = await this.store.list(namespace);
+		const infos = [];
+		const subdirs = /* @__PURE__ */ new Set();
+		const normalizedPath = path$1.endsWith("/") ? path$1 : path$1 + "/";
+		for (const item of items) {
+			const itemKey = item.key;
+			if (!itemKey.startsWith(normalizedPath)) continue;
+			const relative = itemKey.substring(normalizedPath.length);
+			if (relative.includes("/")) {
+				const subdirName = relative.split("/")[0];
+				subdirs.add(normalizedPath + subdirName + "/");
+				continue;
+			}
+			try {
+				const fd = this.convertToFileData(item.value);
+				const size = fd.content.join("\n").length;
+				infos.push({
+					path: itemKey,
+					is_dir: false,
+					size,
+					modified_at: fd.modified_at
+				});
+			} catch {
+				continue;
+			}
+		}
+		for (const subdir of Array.from(subdirs).sort()) infos.push({
+			path: subdir,
+			is_dir: true,
+			size: 0,
+			modified_at: ""
+		});
+		infos.sort((a, b) => a.path.localeCompare(b.path));
+		return infos;
+	}
+	/**
+	* Read file content with line numbers.
+	*/
+	async read(filePath, offset = 0, limit = 2e3) {
+		try {
+			return require_agent.formatReadResponse(await this.readRaw(filePath), offset, limit);
+		} catch (e) {
+			return `Error: ${e.message}`;
+		}
+	}
+	/**
+	* Read file content as raw FileData.
+	*/
+	async readRaw(filePath) {
+		const namespace = this.getNamespace();
+		const value = await this.store.get(namespace, filePath);
+		if (!value) throw new Error(`File '${filePath}' not found`);
+		return this.convertToFileData(value);
+	}
+	/**
+	* Create a new file with content.
+	*/
+	async write(filePath, content) {
+		const namespace = this.getNamespace();
+		if (await this.store.get(namespace, filePath)) return {
+			success: false,
+			error: require_agent.FILE_ALREADY_EXISTS(filePath)
+		};
+		const fileData = require_agent.createFileData(content);
+		const storeValue = this.convertFromFileData(fileData);
+		await this.store.put(namespace, filePath, storeValue);
+		return {
+			success: true,
+			path: filePath
+		};
+	}
+	/**
+	* Edit a file by replacing string occurrences.
+	*/
+	async edit(filePath, oldString, newString, replaceAll = false) {
+		const namespace = this.getNamespace();
+		const value = await this.store.get(namespace, filePath);
+		if (!value) return {
+			success: false,
+			error: require_agent.FILE_NOT_FOUND(filePath)
+		};
+		try {
+			const fileData = this.convertToFileData(value);
+			const result = require_agent.performStringReplacement(require_agent.fileDataToString(fileData), oldString, newString, replaceAll);
+			if (typeof result === "string") return {
+				success: false,
+				error: result
+			};
+			const [newContent, occurrences] = result;
+			const newFileData = require_agent.updateFileData(fileData, newContent);
+			const storeValue = this.convertFromFileData(newFileData);
+			await this.store.put(namespace, filePath, storeValue);
+			return {
+				success: true,
+				path: filePath,
+				occurrences
+			};
+		} catch (e) {
+			return {
+				success: false,
+				error: `Error: ${e.message}`
+			};
+		}
+	}
+	/**
+	* Structured search results or error string for invalid input.
+	*/
+	async grepRaw(pattern, path$1 = "/", glob$1 = null) {
+		const namespace = this.getNamespace();
+		const items = await this.store.list(namespace);
+		const files = {};
+		for (const item of items) try {
+			files[item.key] = this.convertToFileData(item.value);
+		} catch {
+			continue;
+		}
+		return require_agent.grepMatchesFromFiles(files, pattern, path$1, glob$1);
+	}
+	/**
+	* Structured glob matching returning FileInfo objects.
+	*/
+	async globInfo(pattern, path$1 = "/") {
+		const namespace = this.getNamespace();
+		const items = await this.store.list(namespace);
+		const files = {};
+		for (const item of items) try {
+			files[item.key] = this.convertToFileData(item.value);
+		} catch {
+			continue;
+		}
+		const result = require_agent.globSearchFiles(files, pattern, path$1);
+		if (result === "No files found") return [];
+		const paths = result.split("\n");
+		const infos = [];
+		for (const p of paths) {
+			const fd = files[p];
+			const size = fd ? fd.content.join("\n").length : 0;
+			infos.push({
+				path: p,
+				is_dir: false,
+				size,
+				modified_at: fd?.modified_at || ""
+			});
+		}
+		return infos;
+	}
+	/**
+	* Delete a file.
+	*/
+	async deleteFile(filePath) {
+		const namespace = this.getNamespace();
+		if (!await this.store.get(namespace, filePath)) return { error: `File '${filePath}' not found` };
+		await this.store.delete(namespace, filePath);
+		return {};
+	}
+};
+
+//#endregion
+//#region src/checkpointer/memory-saver.ts
+/**
+* In-memory checkpoint saver.
+* 
+* Stores checkpoints in a Map. Data is lost when the process exits.
+* Useful for testing or single-session applications.
+* 
+* @example
+* ```typescript
+* const saver = new MemorySaver();
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   checkpointer: saver,
+* });
+* ```
+*/
+var MemorySaver = class {
+	checkpoints = /* @__PURE__ */ new Map();
+	namespace;
+	constructor(options = {}) {
+		this.namespace = options.namespace || "default";
+	}
+	getKey(threadId) {
+		return `${this.namespace}:${threadId}`;
+	}
+	async save(checkpoint) {
+		const key = this.getKey(checkpoint.threadId);
+		this.checkpoints.set(key, {
+			...checkpoint,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+	async load(threadId) {
+		const key = this.getKey(threadId);
+		return this.checkpoints.get(key);
+	}
+	async list() {
+		const prefix = `${this.namespace}:`;
+		const threadIds = [];
+		for (const key of this.checkpoints.keys()) if (key.startsWith(prefix)) threadIds.push(key.substring(prefix.length));
+		return threadIds;
+	}
+	async delete(threadId) {
+		const key = this.getKey(threadId);
+		this.checkpoints.delete(key);
+	}
+	async exists(threadId) {
+		const key = this.getKey(threadId);
+		return this.checkpoints.has(key);
+	}
+	/**
+	* Clear all checkpoints (useful for testing).
+	*/
+	clear() {
+		this.checkpoints.clear();
+	}
+	/**
+	* Get the number of stored checkpoints.
+	*/
+	size() {
+		return this.checkpoints.size;
+	}
+};
+
+//#endregion
+//#region src/checkpointer/kv-saver.ts
+/**
+* Checkpoint saver using KeyValueStore interface.
+* 
+* This adapter allows using any KeyValueStore implementation (Redis,
+* database, cloud storage, etc.) for checkpoint storage.
+* 
+* @example
+* ```typescript
+* import { InMemoryStore } from 'deepagentsdk';
+* 
+* const store = new InMemoryStore();
+* const saver = new KeyValueStoreSaver({ store });
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   checkpointer: saver,
+* });
+* ```
+* 
+* @example With Redis
+* ```typescript
+* const redisStore = new RedisStore(redisClient); // Your implementation
+* const saver = new KeyValueStoreSaver({ store: redisStore });
+* ```
+*/
+var KeyValueStoreSaver = class {
+	store;
+	namespace;
+	constructor(options) {
+		this.store = options.store;
+		this.namespace = [options.namespace || "default", "checkpoints"];
+	}
+	async save(checkpoint) {
+		const data = {
+			...checkpoint,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.store.put(this.namespace, checkpoint.threadId, data);
+	}
+	async load(threadId) {
+		const data = await this.store.get(this.namespace, threadId);
+		if (!data) return;
+		return data;
+	}
+	async list() {
+		return (await this.store.list(this.namespace)).map((item) => item.key);
+	}
+	async delete(threadId) {
+		await this.store.delete(this.namespace, threadId);
+	}
+	async exists(threadId) {
+		return await this.store.get(this.namespace, threadId) !== void 0;
+	}
+};
+
+//#endregion
+//#region src/middleware/agent-memory.ts
+/**
+* Load agent memory from a file path.
+* Returns empty string if file doesn't exist or can't be read.
+*/
+async function loadAgentMemory(filePath) {
+	try {
+		return (await node_fs_promises.readFile(filePath, "utf-8")).trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Load all additional .md files from the agent's directory (excluding agent.md).
+* Returns an array of { filename, content } objects.
+*/
+async function loadAdditionalMemoryFiles(dirPath) {
+	try {
+		const mdFiles = (await node_fs_promises.readdir(dirPath)).filter((f) => f.endsWith(".md") && f !== "agent.md");
+		return (await Promise.all(mdFiles.map(async (filename) => {
+			return {
+				filename,
+				content: await loadAgentMemory(node_path.join(dirPath, filename))
+			};
+		}))).filter((r) => r.content.length > 0);
+	} catch {
+		return [];
+	}
+}
+/**
+* Build the memory section for the system prompt.
+* This comprehensive prompt teaches the agent how to use memory effectively.
+*/
+function buildMemorySection(userMemory, projectMemory, additionalFiles, agentId, userMemoryPath, projectMemoryPath) {
+	let sections = [];
+	if (userMemory) sections.push(`# Agent Memory (User-Level)
+
+The following is your persistent memory stored at ${userMemoryPath}:
+
+${userMemory}`);
+	if (projectMemory && projectMemoryPath) sections.push(`# Agent Memory (Project-Level)
+
+The following is project-specific context stored at ${projectMemoryPath}:
+
+${projectMemory}`);
+	if (additionalFiles.length > 0) {
+		const additionalSections = additionalFiles.map(({ filename, content }) => `## ${filename}
+
+${content}`);
+		sections.push(`# Additional Context Files
+
+${additionalSections.join("\n\n")}`);
+	}
+	if (sections.length === 0) return "";
+	return `
+<agent_memory>
+${sections.join("\n\n---\n\n")}
+
+---
+
+## How to Use This Memory
+
+**What is this?**
+- The content above is your persistent memory, stored in markdown files
+- **User-level memory** (${userMemoryPath}) contains your core personality, preferences, and cross-project context
+- **Project-level memory** ${projectMemoryPath ? `(${projectMemoryPath})` : "(not available)"} contains project-specific context and conventions
+
+**When to read memory:**
+- You already have the memory content above in your context - no need to read the files unless you need to verify exact content
+- If you need to check current memory state or see if it's been updated, use \`read_file\` tool
+
+**When to update memory:**
+- **User memory**: When you learn something important about the user's preferences, working style, or recurring patterns
+- **Project memory**: When you discover project-specific conventions, architecture decisions, or important context
+- **Additional files**: For specialized context that doesn't fit in agent.md (e.g., decision logs, architecture notes)
+
+**How to update memory:**
+- Use the \`write_file\` or \`edit_file\` tools with the file paths shown above
+- Keep entries concise and relevant
+- Organize information clearly with markdown headings
+- Remove outdated information when updating
+
+**Important guidelines:**
+- Memory is meant for long-term context, not temporary task tracking
+- Don't store information that's already in the codebase or documentation
+- Focus on insights, patterns, and preferences that aren't obvious from other sources
+- When in doubt, ask the user if something should be remembered
+
+**Example use cases:**
+- User prefers TypeScript strict mode and comprehensive error handling
+- Project uses custom testing framework located in \`test-utils/\`
+- User wants all API responses to follow specific error format
+- Project has specific commit message conventions
+</agent_memory>
+`.trim();
+}
+/**
+* Create agent memory middleware for AI SDK v6.
+*
+* This middleware loads agent memory from:
+* 1. User-level: ~/.deepagents/{agentId}/agent.md (personality, preferences)
+* 2. Project-level: [git-root]/.deepagents/agent.md (project-specific context)
+* 3. Additional files: Any other .md files in the user-level directory
+*
+* The memory is injected into the system prompt before each model call, teaching
+* the agent when and how to read/update its own memory using filesystem tools.
+*
+* @param options - Configuration for agent memory
+* @param options.agentId - Unique identifier for the agent (e.g., "code-architect")
+* @param options.workingDirectory - Optional working directory for project detection (defaults to process.cwd())
+* @param options.userDeepagentsDir - Optional custom path for user-level .deepagents directory (defaults to ~/.deepagents)
+* @param options.requestProjectApproval - Optional callback to request approval before creating project .deepagents/ directory
+* @returns AI SDK v6 middleware
+*
+* @example Basic usage
+* ```typescript
+* import { createDeepAgent } from 'deepagentsdk';
+* import { createAgentMemoryMiddleware } from 'deepagentsdk/middleware';
+* import { anthropic } from '@ai-sdk/anthropic';
+*
+* const memoryMiddleware = createAgentMemoryMiddleware({
+*   agentId: 'code-architect',
+* });
+*
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-5'),
+*   middleware: memoryMiddleware,
+* });
+* ```
+*
+* @example With project approval callback
+* ```typescript
+* const memoryMiddleware = createAgentMemoryMiddleware({
+*   agentId: 'code-architect',
+*   requestProjectApproval: async (projectPath) => {
+*     console.log(`Create .deepagents/ in ${projectPath}? (y/n)`);
+*     // ... get user input
+*     return userSaidYes;
+*   }
+* });
+* ```
+*
+* @example With custom user directory path
+* ```typescript
+* const memoryMiddleware = createAgentMemoryMiddleware({
+*   agentId: 'code-architect',
+*   userDeepagentsDir: '/custom/path/.deepagents',
+*   // Memory will be loaded from:
+*   // - /custom/path/.deepagents/code-architect/agent.md
+*   // - [git-root]/.deepagents/agent.md (project-level)
+* });
+* ```
+*/
+function createAgentMemoryMiddleware(options) {
+	const { agentId, workingDirectory, userDeepagentsDir, requestProjectApproval } = options;
+	let memoryLoaded = false;
+	let cachedMemorySection = "";
+	return {
+		specificationVersion: "v3",
+		transformParams: async ({ params }) => {
+			if (!memoryLoaded) {
+				const workDir = workingDirectory || process.cwd();
+				const baseUserDir = userDeepagentsDir || node_path.join(node_os.default.homedir(), ".deepagents");
+				const userAgentDir = node_path.join(baseUserDir, agentId);
+				const userMemoryPath = node_path.join(userAgentDir, "agent.md");
+				const userMemory = await loadAgentMemory(userMemoryPath);
+				if (!userMemory) try {
+					await node_fs_promises.mkdir(userAgentDir, { recursive: true });
+				} catch {}
+				const additionalFiles = await loadAdditionalMemoryFiles(userAgentDir);
+				let projectMemory = "";
+				let projectMemoryPath = null;
+				const gitRoot = await require_load.findGitRoot(workDir);
+				if (gitRoot) {
+					const projectDeepagentsDir = node_path.join(gitRoot, ".deepagents");
+					projectMemoryPath = node_path.join(projectDeepagentsDir, "agent.md");
+					try {
+						await node_fs_promises.stat(projectDeepagentsDir);
+						projectMemory = await loadAgentMemory(projectMemoryPath);
+					} catch {
+						if (requestProjectApproval) {
+							if (await requestProjectApproval(gitRoot)) try {
+								await node_fs_promises.mkdir(projectDeepagentsDir, { recursive: true });
+							} catch {}
+						}
+					}
+				}
+				cachedMemorySection = buildMemorySection(userMemory, projectMemory, additionalFiles, agentId, userMemoryPath, projectMemoryPath);
+				memoryLoaded = true;
+			}
+			if (cachedMemorySection) {
+				const updatedPrompt = params.prompt.map((msg) => {
+					if (msg.role === "system") return {
+						...msg,
+						content: `${msg.content}\n\n${cachedMemorySection}`
+					};
+					return msg;
+				});
+				return {
+					...params,
+					prompt: updatedPrompt
+				};
+			}
+			return params;
+		}
+	};
+}
+
+//#endregion
+exports.BASE_PROMPT = require_agent.BASE_PROMPT;
+exports.BaseSandbox = require_file_saver.BaseSandbox;
+exports.CompositeBackend = CompositeBackend;
+exports.DEFAULT_EVICTION_TOKEN_LIMIT = require_agent.DEFAULT_EVICTION_TOKEN_LIMIT;
+exports.DEFAULT_GENERAL_PURPOSE_DESCRIPTION = require_agent.DEFAULT_GENERAL_PURPOSE_DESCRIPTION;
+exports.DEFAULT_KEEP_MESSAGES = require_agent.DEFAULT_KEEP_MESSAGES;
+exports.DEFAULT_SUBAGENT_PROMPT = require_agent.DEFAULT_SUBAGENT_PROMPT;
+exports.DEFAULT_SUMMARIZATION_THRESHOLD = require_agent.DEFAULT_SUMMARIZATION_THRESHOLD;
+exports.DeepAgent = require_agent.DeepAgent;
+exports.EXECUTE_SYSTEM_PROMPT = require_agent.EXECUTE_SYSTEM_PROMPT;
+exports.FILESYSTEM_SYSTEM_PROMPT = require_agent.FILESYSTEM_SYSTEM_PROMPT;
+exports.FileSaver = require_file_saver.FileSaver;
+exports.FilesystemBackend = FilesystemBackend;
+exports.InMemoryStore = InMemoryStore;
+exports.KeyValueStoreSaver = KeyValueStoreSaver;
+exports.LocalSandbox = require_file_saver.LocalSandbox;
+exports.MemorySaver = MemorySaver;
+exports.PersistentBackend = PersistentBackend;
+exports.StateBackend = require_agent.StateBackend;
+exports.TASK_SYSTEM_PROMPT = require_agent.TASK_SYSTEM_PROMPT;
+exports.TODO_SYSTEM_PROMPT = require_agent.TODO_SYSTEM_PROMPT;
+Object.defineProperty(exports, 'ToolLoopAgent', {
+  enumerable: true,
+  get: function () {
+    return ai.ToolLoopAgent;
+  }
+});
+exports.createAgentMemoryMiddleware = createAgentMemoryMiddleware;
+exports.createDeepAgent = require_agent.createDeepAgent;
+exports.createEditFileTool = require_agent.createEditFileTool;
+exports.createExecuteTool = require_agent.createExecuteTool;
+exports.createExecuteToolFromBackend = require_agent.createExecuteToolFromBackend;
+exports.createFetchUrlTool = require_agent.createFetchUrlTool;
+exports.createFilesystemTools = require_agent.createFilesystemTools;
+exports.createGlobTool = require_agent.createGlobTool;
+exports.createGrepTool = require_agent.createGrepTool;
+exports.createHttpRequestTool = require_agent.createHttpRequestTool;
+exports.createLsTool = require_agent.createLsTool;
+exports.createReadFileTool = require_agent.createReadFileTool;
+exports.createSubagentTool = require_agent.createSubagentTool;
+exports.createTodosTool = require_agent.createTodosTool;
+exports.createToolResultWrapper = require_agent.createToolResultWrapper;
+exports.createWebSearchTool = require_agent.createWebSearchTool;
+exports.createWebTools = require_agent.createWebTools;
+exports.createWriteFileTool = require_agent.createWriteFileTool;
+exports.edit_file = require_agent.edit_file;
+exports.estimateMessagesTokens = require_agent.estimateMessagesTokens;
+exports.estimateTokens = require_agent.estimateTokens;
+exports.eventHasStructuredOutput = eventHasStructuredOutput;
+exports.evictToolResult = require_agent.evictToolResult;
+exports.execute = require_agent.execute;
+exports.fetch_url = require_agent.fetch_url;
+exports.findGitRoot = require_load.findGitRoot;
+exports.getEventOutput = getEventOutput;
+exports.getStructuredOutput = getStructuredOutput;
+exports.getTaskToolDescription = require_agent.getTaskToolDescription;
+exports.glob = require_agent.glob;
+exports.grep = require_agent.grep;
+exports.hasDanglingToolCalls = require_agent.hasDanglingToolCalls;
+exports.hasStructuredOutput = hasStructuredOutput;
+Object.defineProperty(exports, 'hasToolCall', {
+  enumerable: true,
+  get: function () {
+    return ai.hasToolCall;
+  }
+});
+exports.htmlToMarkdown = require_agent.htmlToMarkdown;
+exports.http_request = require_agent.http_request;
+exports.isSandboxBackend = require_agent.isSandboxBackend;
+exports.listSkills = require_load.listSkills;
+exports.ls = require_agent.ls;
+exports.needsSummarization = require_agent.needsSummarization;
+exports.parseSkillMetadata = require_load.parseSkillMetadata;
+exports.patchToolCalls = require_agent.patchToolCalls;
+exports.read_file = require_agent.read_file;
+exports.shouldEvict = require_agent.shouldEvict;
+Object.defineProperty(exports, 'stepCountIs', {
+  enumerable: true,
+  get: function () {
+    return ai.stepCountIs;
+  }
+});
+exports.summarizeIfNeeded = require_agent.summarizeIfNeeded;
+exports.web_search = require_agent.web_search;
+Object.defineProperty(exports, 'wrapLanguageModel', {
+  enumerable: true,
+  get: function () {
+    return ai.wrapLanguageModel;
+  }
+});
+exports.write_file = require_agent.write_file;
+exports.write_todos = require_agent.write_todos;
+//# sourceMappingURL=index.cjs.map