deepagentsdk 0.12.0 → 0.14.0

package/dist/{agent-CrH-He58.mjs → file-saver-Hj5so3dV.mjs}

@@ -6,139 +6,64 @@ import { tavily } from "@tavily/core";
 import TurndownService from "turndown";
 import { Readability } from "@mozilla/readability";
 import { JSDOM } from "jsdom";
+import { spawn } from "child_process";
+import { anthropic } from "@ai-sdk/anthropic";
+import { openai } from "@ai-sdk/openai";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+//#endregion
 //#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 = __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
@@ -300,6 +225,7 @@ function createCheckpointLoadedEvent(threadId, step, messagesCount) {
 		messagesCount
 	};
 }
+var init_events = __esmMin((() => {}));
 
 //#endregion
 //#region src/types/backend.ts
@@ -496,6 +422,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 = z.object({
 	id: z.string().describe("Unique identifier for the todo item"),
 	content: z.string().max(100).describe("The description/content of the todo item (max 100 chars)"),
@@ -554,23 +481,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) => `Error: File '${path}' not found`;
-const FILE_ALREADY_EXISTS = (path) => `Cannot write to ${path} because it already exists. Read and then make an edit, or write to a new path.`;
-const STRING_NOT_FOUND = (path, string) => `Error: String not found in file: '${path}'\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 = __esmMin((() => {
+	FILE_NOT_FOUND = (path) => `Error: File '${path}' not found`;
+	FILE_ALREADY_EXISTS = (path) => `Cannot write to ${path} because it already exists. Read and then make an edit, or write to a new path.`;
+	STRING_NOT_FOUND = (path, string) => `Error: String not found in file: '${path}'\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).
@@ -735,6 +663,7 @@ function grepMatchesFromFiles(files, pattern, path = null, glob$1 = null) {
 
 //#endregion
 //#region src/backends/state.ts
+init_errors();
 /**
 * Backend that stores files in shared state (ephemeral).
 *
@@ -904,15 +833,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.
 */
@@ -996,12 +916,20 @@ function createToolResultWrapper(backend, state, tokenLimit = DEFAULT_EVICTION_T
 		})).content;
 	};
 }
