deepagentsdk 0.12.0 → 0.14.0

package/dist/{agent-Cuks-Idh.cjs → file-saver-BYPKakT4.cjs}

@@ -1,4 +1,4 @@
-const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_chunk = require('./chunk-C5azi7Hr.cjs');
 let ai = require("ai");
 let zod = require("zod");
 let micromatch = require("micromatch");
@@ -9,139 +9,28 @@ let turndown = require("turndown");
 turndown = require_chunk.__toESM(turndown);
 let _mozilla_readability = require("@mozilla/readability");
 let jsdom = require("jsdom");
+let child_process = require("child_process");
+let _ai_sdk_anthropic = require("@ai-sdk/anthropic");
+let _ai_sdk_openai = require("@ai-sdk/openai");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
 
 //#region src/constants/limits.ts
-/**
-* Centralized token, size, and timeout limits.
-*
-* These constants prevent magic number scattering across the codebase and provide
-* a single source of truth for configuration values. When updating these values,
-* consider the impact on performance, user experience, and API limits.
-*
-* @module constants/limits
-*/
-/**
-* Default token limit for tool result eviction.
-*
-* When a tool result exceeds this limit, it is automatically evicted to a file
-* to prevent context overflow. The evicted content is stored in the backend and
-* a summary is kept in the conversation history.
-*
-* @default 20000
-* @see {@link ../utils/eviction | evictToolResult}
-*/
-const DEFAULT_EVICTION_TOKEN_LIMIT$1 = 2e4;
-/**
-* Default threshold for message summarization.
-*
-* When the estimated token count of messages exceeds this threshold, the system
-* automatically summarizes older messages to stay within context limits. This
-* helps maintain conversation continuity while reducing token usage.
-*
-* @default 170000
-* @see {@link ../utils/summarization | summarizeIfNeeded}
-*/
-const DEFAULT_SUMMARIZATION_THRESHOLD$1 = 17e4;
-/**
-* Maximum context window size for Claude models.
-*
-* This represents the maximum number of tokens that can be processed in a single
-* conversation. Used for calculating token usage percentages and determining when
-* summarization is needed.
-*
-* @default 200000
-* @see {@link ../utils/summarization | estimateMessagesTokens}
-*/
-const CONTEXT_WINDOW = 2e5;
-/**
-* Default number of recent messages to keep during summarization.
-*
-* When summarization is triggered, this many of the most recent messages are
-* preserved verbatim while older messages are summarized. This ensures recent
-* context is immediately available to the agent.
-*
-* @default 6
-*/
-const DEFAULT_KEEP_MESSAGES$1 = 6;
-/**
-* Default maximum number of reasoning steps for the main agent.
-*
-* The agent will stop after reaching this many steps to prevent infinite loops
-* or excessive token usage. Each step represents one tool invocation cycle.
-*
-* @default 100
-*/
-const DEFAULT_MAX_STEPS = 100;
-/**
-* Default maximum number of reasoning steps for subagents.
-*
-* Subagents are given a lower step limit than the main agent to prevent them
-* from consuming too many resources. This ensures the parent agent maintains
-* control over the overall task.
-*
-* @default 50
-* @see {@link ../tools/subagent | createTaskTool}
-*/
-const DEFAULT_SUBAGENT_MAX_STEPS = 50;
-/**
-* Default maximum number of lines to read from a file.
-*
-* The read_file tool defaults to reading this many lines to prevent loading
-* extremely large files into context. Can be overridden per-read operation.
-*
-* @default 2000
-* @see {@link ../tools/filesystem | createReadFileTool}
-*/
-const DEFAULT_READ_LIMIT = 2e3;
-/**
-* Maximum line length before content is considered invalid.
-*
-* Lines exceeding this length may indicate minified code, binary content, or
-* other data that should not be processed as text. Used for validation.
-*
-* @default 10000
-*/
-const MAX_LINE_LENGTH = 1e4;
-/**
-* Maximum file size in megabytes for file operations.
-*
-* Files larger than this size will be rejected to prevent memory issues and
-* excessive token usage. This is a soft limit that can be adjusted for specific
-* use cases.
-*
-* @default 10
-*/
-const MAX_FILE_SIZE_MB = 10;
-/**
-* Default timeout for network requests in seconds.
-*
-* Used by web tools (http_request, fetch_url) to prevent hanging indefinitely
-* on slow or unresponsive servers. Can be overridden per-request.
-*
-* @default 30
-* @see {@link ../tools/web | createHttpRequestTool}
-*/
-const DEFAULT_TIMEOUT_SECONDS = 30;
-/**
-* Default timeout in milliseconds (derived from DEFAULT_TIMEOUT_SECONDS).
-*
-* Provided for convenience when working with APIs that expect milliseconds
-* instead of seconds.
-*
-* @default 30000 (30 seconds)
-*/
-const DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_SECONDS * 1e3;
-/**
-* Width for line number formatting in file read operations.
-*
-* When displaying file content with line numbers, this specifies the minimum
-* width for the line number column. Ensures consistent alignment across
-* different file sizes.
-*
-* @default 6
-* @see {@link ../backends/utils | formatFileContent}
-*/
-const LINE_NUMBER_WIDTH = 6;
+var DEFAULT_EVICTION_TOKEN_LIMIT$1, DEFAULT_SUMMARIZATION_THRESHOLD$1, CONTEXT_WINDOW, DEFAULT_KEEP_MESSAGES$1, DEFAULT_MAX_STEPS, DEFAULT_SUBAGENT_MAX_STEPS, DEFAULT_READ_LIMIT, MAX_LINE_LENGTH, MAX_FILE_SIZE_MB, DEFAULT_TIMEOUT_SECONDS, DEFAULT_TIMEOUT_MS, LINE_NUMBER_WIDTH;
+var init_limits = require_chunk.__esmMin((() => {
+	DEFAULT_EVICTION_TOKEN_LIMIT$1 = 2e4;
+	DEFAULT_SUMMARIZATION_THRESHOLD$1 = 17e4;
+	CONTEXT_WINDOW = 2e5;
+	DEFAULT_KEEP_MESSAGES$1 = 6;
+	DEFAULT_MAX_STEPS = 100;
+	DEFAULT_SUBAGENT_MAX_STEPS = 50;
+	DEFAULT_READ_LIMIT = 2e3;
+	MAX_LINE_LENGTH = 1e4;
+	MAX_FILE_SIZE_MB = 10;
+	DEFAULT_TIMEOUT_SECONDS = 30;
+	DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_SECONDS * 1e3;
+	LINE_NUMBER_WIDTH = 6;
+}));
 
 //#endregion
 //#region src/utils/events.ts