+var DEFAULT_EVICTION_TOKEN_LIMIT, CHARS_PER_TOKEN;
+var init_eviction = __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.";
@@ -1324,6 +1252,16 @@ function wrapToolsWithApproval(tools, interruptOn, onApprovalRequest) {
 * Web tools for search and HTTP requests.
 * Based on LangChain DeepAgents implementation.
 */
+var web_exports = /* @__PURE__ */ __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.
 */
@@ -1352,18 +1290,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) {
@@ -1411,14 +1337,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) {
@@ -1490,19 +1408,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) {
@@ -1593,13 +1498,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 = __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
@@ -1721,6 +1653,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.
 */
@@ -2045,6 +1980,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.
@@ -2171,6 +2108,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.
 */
@@ -2261,14 +2200,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(), __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.
@@ -2375,7 +2321,7 @@ var DeepAgent = class {
 	* Supports both legacy skillsDir and new agentId modes.
 	*/
 	async loadSkills(options) {
-		const { listSkills } = await import("./load-94gjHorc.mjs");
+		const { listSkills } = await import("./load-BDxe6Cet.mjs");
 		this.skillsMetadata = (await listSkills(options.agentId ? { agentId: options.agentId } : { projectSkillsDir: options.skillsDir })).map((s) => ({
 			name: s.name,
 			description: s.description,
@@ -2970,5 +2916,653 @@ function createDeepAgent(params) {
 }
 
 //#endregion
-export { SYSTEM_REMINDER_FILE_EMPTY as $, glob as A, StateBackend as B, createFilesystemTools as C, createReadFileTool as D, createLsTool as E, DEFAULT_EVICTION_TOKEN_LIMIT as F, formatReadResponse as G, createFileData as H, createToolResultWrapper as I, performStringReplacement as J, globSearchFiles as K, estimateTokens as L, ls as M, read_file as N, createWriteFileTool as O, write_file as P, STRING_NOT_FOUND as Q, evictToolResult as R, createEditFileTool as S, createGrepTool as T, fileDataToString as U, checkEmptyContent as V, formatContentWithLineNumbers as W, FILE_ALREADY_EXISTS as X, updateFileData as Y, FILE_NOT_FOUND as Z, createWebTools as _, estimateMessagesTokens as a, EXECUTE_SYSTEM_PROMPT as at, http_request as b, hasDanglingToolCalls as c, TODO_SYSTEM_PROMPT as ct, createExecuteTool as d, CONTEXT_WINDOW as dt, createTodosTool as et, createExecuteToolFromBackend as f, DEFAULT_EVICTION_TOKEN_LIMIT$1 as ft, createWebSearchTool as g, MAX_FILE_SIZE_MB as gt, createHttpRequestTool as h, DEFAULT_SUMMARIZATION_THRESHOLD$1 as ht, DEFAULT_SUMMARIZATION_THRESHOLD as i, DEFAULT_SUBAGENT_PROMPT as it, grep as j, edit_file as k, patchToolCalls as l, getTaskToolDescription as lt, createFetchUrlTool as m, DEFAULT_READ_LIMIT as mt, createDeepAgent as n, BASE_PROMPT as nt, needsSummarization as o, FILESYSTEM_SYSTEM_PROMPT as ot, execute as p, DEFAULT_KEEP_MESSAGES$1 as pt, grepMatchesFromFiles as q, DEFAULT_KEEP_MESSAGES as r, DEFAULT_GENERAL_PURPOSE_DESCRIPTION as rt, summarizeIfNeeded as s, TASK_SYSTEM_PROMPT as st, DeepAgent as t, write_todos as tt, createSubagentTool as u, isSandboxBackend as ut, fetch_url as v, createGlobTool as w, web_search as x, htmlToMarkdown as y, shouldEvict as z };
-//# sourceMappingURL=agent-CrH-He58.mjs.map
+//#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) {
+		const pathB64 = toBase64(path);
+		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 = "/", glob$1 = null) {
+		const patternB64 = toBase64(pattern);
+		const pathB64 = toBase64(path);
+		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 = "/") {
+		const pathB64 = toBase64(path);
+		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 = 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 anthropic(modelName || "claude-sonnet-4-20250514");
+	else if (provider === "openai") return openai(modelName || "gpt-5-mini");
+	return 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 (!existsSync(this.dir)) mkdirSync(this.dir, { recursive: true });
+	}
+	getFilePath(threadId) {
+		const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+		return join(this.dir, `${safeId}.json`);
+	}
+	async save(checkpoint) {
+		const filePath = this.getFilePath(checkpoint.threadId);
+		const data = {
+			...checkpoint,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+	}
+	async load(threadId) {
+		const filePath = this.getFilePath(threadId);
+		if (!existsSync(filePath)) return;
+		try {
+			const content = readFileSync(filePath, "utf-8");
+			return JSON.parse(content);
+		} catch {
+			return;
+		}
+	}
+	async list() {
+		if (!existsSync(this.dir)) return [];
+		return readdirSync(this.dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+	}
+	async delete(threadId) {
+		const filePath = this.getFilePath(threadId);
+		if (existsSync(filePath)) unlinkSync(filePath);
+	}
+	async exists(threadId) {
+		return existsSync(this.getFilePath(threadId));
+	}
+};
+
+//#endregion
+export { grepMatchesFromFiles as $, createGrepTool as A, DEFAULT_EVICTION_TOKEN_LIMIT as B, htmlToMarkdown as C, createEditFileTool as D, web_search as E, glob as F, shouldEvict as G, estimateTokens as H, grep as I, createFileData as J, StateBackend as K, ls as L, createReadFileTool as M, createWriteFileTool as N, createFilesystemTools as O, edit_file as P, globSearchFiles as Q, read_file as R, fetch_url as S, init_limits as St, init_web as T, evictToolResult as U, createToolResultWrapper as V, init_eviction as W, formatContentWithLineNumbers as X, fileDataToString as Y, formatReadResponse as Z, execute as _, DEFAULT_EVICTION_TOKEN_LIMIT$1 as _t, DeepAgent as a, createTodosTool as at, createWebSearchTool as b, DEFAULT_SUMMARIZATION_THRESHOLD$1 as bt, DEFAULT_SUMMARIZATION_THRESHOLD as c, DEFAULT_GENERAL_PURPOSE_DESCRIPTION as ct, summarizeIfNeeded as d, FILESYSTEM_SYSTEM_PROMPT as dt, performStringReplacement as et, hasDanglingToolCalls as f, TASK_SYSTEM_PROMPT as ft, createExecuteToolFromBackend as g, CONTEXT_WINDOW as gt, createExecuteTool as h, isSandboxBackend as ht, BaseSandbox as i, init_errors as it, createLsTool as j, createGlobTool as k, estimateMessagesTokens as l, DEFAULT_SUBAGENT_PROMPT as lt, createSubagentTool as m, getTaskToolDescription as mt, parseModelString as n, FILE_ALREADY_EXISTS as nt, createDeepAgent as o, write_todos as ot, patchToolCalls as p, TODO_SYSTEM_PROMPT as pt, checkEmptyContent as q, LocalSandbox as r, FILE_NOT_FOUND as rt, DEFAULT_KEEP_MESSAGES as s, BASE_PROMPT as st, FileSaver as t, updateFileData as tt, needsSummarization as u, EXECUTE_SYSTEM_PROMPT as ut, createFetchUrlTool as v, DEFAULT_KEEP_MESSAGES$1 as vt, http_request as w, createWebTools as x, MAX_FILE_SIZE_MB as xt, createHttpRequestTool as y, DEFAULT_READ_LIMIT as yt, write_file as z };
+//# sourceMappingURL=file-saver-Hj5so3dV.mjs.map