@@ -303,6 +192,7 @@ function createCheckpointLoadedEvent(threadId, step, messagesCount) {
 		messagesCount
 	};
 }
+var init_events = require_chunk.__esmMin((() => {}));
 
 //#endregion
 //#region src/types/backend.ts
@@ -499,6 +389,7 @@ Skills provide expert knowledge for specialized tasks. Always read the full skil
 /**
 * Todo list tool for task planning and tracking.
 */
+init_events();
 const TodoItemSchema = zod.z.object({
 	id: zod.z.string().describe("Unique identifier for the todo item"),
 	content: zod.z.string().max(100).describe("The description/content of the todo item (max 100 chars)"),
@@ -557,23 +448,24 @@ const write_todos = createTodosTool;
 
 //#endregion
 //#region src/constants/errors.ts
-/**
-* Centralized error message constants for backend operations
-* Reduces duplication across 6 backend implementations
-*/
-const FILE_NOT_FOUND = (path$1) => `Error: File '${path$1}' not found`;
-const FILE_ALREADY_EXISTS = (path$1) => `Cannot write to ${path$1} because it already exists. Read and then make an edit, or write to a new path.`;
-const STRING_NOT_FOUND = (path$1, string) => `Error: String not found in file: '${path$1}'\n\n${string}`;
-const INVALID_REGEX = (message) => `Invalid regex pattern: ${message}`;
-const WEB_SEARCH_ERROR = (message) => `Web search error: ${message}`;
-const REQUEST_TIMEOUT = (timeout) => `Request timed out after ${timeout} seconds`;
-const SYSTEM_REMINDER_FILE_EMPTY = "System reminder: File exists but has empty contents";
+var FILE_NOT_FOUND, FILE_ALREADY_EXISTS, STRING_NOT_FOUND, INVALID_REGEX, WEB_SEARCH_ERROR, REQUEST_TIMEOUT, SYSTEM_REMINDER_FILE_EMPTY;
+var init_errors = require_chunk.__esmMin((() => {
+	FILE_NOT_FOUND = (path$1) => `Error: File '${path$1}' not found`;
+	FILE_ALREADY_EXISTS = (path$1) => `Cannot write to ${path$1} because it already exists. Read and then make an edit, or write to a new path.`;
+	STRING_NOT_FOUND = (path$1, string) => `Error: String not found in file: '${path$1}'\n\n${string}`;
+	INVALID_REGEX = (message) => `Invalid regex pattern: ${message}`;
+	WEB_SEARCH_ERROR = (message) => `Web search error: ${message}`;
+	REQUEST_TIMEOUT = (timeout) => `Request timed out after ${timeout} seconds`;
+	SYSTEM_REMINDER_FILE_EMPTY = "System reminder: File exists but has empty contents";
+}));
 
 //#endregion
 //#region src/backends/utils.ts
 /**
 * Shared utility functions for memory backend implementations.
 */
+init_errors();
+init_limits();
 const EMPTY_CONTENT_WARNING = SYSTEM_REMINDER_FILE_EMPTY;
 /**
 * Format file content with line numbers (cat -n style).
@@ -738,6 +630,7 @@ function grepMatchesFromFiles(files, pattern, path$1 = null, glob$1 = null) {
 
 //#endregion
 //#region src/backends/state.ts
+init_errors();
 /**
 * Backend that stores files in shared state (ephemeral).
 *
@@ -907,15 +800,6 @@ var StateBackend = class {
 //#endregion
 //#region src/utils/eviction.ts
 /**
-* Default token limit before evicting a tool result.
-* Approximately 20,000 tokens (~80KB of text).
-*/
-const DEFAULT_EVICTION_TOKEN_LIMIT = DEFAULT_EVICTION_TOKEN_LIMIT$1;
-/**
-* Approximate characters per token (rough estimate).
-*/
-const CHARS_PER_TOKEN = 4;
-/**
 * Sanitize a tool call ID for use as a filename.
 * Removes or replaces characters that are invalid in file paths.
 */
@@ -999,12 +883,20 @@ function createToolResultWrapper(backend, state, tokenLimit = DEFAULT_EVICTION_T
 		})).content;
 	};
 }
+var DEFAULT_EVICTION_TOKEN_LIMIT, CHARS_PER_TOKEN;
+var init_eviction = require_chunk.__esmMin((() => {
+	init_limits();
+	DEFAULT_EVICTION_TOKEN_LIMIT = DEFAULT_EVICTION_TOKEN_LIMIT$1;
+	CHARS_PER_TOKEN = 4;
+}));
 
 //#endregion
 //#region src/tools/filesystem.ts
 /**
 * Filesystem tools for virtual file operations.
 */
+init_eviction();
+init_events();
 const LS_TOOL_DESCRIPTION = "List files and directories in a directory. Paths are relative to the working directory.";
 const READ_FILE_TOOL_DESCRIPTION = "Read the contents of a file. Paths are relative to the working directory.";
 const WRITE_FILE_TOOL_DESCRIPTION = "Write content to a new file. Returns an error if the file already exists. Paths are relative to the working directory.";
@@ -1327,6 +1219,16 @@ function wrapToolsWithApproval(tools, interruptOn, onApprovalRequest) {
 * Web tools for search and HTTP requests.
 * Based on LangChain DeepAgents implementation.
 */
+var web_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	createFetchUrlTool: () => createFetchUrlTool,
+	createHttpRequestTool: () => createHttpRequestTool,
+	createWebSearchTool: () => createWebSearchTool,
+	createWebTools: () => createWebTools,
+	fetch_url: () => fetch_url,
+	htmlToMarkdown: () => htmlToMarkdown,
+	http_request: () => http_request,
+	web_search: () => web_search
+});
 /**
 * Helper to resolve backend from factory or instance.
 */
@@ -1355,18 +1257,6 @@ function htmlToMarkdown(html, url) {
 	}
 }
 /**
-* Tool description for web_search.
-*/
-const WEB_SEARCH_TOOL_DESCRIPTION = `Search the web using Tavily API for current information, news, and documentation.
-
-Returns an array of search results with titles, URLs, relevant excerpts, and relevance scores.
-
-IMPORTANT AGENT INSTRUCTIONS:
-- You MUST synthesize information from search results into a coherent answer
-- NEVER show raw JSON or result objects to the user
-- Cite sources by including URLs in your response
-- If search fails or returns no results, explain this clearly to the user`;
-/**
 * Create the web_search tool.
 */
 function createWebSearchTool(state, options) {
@@ -1414,14 +1304,6 @@ function createWebSearchTool(state, options) {
 	});
 }
 /**
-* Tool description for http_request.
-*/
-const HTTP_REQUEST_TOOL_DESCRIPTION = `Make HTTP requests to APIs and web services.
-
-Supports GET, POST, PUT, DELETE, PATCH methods with custom headers, query parameters, and request bodies.
-
-Returns structured response with status code, headers, and parsed content (JSON or text).`;
-/**
 * Create the http_request tool.
 */
 function createHttpRequestTool(state, options) {
@@ -1493,19 +1375,6 @@ function createHttpRequestTool(state, options) {
 	});
 }
 /**
-* Tool description for fetch_url.
-*/
-const FETCH_URL_TOOL_DESCRIPTION = `Fetch web page content and convert HTML to clean Markdown format.
-
-Uses Mozilla Readability to extract main article content and Turndown to convert to Markdown.
-
-Returns the page content as formatted Markdown, suitable for analysis and summarization.
-
-IMPORTANT AGENT INSTRUCTIONS:
-- Use this tool to read documentation, articles, and web pages
-- The content is already cleaned and formatted as Markdown
-- Cite the URL when referencing fetched content`;
-/**
 * Create the fetch_url tool.
 */
 function createFetchUrlTool(state, options) {
@@ -1596,13 +1465,40 @@ function createWebTools(state, options) {
 		})
 	};
 }
-/**
-* Individual builtin tool references for selective subagent configuration.
-* These are references to the creator functions, not instances.
-*/
-const web_search = createWebSearchTool;
-const http_request = createHttpRequestTool;
-const fetch_url = createFetchUrlTool;
+var WEB_SEARCH_TOOL_DESCRIPTION, HTTP_REQUEST_TOOL_DESCRIPTION, FETCH_URL_TOOL_DESCRIPTION, web_search, http_request, fetch_url;
+var init_web = require_chunk.__esmMin((() => {
+	init_eviction();
+	init_errors();
+	init_limits();
+	init_events();
+	WEB_SEARCH_TOOL_DESCRIPTION = `Search the web using Tavily API for current information, news, and documentation.
+
+Returns an array of search results with titles, URLs, relevant excerpts, and relevance scores.
+
+IMPORTANT AGENT INSTRUCTIONS:
+- You MUST synthesize information from search results into a coherent answer
+- NEVER show raw JSON or result objects to the user
+- Cite sources by including URLs in your response
+- If search fails or returns no results, explain this clearly to the user`;
+	HTTP_REQUEST_TOOL_DESCRIPTION = `Make HTTP requests to APIs and web services.
+
+Supports GET, POST, PUT, DELETE, PATCH methods with custom headers, query parameters, and request bodies.
+
+Returns structured response with status code, headers, and parsed content (JSON or text).`;
+	FETCH_URL_TOOL_DESCRIPTION = `Fetch web page content and convert HTML to clean Markdown format.
+
+Uses Mozilla Readability to extract main article content and Turndown to convert to Markdown.
+
+Returns the page content as formatted Markdown, suitable for analysis and summarization.
+
+IMPORTANT AGENT INSTRUCTIONS:
+- Use this tool to read documentation, articles, and web pages
+- The content is already cleaned and formatted as Markdown
+- Cite the URL when referencing fetched content`;
+	web_search = createWebSearchTool;
+	http_request = createHttpRequestTool;
+	fetch_url = createFetchUrlTool;
+}));
 
 //#endregion
 //#region src/tools/execute.ts
@@ -1724,6 +1620,9 @@ const execute = createExecuteTool;
 /**
 * Subagent tool for task delegation using AI SDK v6 ToolLoopAgent.
 */
+init_limits();
+init_events();
+init_web();
 /**
 * Check if a value is a builtin tool creator function.
 */
@@ -2048,6 +1947,8 @@ function hasDanglingToolCalls(messages) {
 * Automatically summarizes older messages when approaching token limits
 * to prevent context overflow while preserving important context.
 */
+init_eviction();
+init_limits();
 /**
 * Default token threshold before triggering summarization.
 * 170k tokens is a safe threshold for most models.
@@ -2174,6 +2075,8 @@ function needsSummarization(messages, tokenThreshold = DEFAULT_SUMMARIZATION_THR
 /**
 * Deep Agent implementation using Vercel AI SDK v6 ToolLoopAgent.
 */
+init_limits();
+init_events();
 /**
 * Build the full system prompt from components.
 */
@@ -2264,14 +2167,21 @@ var DeepAgent = class {
 	}
 	/**
 	* Create web tools if TAVILY_API_KEY is available.
+	* Uses dynamic import to avoid bundling Node.js dependencies in client builds.
 	* @private
 	*/
 	createWebToolSet(state, onEvent) {
-		return createWebTools(state, {
-			backend: this.backend,
-			onEvent,
-			toolResultEvictionLimit: this.toolResultEvictionLimit
-		});
+		if (!process.env.TAVILY_API_KEY) return {};
+		try {
+			return (init_web(), require_chunk.__toCommonJS(web_exports)).createWebTools(state, {
+				backend: this.backend,
+				onEvent,
+				toolResultEvictionLimit: this.toolResultEvictionLimit
+			});
+		} catch (error) {
+			console.warn("Web tools not available in this environment:", error);
+			return {};
+		}
 	}
 	/**
 	* Create execute tool if backend is a sandbox.
@@ -2378,7 +2288,7 @@ var DeepAgent = class {
 	* Supports both legacy skillsDir and new agentId modes.
 	*/
 	async loadSkills(options) {
-		const { listSkills } = await Promise.resolve().then(() => require("./load-C2qVmZMp.cjs"));
+		const { listSkills } = await Promise.resolve().then(() => require("./load-DqllBbDc.cjs"));
 		this.skillsMetadata = (await listSkills(options.agentId ? { agentId: options.agentId } : { projectSkillsDir: options.skillsDir })).map((s) => ({
 			name: s.name,
 			description: s.description,
@@ -2972,6 +2882,654 @@ function createDeepAgent(params) {
 	return new DeepAgent(params);
 }
 
+//#endregion
+//#region src/backends/sandbox.ts
+init_errors();
+init_limits();
+/**
+* Encode string to base64 for safe shell transmission.
+*/
+function toBase64(str) {
+	return Buffer.from(str, "utf-8").toString("base64");
+}
+/**
+* Build a Node.js script command with embedded base64 arguments.
+* This avoids shell argument parsing issues by embedding values directly in the script.
+*/
+function buildNodeScript(script, args) {
+	let result = script;
+	for (const [key, value] of Object.entries(args)) result = result.replace(new RegExp(`__${key}__`, "g"), value);
+	return `node -e '${result}'`;
+}
+/**
+* Abstract base class for sandbox backends.
+*
+* Implements all file operations using shell commands via execute().
+* Subclasses only need to implement execute() and id.
+*
+* @example Creating a custom sandbox backend
+* ```typescript
+* class MyCloudSandbox extends BaseSandbox {
+*   readonly id = 'my-cloud-123';
+*
+*   async execute(command: string): Promise<ExecuteResponse> {
+*     // Call your cloud provider's API
+*     const result = await myCloudApi.runCommand(command);
+*     return {
+*       output: result.stdout + result.stderr,
+*       exitCode: result.exitCode,
+*       truncated: false,
+*     };
+*   }
+* }
+* ```
+*/
+var BaseSandbox = class {
+	/**
+	* List files and directories in a path.
+	*/
+	async lsInfo(path$1) {
+		const pathB64 = toBase64(path$1);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const dirPath = Buffer.from("__PATH__", "base64").toString("utf-8");
+
+try {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    try {
+      const stat = fs.statSync(fullPath);
+      console.log(JSON.stringify({
+        path: entry.name,
+        is_dir: entry.isDirectory(),
+        size: stat.size,
+        modified_at: stat.mtime.toISOString()
+      }));
+    } catch (e) {}
+  }
+} catch (e) {}
+`, { PATH: pathB64 }));
+		const infos = [];
+		for (const line of result.output.trim().split("\n")) {
+			if (!line) continue;
+			try {
+				const data = JSON.parse(line);
+				infos.push({
+					path: data.path,
+					is_dir: data.is_dir,
+					size: data.size,
+					modified_at: data.modified_at
+				});
+			} catch {}
+		}
+		return infos;
+	}
+	/**
+	* Read file content with line numbers.
+	*/
+	async read(filePath, offset = 0, limit = DEFAULT_READ_LIMIT) {
+		const pathB64 = toBase64(filePath);
+		const script = `
+const fs = require("fs");
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const offset = __OFFSET__;
+const limit = __LIMIT__;
+
+if (!fs.existsSync(filePath)) {
+  console.error("Error: File not found");
+  process.exit(1);
+}
+
+const stat = fs.statSync(filePath);
+if (stat.size === 0) {
+  console.log("${SYSTEM_REMINDER_FILE_EMPTY}");
+  process.exit(0);
+}
+
+const content = fs.readFileSync(filePath, "utf-8");
+const lines = content.split("\\n");
+const selected = lines.slice(offset, offset + limit);
+
+for (let i = 0; i < selected.length; i++) {
+  const lineNum = (offset + i + 1).toString().padStart(6, " ");
+  console.log(lineNum + "\\t" + selected[i]);
+}
+`;
+		const result = await this.execute(buildNodeScript(script, {
+			PATH: pathB64,
+			OFFSET: String(offset),
+			LIMIT: String(limit)
+		}));
+		if (result.exitCode !== 0) {
+			if (result.output.includes("Error: File not found")) return FILE_NOT_FOUND(filePath);
+			return result.output.trim();
+		}
+		return result.output.trimEnd();
+	}
+	/**
+	* Read raw file data.
+	*/
+	async readRaw(filePath) {
+		const pathB64 = toBase64(filePath);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+
+if (!fs.existsSync(filePath)) {
+  console.error("Error: File not found");
+  process.exit(1);
+}
+
+const stat = fs.statSync(filePath);
+const content = fs.readFileSync(filePath, "utf-8");
+
+console.log(JSON.stringify({
+  content: content.split("\\n"),
+  created_at: stat.birthtime.toISOString(),
+  modified_at: stat.mtime.toISOString()
+}));
+`, { PATH: pathB64 }));
+		if (result.exitCode !== 0) throw new Error(`File '${filePath}' not found`);
+		try {
+			const data = JSON.parse(result.output.trim());
+			return {
+				content: data.content,
+				created_at: data.created_at,
+				modified_at: data.modified_at
+			};
+		} catch {
+			throw new Error(`Failed to parse file data for '${filePath}'`);
+		}
+	}
+	/**
+	* Write content to a new file.
+	*/
+	async write(filePath, content) {
+		const pathB64 = toBase64(filePath);
+		const contentB64 = toBase64(content);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const content = Buffer.from("__CONTENT__", "base64").toString("utf-8");
+
+if (fs.existsSync(filePath)) {
+  console.error("Error: File already exists");
+  process.exit(1);
+}
+
+const dir = path.dirname(filePath);
+if (dir && dir !== ".") {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+fs.writeFileSync(filePath, content, "utf-8");
+`, {
+			PATH: pathB64,
+			CONTENT: contentB64
+		}));
+		if (result.exitCode !== 0) {
+			if (result.output.includes("already exists")) return {
+				success: false,
+				error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.`
+			};
+			return {
+				success: false,
+				error: result.output.trim() || `Failed to write '${filePath}'`
+			};
+		}
+		return {
+			success: true,
+			path: filePath
+		};
+	}
+	/**
+	* Edit a file by replacing string occurrences.
+	*/
+	async edit(filePath, oldString, newString, replaceAll = false) {
+		const pathB64 = toBase64(filePath);
+		const oldB64 = toBase64(oldString);
+		const newB64 = toBase64(newString);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const oldStr = Buffer.from("__OLD__", "base64").toString("utf-8");
+const newStr = Buffer.from("__NEW__", "base64").toString("utf-8");
+const replaceAll = __REPLACE_ALL__;
+
+if (!fs.existsSync(filePath)) {
+  console.error("Error: File not found");
+  process.exit(1);
+}
+
+let content = fs.readFileSync(filePath, "utf-8");
+const count = content.split(oldStr).length - 1;
+
+if (count === 0) {
+  process.exit(2);
+}
+if (count > 1 && !replaceAll) {
+  process.exit(3);
+}
+
+if (replaceAll) {
+  content = content.split(oldStr).join(newStr);
+} else {
+  content = content.replace(oldStr, newStr);
+}
+
+fs.writeFileSync(filePath, content, "utf-8");
+console.log(count);
+`, {
+			PATH: pathB64,
+			OLD: oldB64,
+			NEW: newB64,
+			REPLACE_ALL: String(replaceAll)
+		}));
+		if (result.exitCode === 1) return {
+			success: false,
+			error: FILE_NOT_FOUND(filePath)
+		};
+		if (result.exitCode === 2) return {
+			success: false,
+			error: STRING_NOT_FOUND(filePath, oldString)
+		};
+		if (result.exitCode === 3) return {
+			success: false,
+			error: `Error: String '${oldString}' appears multiple times. Use replaceAll=true to replace all occurrences.`
+		};
+		return {
+			success: true,
+			path: filePath,
+			occurrences: parseInt(result.output.trim(), 10) || 1
+		};
+	}
+	/**
+	* Search for pattern in files.
+	*/
+	async grepRaw(pattern, path$1 = "/", glob$1 = null) {
+		const patternB64 = toBase64(pattern);
+		const pathB64 = toBase64(path$1);
+		const globB64 = glob$1 ? toBase64(glob$1) : toBase64("**/*");
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const pattern = Buffer.from("__PATTERN__", "base64").toString("utf-8");
+const basePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const fileGlob = Buffer.from("__GLOB__", "base64").toString("utf-8");
+
+function walkDir(dir, baseDir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath);
+      
+      if (entry.isDirectory()) {
+        results.push(...walkDir(fullPath, baseDir));
+      } else {
+        results.push(relativePath);
+      }
+    }
+  } catch (e) {}
+  return results;
+}
+
+function matchGlob(filepath, pattern) {
+  if (!pattern || pattern === "**/*") return true;
+  const regex = pattern
+    .replace(/\\./g, "\\\\.")
+    .replace(/\\*\\*/g, "<<<GLOBSTAR>>>")
+    .replace(/\\*/g, "[^/]*")
+    .replace(/<<<GLOBSTAR>>>/g, ".*")
+    .replace(/\\?/g, ".");
+  return new RegExp("^" + regex + "$").test(filepath);
+}
+
+const allFiles = walkDir(basePath, basePath);
+const files = allFiles.filter(f => matchGlob(f, fileGlob)).sort();
+
+for (const file of files) {
+  try {
+    const fullPath = path.join(basePath, file);
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const lines = content.split("\\n");
+    
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(pattern)) {
+        console.log(JSON.stringify({
+          path: file,
+          line: i + 1,
+          text: lines[i]
+        }));
+      }
+    }
+  } catch (e) {}
+}
+`, {
+			PATTERN: patternB64,
+			PATH: pathB64,
+			GLOB: globB64
+		}));
+		const matches = [];
+		for (const line of result.output.trim().split("\n")) {
+			if (!line) continue;
+			try {
+				const data = JSON.parse(line);
+				matches.push({
+					path: data.path,
+					line: data.line,
+					text: data.text
+				});
+			} catch {}
+		}
+		return matches;
+	}
+	/**
+	* Find files matching glob pattern.
+	*/
+	async globInfo(pattern, path$1 = "/") {
+		const pathB64 = toBase64(path$1);
+		const patternB64 = toBase64(pattern);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const basePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const pattern = Buffer.from("__PATTERN__", "base64").toString("utf-8");
+
+function walkDir(dir, baseDir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath);
+      
+      if (entry.isDirectory()) {
+        results.push(...walkDir(fullPath, baseDir));
+      } else {
+        results.push(relativePath);
+      }
+    }
+  } catch (e) {}
+  return results;
+}
+
+function matchGlob(filepath, pattern) {
+  const regex = pattern
+    .replace(/\\./g, "\\\\.")
+    .replace(/\\*\\*/g, "<<<GLOBSTAR>>>")
+    .replace(/\\*/g, "[^/]*")
+    .replace(/<<<GLOBSTAR>>>/g, ".*")
+    .replace(/\\?/g, ".");
+  return new RegExp("^" + regex + "$").test(filepath);
+}
+
+const allFiles = walkDir(basePath, basePath);
+const matches = allFiles.filter(f => matchGlob(f, pattern)).sort();
+
+for (const m of matches) {
+  try {
+    const fullPath = path.join(basePath, m);
+    const stat = fs.statSync(fullPath);
+    console.log(JSON.stringify({
+      path: m,
+      is_dir: stat.isDirectory(),
+      size: stat.size,
+      modified_at: stat.mtime.toISOString()
+    }));
+  } catch (e) {}
+}
+`, {
+			PATH: pathB64,
+			PATTERN: patternB64
+		}));
+		const infos = [];
+		for (const line of result.output.trim().split("\n")) {
+			if (!line) continue;
+			try {
+				const data = JSON.parse(line);
+				infos.push({
+					path: data.path,
+					is_dir: data.is_dir,
+					size: data.size,
+					modified_at: data.modified_at
+				});
+			} catch {}
+		}
+		return infos;
+	}
+};
+
+//#endregion
+//#region src/backends/local-sandbox.ts
+/**
+* LocalSandbox: Execute commands locally using child_process.
+*
+* Useful for local development and testing without cloud sandboxes.
+* All file operations are inherited from BaseSandbox and executed
+* via shell commands in the local filesystem.
+*/
+/**
+* Local sandbox that executes commands using Node.js child_process.
+*
+* All commands are executed in a bash shell with the specified working directory.
+* Inherits all file operations (read, write, edit, ls, grep, glob) from BaseSandbox.
+*
+* @example Basic usage
+* ```typescript
+* import { LocalSandbox } from 'deepagentsdk';
+*
+* const sandbox = new LocalSandbox({ cwd: './workspace' });
+*
+* // Execute commands
+* const result = await sandbox.execute('ls -la');
+* console.log(result.output);
+*
+* // File operations
+* await sandbox.write('./src/index.ts', 'console.log("hello")');
+* const content = await sandbox.read('./src/index.ts');
+* ```
+*
+* @example With timeout and environment
+* ```typescript
+* const sandbox = new LocalSandbox({
+*   cwd: './workspace',
+*   timeout: 60000, // 60 seconds
+*   env: {
+*     NODE_ENV: 'development',
+*     DEBUG: '*',
+*   },
+* });
+* ```
+*
+* @example Error handling
+* ```typescript
+* const result = await sandbox.execute('npm test');
+* if (result.exitCode !== 0) {
+*   console.error('Tests failed:', result.output);
+* }
+* ```
+*/
+var LocalSandbox = class extends BaseSandbox {
+	cwd;
+	timeout;
+	env;
+	maxOutputSize;
+	_id;
+	/**
+	* Create a new LocalSandbox instance.
+	*
+	* @param options - Configuration options for the sandbox
+	*/
+	constructor(options = {}) {
+		super();
+		this.cwd = options.cwd || process.cwd();
+		this.timeout = options.timeout || 3e4;
+		this.env = options.env || {};
+		this.maxOutputSize = options.maxOutputSize || 1024 * 1024;
+		this._id = `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+	}
+	/**
+	* Unique identifier for this sandbox instance.
+	* Format: `local-{timestamp}-{random}`
+	*/
+	get id() {
+		return this._id;
+	}
+	/**
+	* Execute a shell command in the local filesystem.
+	*
+	* Commands are executed using bash with the configured working directory
+	* and environment variables. Output is captured from both stdout and stderr.
+	*
+	* @param command - Shell command to execute
+	* @returns ExecuteResponse with output, exit code, and truncation status
+	*
+	* @example
+	* ```typescript
+	* const result = await sandbox.execute('echo "Hello" && ls -la');
+	* console.log(result.output);
+	* console.log('Exit code:', result.exitCode);
+	* ```
+	*/
+	async execute(command) {
+		return new Promise((resolve) => {
+			const child = (0, child_process.spawn)("bash", ["-c", command], {
+				cwd: this.cwd,
+				env: {
+					...process.env,
+					...this.env
+				},
+				timeout: this.timeout
+			});
+			let output = "";
+			let truncated = false;
+			child.stdout.on("data", (data) => {
+				if (output.length < this.maxOutputSize) output += data.toString();
+				else truncated = true;
+			});
+			child.stderr.on("data", (data) => {
+				if (output.length < this.maxOutputSize) output += data.toString();
+				else truncated = true;
+			});
+			child.on("close", (code) => {
+				resolve({
+					output,
+					exitCode: code,
+					truncated
+				});
+			});
+			child.on("error", (err) => {
+				resolve({
+					output: `Error: ${err.message}`,
+					exitCode: 1,
+					truncated: false
+				});
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/model-parser.ts
+/**
+* Utility to parse model strings into LanguageModel instances.
+* Provides backward compatibility for CLI and other string-based model specifications.
+*/
+/**
+* Parse a model string into a LanguageModel instance.
+*
+* Supports formats like:
+* - "anthropic/claude-sonnet-4-20250514"
+* - "openai/gpt-4o"
+* - "claude-sonnet-4-20250514" (defaults to Anthropic)
+*
+* @param modelString - The model string to parse
+* @returns A LanguageModel instance
+*
+* @example
+* ```typescript
+* const model = parseModelString("anthropic/claude-sonnet-4-20250514");
+* const agent = createDeepAgent({ model });
+* ```
+*/
+function parseModelString(modelString) {
+	const [provider, modelName] = modelString.split("/");
+	if (provider === "anthropic") return (0, _ai_sdk_anthropic.anthropic)(modelName || "claude-sonnet-4-20250514");
+	else if (provider === "openai") return (0, _ai_sdk_openai.openai)(modelName || "gpt-5-mini");
+	return (0, _ai_sdk_anthropic.anthropic)(modelString);
+}
+
+//#endregion
+//#region src/checkpointer/file-saver.ts
+/**
+* File-based checkpoint saver for local development.
+*/
+/**
+* File-based checkpoint saver.
+* 
+* Stores checkpoints as JSON files in a directory. Each thread gets
+* its own file named `{threadId}.json`.
+* 
+* @example
+* ```typescript
+* const saver = new FileSaver({ dir: './.checkpoints' });
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   checkpointer: saver,
+* });
+* ```
+*/
+var FileSaver = class {
+	dir;
+	constructor(options) {
+		this.dir = options.dir;
+		if (!(0, node_fs.existsSync)(this.dir)) (0, node_fs.mkdirSync)(this.dir, { recursive: true });
+	}
+	getFilePath(threadId) {
+		const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+		return (0, node_path.join)(this.dir, `${safeId}.json`);
+	}
+	async save(checkpoint) {
+		const filePath = this.getFilePath(checkpoint.threadId);
+		const data = {
+			...checkpoint,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		(0, node_fs.writeFileSync)(filePath, JSON.stringify(data, null, 2), "utf-8");
+	}
+	async load(threadId) {
+		const filePath = this.getFilePath(threadId);
+		if (!(0, node_fs.existsSync)(filePath)) return;
+		try {
+			const content = (0, node_fs.readFileSync)(filePath, "utf-8");
+			return JSON.parse(content);
+		} catch {
+			return;
+		}
+	}
+	async list() {
+		if (!(0, node_fs.existsSync)(this.dir)) return [];
+		return (0, node_fs.readdirSync)(this.dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+	}
+	async delete(threadId) {
+		const filePath = this.getFilePath(threadId);
+		if ((0, node_fs.existsSync)(filePath)) (0, node_fs.unlinkSync)(filePath);
+	}
+	async exists(threadId) {
+		return (0, node_fs.existsSync)(this.getFilePath(threadId));
+	}
+};
+
 //#endregion
 Object.defineProperty(exports, 'BASE_PROMPT', {
   enumerable: true,
@@ -2979,6 +3537,12 @@ Object.defineProperty(exports, 'BASE_PROMPT', {
     return BASE_PROMPT;
   }
 });
+Object.defineProperty(exports, 'BaseSandbox', {
+  enumerable: true,
+  get: function () {
+    return BaseSandbox;
+  }
+});
 Object.defineProperty(exports, 'CONTEXT_WINDOW', {
   enumerable: true,
   get: function () {
@@ -3069,22 +3633,22 @@ Object.defineProperty(exports, 'FILE_NOT_FOUND', {
     return FILE_NOT_FOUND;
   }
 });
-Object.defineProperty(exports, 'MAX_FILE_SIZE_MB', {
+Object.defineProperty(exports, 'FileSaver', {
   enumerable: true,
   get: function () {
-    return MAX_FILE_SIZE_MB;
+    return FileSaver;
   }
 });
-Object.defineProperty(exports, 'STRING_NOT_FOUND', {
+Object.defineProperty(exports, 'LocalSandbox', {
   enumerable: true,
   get: function () {
-    return STRING_NOT_FOUND;
+    return LocalSandbox;
   }
 });
-Object.defineProperty(exports, 'SYSTEM_REMINDER_FILE_EMPTY', {
+Object.defineProperty(exports, 'MAX_FILE_SIZE_MB', {
   enumerable: true,
   get: function () {
-    return SYSTEM_REMINDER_FILE_EMPTY;
+    return MAX_FILE_SIZE_MB;
   }
 });
 Object.defineProperty(exports, 'StateBackend', {
@@ -3321,6 +3885,30 @@ Object.defineProperty(exports, 'http_request', {
     return http_request;
   }
 });
+Object.defineProperty(exports, 'init_errors', {
+  enumerable: true,
+  get: function () {
+    return init_errors;
+  }
+});
+Object.defineProperty(exports, 'init_eviction', {
+  enumerable: true,
+  get: function () {
+    return init_eviction;
+  }
+});
+Object.defineProperty(exports, 'init_limits', {
+  enumerable: true,
+  get: function () {
+    return init_limits;
+  }
+});
+Object.defineProperty(exports, 'init_web', {
+  enumerable: true,
+  get: function () {
+    return init_web;
+  }
+});
 Object.defineProperty(exports, 'isSandboxBackend', {
   enumerable: true,
   get: function () {
@@ -3339,6 +3927,12 @@ Object.defineProperty(exports, 'needsSummarization', {
     return needsSummarization;
   }
 });
+Object.defineProperty(exports, 'parseModelString', {
+  enumerable: true,
+  get: function () {
+    return parseModelString;
+  }
+});
 Object.defineProperty(exports, 'patchToolCalls', {
   enumerable: true,
   get: function () {
@@ -3393,4 +3987,4 @@ Object.defineProperty(exports, 'write_todos', {
     return write_todos;
   }
 });
-//# sourceMappingURL=agent-Cuks-Idh.cjs.map
+//# sourceMappingURL=file-saver-BYPKakT4.cjs.map