deepagentsdk 0.11.1 → 0.13.0

package/dist/file-saver-BYPKakT4.cjs

@@ -0,0 +1,3990 @@
+const require_chunk = require('./chunk-C5azi7Hr.cjs');
+let ai = require("ai");
+let zod = require("zod");
+let micromatch = require("micromatch");
+micromatch = require_chunk.__toESM(micromatch);
+let path = require("path");
+let _tavily_core = require("@tavily/core");
+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
+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
+/**
+* Create a todos-changed event.
+*/
+function createTodosChangedEvent(todos) {
+	return {
+		type: "todos-changed",
+		todos
+	};
+}
+/**
+* Create a file-write-start event (preview before write).
+*/
+function createFileWriteStartEvent(path$1, content) {
+	return {
+		type: "file-write-start",
+		path: path$1,
+		content
+	};
+}
+/**
+* Create a file-written event (after successful write).
+*/
+function createFileWrittenEvent(path$1, content) {
+	return {
+		type: "file-written",
+		path: path$1,
+		content
+	};
+}
+/**
+* Create a file-edited event.
+*/
+function createFileEditedEvent(path$1, occurrences) {
+	return {
+		type: "file-edited",
+		path: path$1,
+		occurrences
+	};
+}
+/**
+* Create a file-read event.
+*/
+function createFileReadEvent(path$1, lines) {
+	return {
+		type: "file-read",
+		path: path$1,
+		lines
+	};
+}
+/**
+* Create a web-search-start event.
+*/
+function createWebSearchStartEvent(query) {
+	return {
+		type: "web-search-start",
+		query
+	};
+}
+/**
+* Create a web-search-finish event.
+*/
+function createWebSearchFinishEvent(query, resultCount) {
+	return {
+		type: "web-search-finish",
+		query,
+		resultCount
+	};
+}
+/**
+* Create an http-request-start event.
+*/
+function createHttpRequestStartEvent(url, method) {
+	return {
+		type: "http-request-start",
+		url,
+		method
+	};
+}
+/**
+* Create an http-request-finish event.
+*/
+function createHttpRequestFinishEvent(url, statusCode) {
+	return {
+		type: "http-request-finish",
+		url,
+		statusCode
+	};
+}
+/**
+* Create a fetch-url-start event.
+*/
+function createFetchUrlStartEvent(url) {
+	return {
+		type: "fetch-url-start",
+		url
+	};
+}
+/**
+* Create a fetch-url-finish event.
+*/
+function createFetchUrlFinishEvent(url, success) {
+	return {
+		type: "fetch-url-finish",
+		url,
+		success
+	};
+}
+/**
+* Create a subagent-start event.
+*/
+function createSubagentStartEvent(name, task) {
+	return {
+		type: "subagent-start",
+		name,
+		task
+	};
+}
+/**
+* Create a subagent-finish event.
+*/
+function createSubagentFinishEvent(name, result) {
+	return {
+		type: "subagent-finish",
+		name,
+		result
+	};
+}
+/**
+* Create a subagent-step event.
+*/
+function createSubagentStepEvent(stepIndex, toolCalls) {
+	return {
+		type: "subagent-step",
+		stepIndex,
+		toolCalls
+	};
+}
+/**
+* Create a checkpoint-saved event.
+*/
+function createCheckpointSavedEvent(threadId, step) {
+	return {
+		type: "checkpoint-saved",
+		threadId,
+		step
+	};
+}
+/**
+* Create a checkpoint-loaded event.
+*/
+function createCheckpointLoadedEvent(threadId, step, messagesCount) {
+	return {
+		type: "checkpoint-loaded",
+		threadId,
+		step,
+		messagesCount
+	};
+}
+var init_events = require_chunk.__esmMin((() => {}));
+
+//#endregion
+//#region src/types/backend.ts
+/**
+* Type guard to check if a backend is a SandboxBackendProtocol.
+*/
+function isSandboxBackend(backend) {
+	return typeof backend.execute === "function" && typeof backend.id === "string";
+}
+
+//#endregion
+//#region src/prompts.ts
+/**
+* System prompts for Deep Agent.
+*/
+const BASE_PROMPT = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
+const TODO_SYSTEM_PROMPT = `## \`write_todos\` (task planning)
+
+You have access to a \`write_todos\` tool to help you manage and plan tasks. Use this tool whenever you are working on a complex task.
+
+### When to Use This Tool
+
+Use proactively for:
+1. Complex multi-step tasks (3+ distinct steps)
+2. Non-trivial tasks requiring careful planning
+3. After receiving new instructions - capture requirements as todos
+4. After completing tasks - mark complete and add follow-ups
+5. When starting new tasks - mark as in_progress (ideally only one at a time)
+
+### When NOT to Use
+
+Skip for:
+1. Single, straightforward tasks
+2. Trivial tasks with no organizational benefit
+3. Tasks completable in < 3 trivial steps
+4. Purely conversational/informational requests
+
+### Task States and Management
+
+1. **Task States:**
+  - pending: Not yet started
+  - in_progress: Currently working on
+  - completed: Finished successfully
+  - cancelled: No longer needed
+
+2. **Task Management:**
+  - Update status in real-time
+  - Mark complete IMMEDIATELY after finishing
+  - Only ONE task in_progress at a time
+  - Complete current tasks before starting new ones`;
+const FILESYSTEM_SYSTEM_PROMPT = `## Virtual Filesystem
+
+You have access to a virtual filesystem. All file paths must start with a /.
+
+- ls: list files in a directory (requires absolute path)
+- read_file: read a file from the filesystem
+- write_file: write to a file in the filesystem
+- edit_file: edit a file in the filesystem
+- glob: find files matching a pattern (e.g., "**/*.py")
+- grep: search for text within files`;
+const TASK_SYSTEM_PROMPT = `## \`task\` (subagent spawner)
+
+You have access to a \`task\` tool to launch short-lived subagents that handle isolated tasks. These agents are ephemeral — they live only for the duration of the task and return a single result.
+
+When to use the task tool:
+- When a task is complex and multi-step, and can be fully delegated in isolation
+- When a task is independent of other tasks and can run in parallel
+- When a task requires focused reasoning or heavy token/context usage that would bloat the orchestrator thread
+- When sandboxing improves reliability (e.g. code execution, structured searches, data formatting)
+- When you only care about the output of the subagent, and not the intermediate steps
+
+Subagent lifecycle:
+1. **Spawn** → Provide clear role, instructions, and expected output
+2. **Run** → The subagent completes the task autonomously
+3. **Return** → The subagent provides a single structured result
+4. **Reconcile** → Incorporate or synthesize the result into the main thread
+
+When NOT to use the task tool:
+- If you need to see the intermediate reasoning or steps after the subagent has completed (the task tool hides them)
+- If the task is trivial (a few tool calls or simple lookup)
+- If delegating does not reduce token usage, complexity, or context switching
+- If splitting would add latency without benefit
+
+## Important Task Tool Usage Notes
+- Whenever possible, parallelize the work that you do. Whenever you have independent steps to complete - kick off tasks (subagents) in parallel to accomplish them faster.
+- Remember to use the \`task\` tool to silo independent tasks within a multi-part objective.
+- You should use the \`task\` tool whenever you have a complex task that will take multiple steps, and is independent from other tasks that the agent needs to complete.`;
+/**
+* Get the task tool description with available subagent types.
+*/
+function getTaskToolDescription(subagentDescriptions) {
+	return `
+Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
+
+Available agent types and the tools they have access to:
+${subagentDescriptions.join("\n")}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+## Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+7. When only the general-purpose agent is provided, you should use it for all tasks. It is great for isolating context and token usage, and completing specific, complex tasks, as it has all the same capabilities as the main agent.
+
+### Example usage of the general-purpose agent:
+
+<example_agent_descriptions>
+"general-purpose": use this agent for general purpose tasks, it has access to all tools as the main agent.
+</example_agent_descriptions>
+
+<example>
+User: "I want to conduct research on the accomplishments of Lebron James, Michael Jordan, and Kobe Bryant, and then compare them."
+Assistant: *Uses the task tool in parallel to conduct isolated research on each of the three players*
+Assistant: *Synthesizes the results of the three isolated research tasks and responds to the User*
+<commentary>
+Research is a complex, multi-step task in it of itself.
+The research of each individual player is not dependent on the research of the other players.
+The assistant uses the task tool to break down the complex objective into three isolated tasks.
+Each research task only needs to worry about context and tokens about one player, then returns synthesized information about each player as the Tool Result.
+This means each research task can dive deep and spend tokens and context deeply researching each player, but the final result is synthesized information, and saves us tokens in the long run when comparing the players to each other.
+</commentary>
+</example>
+
+<example>
+User: "Analyze a single large code repository for security vulnerabilities and generate a report."
+Assistant: *Launches a single \`task\` subagent for the repository analysis*
+Assistant: *Receives report and integrates results into final summary*
+<commentary>
+Subagent is used to isolate a large, context-heavy task, even though there is only one. This prevents the main thread from being overloaded with details.
+If the user then asks followup questions, we have a concise report to reference instead of the entire history of analysis and tool calls, which is good and saves us time and money.
+</commentary>
+</example>
+  `.trim();
+}
+const DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
+const DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
+const EXECUTE_SYSTEM_PROMPT = `## \`execute\` (shell command execution)
+
+You have access to an \`execute\` tool to run shell commands in the sandbox environment.
+
+### When to Use This Tool
+
+Use for:
+- Running build commands (npm install, npm run build, bun install)
+- Running tests (npm test, bun test, pytest)
+- Executing scripts (node script.js, python script.py)
+- Installing dependencies
+- Checking system state (ls, cat, pwd, which)
+- Any shell command that helps accomplish the task
+
+### Important Notes
+
+1. **Exit Codes**: Always check the exit code to determine success
+   - 0 = success
+   - non-zero = failure
+   - null = possibly timed out
+
+2. **Command Chaining**:
+   - Use \`&&\` to chain commands that depend on each other
+   - Use \`;\` to run commands sequentially regardless of success
+
+3. **Timeouts**: Long-running commands may timeout
+
+4. **Working Directory**: Commands run in the sandbox's working directory`;
+/**
+* Build skills section for system prompt with progressive disclosure.
+*/
+function buildSkillsPrompt(skills) {
+	if (skills.length === 0) return "";
+	return `## Skills System
+
+You have access to a skills library providing specialized domain knowledge and workflows.
+
+**Available Skills:**
+
+${skills.map((skill) => `- **${skill.name}**: ${skill.description}\n  → Read \`${skill.path}\` for full instructions`).join("\n")}
+
+**How to Use Skills (Progressive Disclosure):**
+
+1. **Recognize when a skill applies**: Check if the user's task matches any skill's domain
+2. **Read the skill's full instructions**: Use read_file to load the SKILL.md content
+3. **Follow the skill's workflow**: Skills contain step-by-step instructions and examples
+4. **Access supporting files**: Skills may include helper scripts or configuration files in their directory
+
+Skills provide expert knowledge for specialized tasks. Always read the full skill before using it.`;
+}
+
+//#endregion
+//#region src/tools/todos.ts
+/**
+* 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)"),
+	status: zod.z.enum([
+		"pending",
+		"in_progress",
+		"completed",
+		"cancelled"
+	]).describe("The current status of the todo item")
+});
+/**
+* Create the write_todos tool for task planning.
+* @param state - The shared agent state
+* @param onEvent - Optional callback for emitting events
+*/
+function createTodosTool(state, onEvent) {
+	return (0, ai.tool)({
+		description: `Manage and plan tasks using a structured todo list. Use this tool for:
+- Complex multi-step tasks (3+ steps)
+- After receiving new instructions - capture requirements
+- When starting tasks - mark as in_progress (only one at a time)
+- After completing tasks - mark complete immediately
+
+Task states: pending, in_progress, completed, cancelled
+
+When merge=true, updates are merged with existing todos by id.
+When merge=false, the new todos replace all existing todos.`,
+		inputSchema: zod.z.object({
+			todos: zod.z.array(TodoItemSchema).min(1).describe("Array of todo items to write"),
+			merge: zod.z.boolean().default(true).describe("Whether to merge with existing todos (true) or replace all (false)")
+		}),
+		execute: async ({ todos, merge }) => {
+			if (merge) {
+				const existingMap = /* @__PURE__ */ new Map();
+				for (const todo of state.todos) existingMap.set(todo.id, todo);
+				for (const newTodo of todos) {
+					const existing = existingMap.get(newTodo.id);
+					if (existing) existingMap.set(newTodo.id, {
+						...existing,
+						...newTodo
+					});
+					else existingMap.set(newTodo.id, newTodo);
+				}
+				state.todos = Array.from(existingMap.values());
+			} else state.todos = todos;
+			if (onEvent) onEvent(createTodosChangedEvent([...state.todos]));
+			return `Todo list updated successfully.\n\nCurrent todos:\n${state.todos.map((t) => `- [${t.status}] ${t.id}: ${t.content}`).join("\n")}`;
+		}
+	});
+}
+/**
+* Individual builtin tool reference for selective subagent configuration.
+* This is a reference to the creator function, not an instance.
+*/
+const write_todos = createTodosTool;
+
+//#endregion
+//#region src/constants/errors.ts
+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).
+*/
+function formatContentWithLineNumbers(content, startLine = 1) {
+	let lines;
+	if (typeof content === "string") {
+		lines = content.split("\n");
+		if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
+	} else lines = content;
+	const resultLines = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const lineNum = i + startLine;
+		if (line && line.length <= MAX_LINE_LENGTH) resultLines.push(`${lineNum.toString().padStart(LINE_NUMBER_WIDTH)}\t${line}`);
+		else if (line) {
+			const numChunks = Math.ceil(line.length / MAX_LINE_LENGTH);
+			for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+				const start = chunkIdx * MAX_LINE_LENGTH;
+				const end = Math.min(start + MAX_LINE_LENGTH, line.length);
+				const chunk = line.substring(start, end);
+				if (chunkIdx === 0) resultLines.push(`${lineNum.toString().padStart(LINE_NUMBER_WIDTH)}\t${chunk}`);
+				else {
+					const continuationMarker = `${lineNum}.${chunkIdx}`;
+					resultLines.push(`${continuationMarker.padStart(LINE_NUMBER_WIDTH)}\t${chunk}`);
+				}
+			}
+		} else resultLines.push(`${lineNum.toString().padStart(LINE_NUMBER_WIDTH)}\t`);
+	}
+	return resultLines.join("\n");
+}
+/**
+* Check if content is empty and return warning message.
+*/
+function checkEmptyContent(content) {
+	if (!content || content.trim() === "") return EMPTY_CONTENT_WARNING;
+	return null;
+}
+/**
+* Convert FileData to plain string content.
+*/
+function fileDataToString(fileData) {
+	return fileData.content.join("\n");
+}
+/**
+* Create a FileData object with timestamps.
+*/
+function createFileData(content, createdAt) {
+	const lines = typeof content === "string" ? content.split("\n") : content;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		content: lines,
+		created_at: createdAt || now,
+		modified_at: now
+	};
+}
+/**
+* Update FileData with new content, preserving creation timestamp.
+*/
+function updateFileData(fileData, content) {
+	const lines = typeof content === "string" ? content.split("\n") : content;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		content: lines,
+		created_at: fileData.created_at,
+		modified_at: now
+	};
+}
+/**
+* Format file data for read response with line numbers.
+*/
+function formatReadResponse(fileData, offset, limit) {
+	const content = fileDataToString(fileData);
+	const emptyMsg = 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 formatContentWithLineNumbers(lines.slice(startIdx, endIdx), startIdx + 1);
+}
+/**
+* Perform string replacement with occurrence validation.
+*/
+function performStringReplacement(content, oldString, newString, replaceAll) {
+	const occurrences = content.split(oldString).length - 1;
+	if (occurrences === 0) return `Error: String not found in file: '${oldString}'`;
+	if (occurrences > 1 && !replaceAll) return `Error: String '${oldString}' appears ${occurrences} times in file. Use replace_all=true to replace all instances, or provide a more specific string with surrounding context.`;
+	return [content.split(oldString).join(newString), occurrences];
+}
+/**
+* Validate and normalize a path.
+*/
+function validatePath(path$1) {
+	const pathStr = path$1 || "/";
+	if (!pathStr || pathStr.trim() === "") throw new Error("Path cannot be empty");
+	let normalized = pathStr.startsWith("/") ? pathStr : "/" + pathStr;
+	if (!normalized.endsWith("/")) normalized += "/";
+	return normalized;
+}
+/**
+* Search files dict for paths matching glob pattern.
+*/
+function globSearchFiles(files, pattern, path$1 = "/") {
+	let normalizedPath;
+	try {
+		normalizedPath = validatePath(path$1);
+	} catch {
+		return "No files found";
+	}
+	const filtered = Object.fromEntries(Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath)));
+	const matches = [];
+	for (const [filePath, fileData] of Object.entries(filtered)) {
+		let relative = filePath.substring(normalizedPath.length);
+		if (relative.startsWith("/")) relative = relative.substring(1);
+		if (!relative) {
+			const parts = filePath.split("/");
+			relative = parts[parts.length - 1] || "";
+		}
+		if (micromatch.default.isMatch(relative, pattern, {
+			dot: true,
+			nobrace: false
+		})) matches.push([filePath, fileData.modified_at]);
+	}
+	matches.sort((a, b) => b[1].localeCompare(a[1]));
+	if (matches.length === 0) return "No files found";
+	return matches.map(([fp]) => fp).join("\n");
+}
+/**
+* Return structured grep matches from an in-memory files mapping.
+*/
+function grepMatchesFromFiles(files, pattern, path$1 = null, glob$1 = null) {
+	let regex;
+	try {
+		regex = new RegExp(pattern);
+	} catch (e) {
+		return INVALID_REGEX(e.message);
+	}
+	let normalizedPath;
+	try {
+		normalizedPath = validatePath(path$1);
+	} catch {
+		return [];
+	}
+	let filtered = Object.fromEntries(Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath)));
+	if (glob$1) filtered = Object.fromEntries(Object.entries(filtered).filter(([fp]) => micromatch.default.isMatch((0, path.basename)(fp), glob$1, {
+		dot: true,
+		nobrace: false
+	})));
+	const matches = [];
+	for (const [filePath, fileData] of Object.entries(filtered)) for (let i = 0; i < fileData.content.length; i++) {
+		const line = fileData.content[i];
+		const lineNum = i + 1;
+		if (line && regex.test(line)) matches.push({
+			path: filePath,
+			line: lineNum,
+			text: line
+		});
+	}
+	return matches;
+}
+
+//#endregion
+//#region src/backends/state.ts
+init_errors();
+/**
+* Backend that stores files in shared state (ephemeral).
+*
+* Files persist within a single agent invocation but not across invocations.
+* This is the default backend for Deep Agent when no backend is specified.
+*
+* Files are stored in memory as part of the `DeepAgentState`, making this backend
+* fast but non-persistent. Use `FilesystemBackend` or `PersistentBackend` for
+* cross-session persistence.
+*
+* @example Default usage (no backend specified)
+* ```typescript
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   // StateBackend is used by default
+* });
+* ```
+*
+* @example Explicit usage
+* ```typescript
+* const state: DeepAgentState = { todos: [], files: {} };
+* const backend = new StateBackend(state);
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend,
+* });
+* ```
+*/
+var StateBackend = class {
+	state;
+	/**
+	* Create a new StateBackend instance.
+	*
+	* @param state - The DeepAgentState object that will store the files.
+	*                Files are stored in `state.files` as a Record<string, FileData>.
+	*/
+	constructor(state) {
+		this.state = state;
+	}
+	/**
+	* Get files from current state.
+	*/
+	getFiles() {
+		return this.state.files || {};
+	}
+	/**
+	* List files and directories in the specified directory (non-recursive).
+	*/
+	lsInfo(path$1) {
+		const files = this.getFiles();
+		const infos = [];
+		const subdirs = /* @__PURE__ */ new Set();
+		const normalizedPath = path$1.endsWith("/") ? path$1 : path$1 + "/";
+		for (const [k, fd] of Object.entries(files)) {
+			if (!k.startsWith(normalizedPath)) continue;
+			const relative = k.substring(normalizedPath.length);
+			if (relative.includes("/")) {
+				const subdirName = relative.split("/")[0];
+				subdirs.add(normalizedPath + subdirName + "/");
+				continue;
+			}
+			const size = fd.content.join("\n").length;
+			infos.push({
+				path: k,
+				is_dir: false,
+				size,
+				modified_at: fd.modified_at
+			});
+		}
+		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.
+	*/
+	read(filePath, offset = 0, limit = 2e3) {
+		const fileData = this.getFiles()[filePath];
+		if (!fileData) return FILE_NOT_FOUND(filePath);
+		return formatReadResponse(fileData, offset, limit);
+	}
+	/**
+	* Read file content as raw FileData.
+	*/
+	readRaw(filePath) {
+		const fileData = this.getFiles()[filePath];
+		if (!fileData) throw new Error(`File '${filePath}' not found`);
+		return fileData;
+	}
+	/**
+	* Create a new file with content.
+	*/
+	write(filePath, content) {
+		const files = this.getFiles();
+		if (!filePath || filePath.trim() === "") return {
+			success: false,
+			error: "File path cannot be empty"
+		};
+		if (filePath in files) return {
+			success: false,
+			error: FILE_ALREADY_EXISTS(filePath)
+		};
+		const newFileData = createFileData(content);
+		this.state.files[filePath] = newFileData;
+		return {
+			success: true,
+			path: filePath
+		};
+	}
+	/**
+	* Edit a file by replacing string occurrences.
+	*/
+	edit(filePath, oldString, newString, replaceAll = false) {
+		const fileData = this.getFiles()[filePath];
+		if (!fileData) return {
+			success: false,
+			error: FILE_NOT_FOUND(filePath)
+		};
+		const result = performStringReplacement(fileDataToString(fileData), oldString, newString, replaceAll);
+		if (typeof result === "string") return {
+			success: false,
+			error: result
+		};
+		const [newContent, occurrences] = result;
+		const newFileData = updateFileData(fileData, newContent);
+		this.state.files[filePath] = newFileData;
+		return {
+			success: true,
+			path: filePath,
+			occurrences
+		};
+	}
+	/**
+	* Structured search results or error string for invalid input.
+	*/
+	grepRaw(pattern, path$1 = "/", glob$1 = null) {
+		return grepMatchesFromFiles(this.getFiles(), pattern, path$1, glob$1);
+	}
+	/**
+	* Structured glob matching returning FileInfo objects.
+	*/
+	globInfo(pattern, path$1 = "/") {
+		const files = this.getFiles();
+		const result = 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;
+	}
+};
+
+//#endregion
+//#region src/utils/eviction.ts
+/**
+* Sanitize a tool call ID for use as a filename.
+* Removes or replaces characters that are invalid in file paths.
+*/
+function sanitizeToolCallId(toolCallId) {
+	return toolCallId.replace(/[^a-zA-Z0-9_-]/g, "_").substring(0, 100);
+}
+/**
+* Estimate the number of tokens in a string.
+* Uses a simple character-based approximation.
+*/
+function estimateTokens(text) {
+	return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+/**
+* Check if a tool result should be evicted based on size.
+*/
+function shouldEvict(result, tokenLimit = DEFAULT_EVICTION_TOKEN_LIMIT) {
+	return estimateTokens(result) > tokenLimit;
+}
+/**
+* Evict a large tool result to the filesystem.
+*
+* If the result exceeds the token limit, writes it to a file and
+* returns a truncated message with the file path.
+*
+* @param options - Eviction options
+* @returns Eviction result with content and metadata
+*
+* @example
+* ```typescript
+* const result = await evictToolResult({
+*   result: veryLongString,
+*   toolCallId: "call_123",
+*   toolName: "grep",
+*   backend: filesystemBackend,
+* });
+*
+* if (result.evicted) {
+*   console.log(`Content saved to ${result.evictedPath}`);
+* }
+* ```
+*/
+async function evictToolResult(options) {
+	const { result, toolCallId, toolName, backend, tokenLimit = DEFAULT_EVICTION_TOKEN_LIMIT } = options;
+	if (!shouldEvict(result, tokenLimit)) return {
+		evicted: false,
+		content: result
+	};
+	const evictPath = `/large_tool_results/${toolName}_${sanitizeToolCallId(toolCallId)}.txt`;
+	const writeResult = await backend.write(evictPath, result);
+	if (writeResult.error) {
+		console.warn(`Failed to evict tool result: ${writeResult.error}`);
+		return {
+			evicted: false,
+			content: result
+		};
+	}
+	return {
+		evicted: true,
+		content: `Tool result too large (~${estimateTokens(result)} tokens). Content saved to ${evictPath}. Use read_file to access the full content.`,
+		evictedPath: evictPath
+	};
+}
+/**
+* Create a tool result wrapper that automatically evicts large results.
+*
+* @param backend - Backend or factory for filesystem operations
+* @param state - Current agent state (for factory backends)
+* @param tokenLimit - Token limit before eviction
+* @returns Function that wraps tool results with eviction
+*/
+function createToolResultWrapper(backend, state, tokenLimit = DEFAULT_EVICTION_TOKEN_LIMIT) {
+	const resolvedBackend = typeof backend === "function" ? backend(state) : backend;
+	return async (result, toolCallId, toolName) => {
+		return (await evictToolResult({
+			result,
+			toolCallId,
+			toolName,
+			backend: resolvedBackend,
+			tokenLimit
+		})).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.";
+const EDIT_FILE_TOOL_DESCRIPTION = "Edit a file by replacing a specific string with a new string. Paths are relative to the working directory.";
+const GLOB_TOOL_DESCRIPTION = "Find files matching a glob pattern (e.g., '**/*.py' for all Python files). Paths are relative to the working directory.";
+const GREP_TOOL_DESCRIPTION = "Search for a regex pattern in files. Returns matching files and line numbers. Paths are relative to the working directory.";
+/**
+* Resolve backend from factory or instance.
+*/
+function getBackend$1(backend, state) {
+	if (typeof backend === "function") return backend(state);
+	return backend;
+}
+/**
+* Create the ls tool.
+*/
+function createLsTool(state, backend, onEvent) {
+	return (0, ai.tool)({
+		description: LS_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({ path: zod.z.string().default(".").describe("Directory path to list (default: current directory)") }),
+		execute: async ({ path: path$1 }) => {
+			const infos = await getBackend$1(backend, state).lsInfo(path$1 || ".");
+			if (onEvent) onEvent({
+				type: "ls",
+				path: path$1 || ".",
+				count: infos.length
+			});
+			if (infos.length === 0) return `No files found in ${path$1}`;
+			const lines = [];
+			for (const info of infos) if (info.is_dir) lines.push(`${info.path} (directory)`);
+			else {
+				const size = info.size ? ` (${info.size} bytes)` : "";
+				lines.push(`${info.path}${size}`);
+			}
+			return lines.join("\n");
+		}
+	});
+}
+/**
+* Create the read_file tool.
+*/
+function createReadFileTool(state, backend, evictionLimit, onEvent) {
+	return (0, ai.tool)({
+		description: READ_FILE_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			file_path: zod.z.string().describe("Path to the file to read (e.g., 'src/main.ts' or './main.ts')"),
+			offset: zod.z.number().default(0).describe("Line offset to start reading from (0-indexed)"),
+			limit: zod.z.number().default(2e3).describe("Maximum number of lines to read")
+		}),
+		execute: async ({ file_path, offset, limit }, { toolCallId }) => {
+			const resolvedBackend = getBackend$1(backend, state);
+			const content = await resolvedBackend.read(file_path, offset ?? 0, limit ?? 2e3);
+			if (onEvent) {
+				const lineCount = content.split("\n").length;
+				onEvent(createFileReadEvent(file_path, lineCount));
+			}
+			if (evictionLimit && evictionLimit > 0) return (await evictToolResult({
+				result: content,
+				toolCallId: toolCallId || `read_${Date.now()}`,
+				toolName: "read_file",
+				backend: resolvedBackend,
+				tokenLimit: evictionLimit
+			})).content;
+			return content;
+		}
+	});
+}
+/**
+* Create the write_file tool.
+*/
+function createWriteFileTool(state, backend, onEvent) {
+	return (0, ai.tool)({
+		description: WRITE_FILE_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			file_path: zod.z.string().describe("Path to the file to write (e.g., 'src/main.ts' or './main.ts')"),
+			content: zod.z.string().describe("Content to write to the file")
+		}),
+		execute: async ({ file_path, content }) => {
+			if (onEvent) onEvent(createFileWriteStartEvent(file_path, content));
+			const result = await getBackend$1(backend, state).write(file_path, content);
+			if (result.error) return result.error;
+			if (onEvent) onEvent(createFileWrittenEvent(file_path, content));
+			return `Successfully wrote to '${file_path}'`;
+		}
+	});
+}
+/**
+* Create the edit_file tool.
+*/
+function createEditFileTool(state, backend, onEvent) {
+	return (0, ai.tool)({
+		description: EDIT_FILE_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			file_path: zod.z.string().describe("Path to the file to edit (e.g., 'src/main.ts' or './main.ts')"),
+			old_string: zod.z.string().describe("String to be replaced (must match exactly)"),
+			new_string: zod.z.string().describe("String to replace with"),
+			replace_all: zod.z.boolean().default(false).describe("Whether to replace all occurrences")
+		}),
+		execute: async ({ file_path, old_string, new_string, replace_all }) => {
+			const result = await getBackend$1(backend, state).edit(file_path, old_string, new_string, replace_all ?? false);
+			if (result.error) return result.error;
+			if (onEvent) onEvent(createFileEditedEvent(file_path, result.occurrences ?? 0));
+			return `Successfully replaced ${result.occurrences} occurrence(s) in '${file_path}'`;
+		}
+	});
+}
+/**
+* Create the glob tool.
+*/
+function createGlobTool(state, backend, onEvent) {
+	return (0, ai.tool)({
+		description: GLOB_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			pattern: zod.z.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
+			path: zod.z.string().default(".").describe("Base path to search from (default: current directory)")
+		}),
+		execute: async ({ pattern, path: path$1 }) => {
+			const infos = await getBackend$1(backend, state).globInfo(pattern, path$1 || ".");
+			if (onEvent) onEvent({
+				type: "glob",
+				pattern,
+				count: infos.length
+			});
+			if (infos.length === 0) return `No files found matching pattern '${pattern}'`;
+			return infos.map((info) => info.path).join("\n");
+		}
+	});
+}
+/**
+* Create the grep tool.
+*/
+function createGrepTool(state, backend, evictionLimit, onEvent) {
+	return (0, ai.tool)({
+		description: GREP_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			pattern: zod.z.string().describe("Regex pattern to search for"),
+			path: zod.z.string().default(".").describe("Base path to search from (default: current directory)"),
+			glob: zod.z.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
+		}),
+		execute: async ({ pattern, path: path$1, glob: glob$1 }, { toolCallId }) => {
+			const resolvedBackend = getBackend$1(backend, state);
+			const result = await resolvedBackend.grepRaw(pattern, path$1 || ".", glob$1 ?? null);
+			if (typeof result === "string") {
+				if (onEvent) onEvent({
+					type: "grep",
+					pattern,
+					count: 0
+				});
+				return result;
+			}
+			if (onEvent) onEvent({
+				type: "grep",
+				pattern,
+				count: result.length
+			});
+			if (result.length === 0) return `No matches found for pattern '${pattern}'`;
+			const lines = [];
+			let currentFile = null;
+			for (const match of result) {
+				if (match.path !== currentFile) {
+					currentFile = match.path;
+					lines.push(`\n${currentFile}:`);
+				}
+				lines.push(`  ${match.line}: ${match.text}`);
+			}
+			const content = lines.join("\n");
+			if (evictionLimit && evictionLimit > 0) return (await evictToolResult({
+				result: content,
+				toolCallId: toolCallId || `grep_${Date.now()}`,
+				toolName: "grep",
+				backend: resolvedBackend,
+				tokenLimit: evictionLimit
+			})).content;
+			return content;
+		}
+	});
+}
+/**
+* Create all filesystem tools.
+* @param state - The shared agent state
+* @param backendOrOptions - Backend or options object
+* @param onEvent - Optional callback for emitting events (deprecated, use options)
+*/
+function createFilesystemTools(state, backendOrOptions, onEvent) {
+	let backend;
+	let eventCallback = onEvent;
+	let evictionLimit;
+	if (backendOrOptions && typeof backendOrOptions === "object" && "backend" in backendOrOptions) {
+		const options = backendOrOptions;
+		backend = options.backend;
+		eventCallback = options.onEvent;
+		evictionLimit = options.toolResultEvictionLimit;
+	} else backend = backendOrOptions;
+	const resolvedBackend = backend || ((s) => new StateBackend(s));
+	return {
+		ls: createLsTool(state, resolvedBackend, eventCallback),
+		read_file: createReadFileTool(state, resolvedBackend, evictionLimit, eventCallback),
+		write_file: createWriteFileTool(state, resolvedBackend, eventCallback),
+		edit_file: createEditFileTool(state, resolvedBackend, eventCallback),
+		glob: createGlobTool(state, resolvedBackend, eventCallback),
+		grep: createGrepTool(state, resolvedBackend, evictionLimit, eventCallback)
+	};
+}
+/**
+* Individual builtin tool references for selective subagent configuration.
+* These are references to the creator functions, not instances.
+*/
+const ls = createLsTool;
+const read_file = createReadFileTool;
+const write_file = createWriteFileTool;
+const edit_file = createEditFileTool;
+const glob = createGlobTool;
+const grep = createGrepTool;
+
+//#endregion
+//#region src/utils/approval.ts
+/**
+* Utilities for applying tool approval configuration.
+*/
+/**
+* Check if approval is needed based on config.
+*/
+async function checkNeedsApproval(config, args) {
+	if (typeof config === "boolean") return config;
+	if (config.shouldApprove) return config.shouldApprove(args);
+	return true;
+}
+/**
+* Convert interruptOn config to needsApproval function for a tool.
+*/
+function configToNeedsApproval(config) {
+	if (typeof config === "boolean") return config;
+	if (config.shouldApprove) return config.shouldApprove;
+	return true;
+}
+let approvalCounter = 0;
+function generateApprovalId() {
+	return `approval-${Date.now()}-${++approvalCounter}`;
+}
+/**
+* Apply interruptOn configuration to a toolset.
+* 
+* This adds the `needsApproval` property to tools based on the config.
+* 
+* @param tools - The original toolset
+* @param interruptOn - Configuration mapping tool names to approval settings
+* @returns New toolset with needsApproval applied
+* 
+* @example
+* ```typescript
+* const approvedTools = applyInterruptConfig(tools, {
+*   write_file: true,
+*   execute: { shouldApprove: (args) => args.command.includes('rm') },
+* });
+* ```
+*/
+function applyInterruptConfig(tools, interruptOn) {
+	if (!interruptOn) return tools;
+	const result = {};
+	for (const [name, tool$6] of Object.entries(tools)) {
+		const config = interruptOn[name];
+		if (config === void 0 || config === false) result[name] = tool$6;
+		else result[name] = {
+			...tool$6,
+			needsApproval: configToNeedsApproval(config)
+		};
+	}
+	return result;
+}
+/**
+* Wrap tools with approval checking that intercepts execution.
+*
+* Unlike applyInterruptConfig which just sets needsApproval metadata,
+* this actually wraps the execute function to request approval before running.
+*
+* If no approval callback is provided, tools requiring approval will be auto-denied.
+*
+* @param tools - The original toolset
+* @param interruptOn - Configuration mapping tool names to approval settings
+* @param onApprovalRequest - Callback to request approval from user (optional)
+* @returns New toolset with wrapped execute functions
+*/
+function wrapToolsWithApproval(tools, interruptOn, onApprovalRequest) {
+	if (!interruptOn) return tools;
+	const result = {};
+	for (const [name, existingTool] of Object.entries(tools)) {
+		const config = interruptOn[name];
+		if (config === void 0 || config === false) result[name] = existingTool;
+		else {
+			const originalExecute = existingTool.execute;
+			if (!originalExecute) {
+				result[name] = existingTool;
+				continue;
+			}
+			result[name] = (0, ai.tool)({
+				description: existingTool.description,
+				inputSchema: existingTool.inputSchema,
+				execute: async (args, options) => {
+					if (await checkNeedsApproval(config, args)) {
+						if (!onApprovalRequest) return `Tool execution denied. No approval callback provided. The ${name} tool was not executed.`;
+						const approvalId = generateApprovalId();
+						if (!await onApprovalRequest({
+							approvalId,
+							toolCallId: options?.toolCallId || approvalId,
+							toolName: name,
+							args
+						})) return `Tool execution denied by user. The ${name} tool was not executed.`;
+					}
+					return originalExecute(args, options);
+				}
+			});
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/tools/web.ts
+/**
+* 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.
+*/
+function getBackend(backend, state) {
+	if (!backend) return null;
+	if (typeof backend === "function") return backend(state);
+	return backend;
+}
+/**
+* Convert HTML to Markdown with article extraction.
+* Uses Mozilla Readability to extract main content, then converts to Markdown.
+*/
+function htmlToMarkdown(html, url) {
+	try {
+		const dom = new jsdom.JSDOM(html, { url });
+		const article = new _mozilla_readability.Readability(dom.window.document).parse();
+		if (!article) return (dom.window.document.body?.textContent || "").trim();
+		const markdown = new turndown.default({
+			headingStyle: "atx",
+			codeBlockStyle: "fenced"
+		}).turndown(article.content || "");
+		if (article.title) return `# ${article.title}\n\n${markdown}`;
+		return markdown;
+	} catch (error) {
+		return `Error converting HTML to Markdown: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+/**
+* Create the web_search tool.
+*/
+function createWebSearchTool(state, options) {
+	const { backend, onEvent, toolResultEvictionLimit, tavilyApiKey } = options;
+	return (0, ai.tool)({
+		description: WEB_SEARCH_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			query: zod.z.string().describe("The search query (be specific and detailed for best results)"),
+			max_results: zod.z.number().default(5).describe("Number of results to return (1-20)"),
+			topic: zod.z.enum([
+				"general",
+				"news",
+				"finance"
+			]).default("general").describe("Search topic category"),
+			include_raw_content: zod.z.boolean().default(false).describe("Include full page content (warning: uses more tokens)")
+		}),
+		execute: async ({ query, max_results, topic, include_raw_content }, { toolCallId }) => {
+			if (onEvent) onEvent(createWebSearchStartEvent(query));
+			try {
+				const results = (await (0, _tavily_core.tavily)({ apiKey: tavilyApiKey }).search(query, {
+					maxResults: max_results,
+					topic,
+					includeRawContent: include_raw_content ? "text" : false
+				})).results || [];
+				const formattedResults = results.map((r, i) => `## Result ${i + 1}: ${r.title}\nURL: ${r.url}\nScore: ${r.score?.toFixed(2) || "N/A"}\nContent: ${r.content}\n`).join("\n---\n\n");
+				const output = `Found ${results.length} results for query: "${query}"\n\n${formattedResults}`;
+				if (onEvent) onEvent(createWebSearchFinishEvent(query, results.length));
+				if (toolResultEvictionLimit && toolResultEvictionLimit > 0 && backend) {
+					const resolvedBackend = getBackend(backend, state);
+					if (resolvedBackend) return (await evictToolResult({
+						result: output,
+						toolCallId: toolCallId || `web_search_${Date.now()}`,
+						toolName: "web_search",
+						backend: resolvedBackend,
+						tokenLimit: toolResultEvictionLimit
+					})).content;
+				}
+				return output;
+			} catch (error) {
+				const errorMessage = WEB_SEARCH_ERROR(error.message);
+				if (onEvent) onEvent(createWebSearchFinishEvent(query, 0));
+				return errorMessage;
+			}
+		}
+	});
+}
+/**
+* Create the http_request tool.
+*/
+function createHttpRequestTool(state, options) {
+	const { backend, onEvent, toolResultEvictionLimit, defaultTimeout } = options;
+	return (0, ai.tool)({
+		description: HTTP_REQUEST_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			url: zod.z.string().url().describe("Target URL (must be valid HTTP/HTTPS URL)"),
+			method: zod.z.enum([
+				"GET",
+				"POST",
+				"PUT",
+				"DELETE",
+				"PATCH"
+			]).default("GET").describe("HTTP method"),
+			headers: zod.z.record(zod.z.string()).optional().describe("HTTP headers as key-value pairs"),
+			body: zod.z.union([zod.z.string(), zod.z.record(zod.z.any())]).optional().describe("Request body (string or JSON object)"),
+			params: zod.z.record(zod.z.string()).optional().describe("URL query parameters as key-value pairs"),
+			timeout: zod.z.number().default(defaultTimeout).describe("Request timeout in seconds")
+		}),
+		execute: async ({ url, method, headers, body, params, timeout }, { toolCallId }) => {
+			if (onEvent) onEvent(createHttpRequestStartEvent(url, method));
+			try {
+				const urlObj = new URL(url);
+				if (params) Object.entries(params).forEach(([key, value]) => {
+					urlObj.searchParams.append(key, value);
+				});
+				const requestOptions = {
+					method,
+					headers: headers || {},
+					signal: AbortSignal.timeout(timeout * 1e3)
+				};
+				if (body) if (typeof body === "string") requestOptions.body = body;
+				else {
+					requestOptions.body = JSON.stringify(body);
+					requestOptions.headers["Content-Type"] = "application/json";
+				}
+				const response = await fetch(urlObj.toString(), requestOptions);
+				const contentType = response.headers.get("content-type") || "";
+				let content;
+				if (contentType.includes("application/json")) try {
+					content = await response.json();
+				} catch {
+					content = await response.text();
+				}
+				else content = await response.text();
+				const formattedOutput = `HTTP ${method} ${url}\nStatus: ${response.status}\nSuccess: ${response.ok}\nContent:\n${typeof content === "string" ? content : JSON.stringify(content, null, 2)}`;
+				if (onEvent) onEvent(createHttpRequestFinishEvent(response.url, response.status));
+				if (toolResultEvictionLimit && toolResultEvictionLimit > 0 && backend) {
+					const resolvedBackend = getBackend(backend, state);
+					if (resolvedBackend) return (await evictToolResult({
+						result: formattedOutput,
+						toolCallId: toolCallId || `http_request_${Date.now()}`,
+						toolName: "http_request",
+						backend: resolvedBackend,
+						tokenLimit: toolResultEvictionLimit
+					})).content;
+				}
+				return formattedOutput;
+			} catch (error) {
+				const err = error;
+				let errorMessage;
+				if (err.name === "TimeoutError" || err.name === "AbortError") errorMessage = REQUEST_TIMEOUT(timeout);
+				else errorMessage = `HTTP request error: ${err.message}`;
+				if (onEvent) onEvent(createHttpRequestFinishEvent(url, 0));
+				return errorMessage;
+			}
+		}
+	});
+}
+/**
+* Create the fetch_url tool.
+*/
+function createFetchUrlTool(state, options) {
+	const { backend, onEvent, toolResultEvictionLimit, defaultTimeout } = options;
+	return (0, ai.tool)({
+		description: FETCH_URL_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({
+			url: zod.z.string().url().describe("The URL to fetch (must be valid HTTP/HTTPS URL)"),
+			timeout: zod.z.number().default(defaultTimeout).describe("Request timeout in seconds"),
+			extract_article: zod.z.boolean().default(true).describe("Extract main article content using Readability (disable for non-article pages)")
+		}),
+		execute: async ({ url, timeout, extract_article }, { toolCallId }) => {
+			if (onEvent) onEvent(createFetchUrlStartEvent(url));
+			try {
+				const response = await fetch(url, {
+					signal: AbortSignal.timeout(timeout * 1e3),
+					headers: { "User-Agent": "Mozilla/5.0 (compatible; DeepAgents/1.0)" }
+				});
+				if (!response.ok) {
+					const errorMsg = `HTTP error: ${response.status} ${response.statusText}`;
+					if (onEvent) onEvent(createFetchUrlFinishEvent(response.url, false));
+					return errorMsg;
+				}
+				const html = await response.text();
+				const dom = new jsdom.JSDOM(html, { url });
+				let contentToConvert = html;
+				if (extract_article) try {
+					const article = new _mozilla_readability.Readability(dom.window.document).parse();
+					if (article && article.content) contentToConvert = article.content;
+				} catch (readabilityError) {
+					console.warn("Readability extraction failed, using full HTML");
+				}
+				const markdown = new turndown.default({
+					headingStyle: "atx",
+					codeBlockStyle: "fenced"
+				}).turndown(contentToConvert);
+				if (onEvent) onEvent(createFetchUrlFinishEvent(response.url, true));
+				if (toolResultEvictionLimit && toolResultEvictionLimit > 0 && backend) {
+					const resolvedBackend = getBackend(backend, state);
+					if (resolvedBackend) return (await evictToolResult({
+						result: markdown,
+						toolCallId: toolCallId || `fetch_url_${Date.now()}`,
+						toolName: "fetch_url",
+						backend: resolvedBackend,
+						tokenLimit: toolResultEvictionLimit
+					})).content;
+				}
+				return markdown;
+			} catch (error) {
+				const err = error;
+				let errorMessage;
+				if (err.name === "TimeoutError" || err.name === "AbortError") errorMessage = REQUEST_TIMEOUT(timeout);
+				else errorMessage = `Error fetching URL: ${err.message}`;
+				if (onEvent) onEvent(createFetchUrlFinishEvent(url, false));
+				return errorMessage;
+			}
+		}
+	});
+}
+/**
+* Create all web tools (web_search, http_request, fetch_url).
+* Tools are only created if TAVILY_API_KEY is available.
+*/
+function createWebTools(state, options) {
+	const { backend, onEvent, toolResultEvictionLimit, tavilyApiKey = process.env.TAVILY_API_KEY, defaultTimeout = DEFAULT_TIMEOUT_SECONDS } = options || {};
+	if (!tavilyApiKey) {
+		console.warn("Tavily API key not found. Web tools (web_search, fetch_url, http_request) will not be available. Set TAVILY_API_KEY environment variable to enable web tools.");
+		return {};
+	}
+	return {
+		web_search: createWebSearchTool(state, {
+			backend,
+			onEvent,
+			toolResultEvictionLimit,
+			tavilyApiKey
+		}),
+		http_request: createHttpRequestTool(state, {
+			backend,
+			onEvent,
+			toolResultEvictionLimit,
+			defaultTimeout
+		}),
+		fetch_url: createFetchUrlTool(state, {
+			backend,
+			onEvent,
+			toolResultEvictionLimit,
+			defaultTimeout
+		})
+	};
+}
+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
+/**
+* Execute tool for running shell commands in sandbox backends.
+*
+* This tool is only available when the backend implements SandboxBackendProtocol.
+*/
+/**
+* Tool description for the execute tool.
+*/
+const EXECUTE_TOOL_DESCRIPTION = `Execute a shell command in the sandbox environment.
+
+Use this tool to:
+- Run build commands (npm install, npm run build, bun install)
+- Run tests (npm test, bun test, pytest)
+- Execute scripts (node script.js, python script.py)
+- Check system state (ls, cat, pwd, which)
+- Install dependencies
+- Run any shell command
+
+The command runs in the sandbox's working directory. Commands have a timeout limit.
+
+IMPORTANT:
+- Always check the exit code to determine success (0 = success)
+- Long-running commands may timeout
+- Use && to chain commands that depend on each other
+- Use ; to run commands sequentially regardless of success`;
+/**
+* Create an execute tool for running shell commands.
+*
+* @param options - Options including the sandbox backend and optional event callback
+* @returns An AI SDK tool that executes shell commands
+*
+* @example Basic usage
+* ```typescript
+* import { LocalSandbox, createExecuteTool } from 'deepagentsdk';
+*
+* const sandbox = new LocalSandbox({ cwd: './workspace' });
+* const executeTool = createExecuteTool({ backend: sandbox });
+*
+* // Use with agent
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend: sandbox,
+*   tools: { execute: executeTool },
+* });
+* ```
+*
+* @example With event streaming
+* ```typescript
+* const executeTool = createExecuteTool({
+*   backend: sandbox,
+*   onEvent: (event) => {
+*     if (event.type === 'execute-start') {
+*       console.log(`Running: ${event.command}`);
+*     } else if (event.type === 'execute-finish') {
+*       console.log(`Exit code: ${event.exitCode}`);
+*     }
+*   },
+* });
+* ```
+*/
+function createExecuteTool(options) {
+	const { backend, onEvent, description } = options;
+	return (0, ai.tool)({
+		description: description || EXECUTE_TOOL_DESCRIPTION,
+		inputSchema: zod.z.object({ command: zod.z.string().describe("The shell command to execute (e.g., 'npm install', 'ls -la', 'cat file.txt')") }),
+		execute: async ({ command }) => {
+			if (onEvent) onEvent({
+				type: "execute-start",
+				command,
+				sandboxId: backend.id
+			});
+			const result = await backend.execute(command);
+			if (onEvent) onEvent({
+				type: "execute-finish",
+				command,
+				exitCode: result.exitCode,
+				truncated: result.truncated,
+				sandboxId: backend.id
+			});
+			const parts = [];
+			if (result.output) parts.push(result.output);
+			if (result.exitCode === 0) parts.push(`\n[Exit code: 0 (success)]`);
+			else if (result.exitCode !== null) parts.push(`\n[Exit code: ${result.exitCode} (failure)]`);
+			else parts.push(`\n[Exit code: unknown (possibly timed out)]`);
+			if (result.truncated) parts.push(`[Output truncated due to size limit]`);
+			return parts.join("");
+		}
+	});
+}
+/**
+* Convenience function to create execute tool from just a backend.
+* Useful for simple cases without event handling.
+*
+* @param backend - The sandbox backend
+* @returns An AI SDK tool that executes shell commands
+*
+* @example
+* ```typescript
+* const sandbox = new LocalSandbox({ cwd: './workspace' });
+* const tools = {
+*   execute: createExecuteToolFromBackend(sandbox),
+* };
+* ```
+*/
+function createExecuteToolFromBackend(backend) {
+	return createExecuteTool({ backend });
+}
+/**
+* Individual builtin tool reference for selective subagent configuration.
+* This is a reference to the creator function, not an instance.
+*/
+const execute = createExecuteTool;
+
+//#endregion
+//#region src/tools/subagent.ts
+/**
+* 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.
+*/
+function isBuiltinToolCreator(value) {
+	return typeof value === "function" && (value === createWebSearchTool || value === createHttpRequestTool || value === createFetchUrlTool || value === createLsTool || value === createReadFileTool || value === createWriteFileTool || value === createEditFileTool || value === createGlobTool || value === createGrepTool || value === createTodosTool || value === createExecuteTool);
+}
+/**
+* Instantiate a builtin tool creator with the given context.
+*/
+function instantiateBuiltinTool(creator, state, options) {
+	const { backend, onEvent, toolResultEvictionLimit } = options;
+	const tavilyApiKey = process.env.TAVILY_API_KEY || "";
+	const defaultTimeout = DEFAULT_TIMEOUT_SECONDS;
+	if (creator === createWebSearchTool) {
+		if (!tavilyApiKey) {
+			console.warn("web_search tool requested but TAVILY_API_KEY not set");
+			return {};
+		}
+		return { web_search: createWebSearchTool(state, {
+			backend,
+			onEvent,
+			toolResultEvictionLimit,
+			tavilyApiKey
+		}) };
+	}
+	if (creator === createHttpRequestTool) return { http_request: createHttpRequestTool(state, {
+		backend,
+		onEvent,
+		toolResultEvictionLimit,
+		defaultTimeout
+	}) };
+	if (creator === createFetchUrlTool) return { fetch_url: createFetchUrlTool(state, {
+		backend,
+		onEvent,
+		toolResultEvictionLimit,
+		defaultTimeout
+	}) };
+	if (creator === createLsTool) return { ls: createLsTool(state, backend, onEvent) };
+	if (creator === createReadFileTool) return { read_file: createReadFileTool(state, backend, toolResultEvictionLimit, onEvent) };
+	if (creator === createWriteFileTool) return { write_file: createWriteFileTool(state, backend, onEvent) };
+	if (creator === createEditFileTool) return { edit_file: createEditFileTool(state, backend, onEvent) };
+	if (creator === createGlobTool) return { glob: createGlobTool(state, backend, onEvent) };
+	if (creator === createGrepTool) return { grep: createGrepTool(state, backend, toolResultEvictionLimit, onEvent) };
+	if (creator === createTodosTool) return { write_todos: createTodosTool(state, onEvent) };
+	if (creator === createExecuteTool) throw new Error("execute tool cannot be used via selective tools - it requires a SandboxBackendProtocol");
+	throw new Error(`Unknown builtin tool creator: ${creator}`);
+}
+/**
+* Process subagent tool configuration (array or ToolSet) into a ToolSet.
+*/
+function processSubagentTools(toolConfig, state, options) {
+	if (!toolConfig) return {};
+	if (!Array.isArray(toolConfig)) return toolConfig;
+	let result = {};
+	for (const item of toolConfig) if (isBuiltinToolCreator(item)) {
+		const instantiated = instantiateBuiltinTool(item, state, options);
+		result = {
+			...result,
+			...instantiated
+		};
+	} else if (typeof item === "object" && item !== null) result = {
+		...result,
+		...item
+	};
+	return result;
+}
+/**
+* Build the system prompt for a subagent.
+*/
+function buildSubagentSystemPrompt(customPrompt) {
+	return `${customPrompt}
+
+${BASE_PROMPT}
+
+${TODO_SYSTEM_PROMPT}
+
+${FILESYSTEM_SYSTEM_PROMPT}`;
+}
+/**
+* Create the task tool for spawning subagents using ToolLoopAgent.
+*/
+function createSubagentTool(state, options) {
+	const { defaultModel, defaultTools = {}, subagents = [], includeGeneralPurposeAgent = true, backend, taskDescription = null, onEvent, interruptOn, parentGenerationOptions, parentAdvancedOptions } = options;
+	const subagentRegistry = {};
+	const subagentDescriptions = [];
+	if (includeGeneralPurposeAgent) {
+		subagentRegistry["general-purpose"] = {
+			systemPrompt: buildSubagentSystemPrompt(DEFAULT_SUBAGENT_PROMPT),
+			toolConfig: defaultTools,
+			model: defaultModel
+		};
+		subagentDescriptions.push(`- general-purpose: ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION}`);
+	}
+	for (const subagent of subagents) {
+		subagentRegistry[subagent.name] = {
+			systemPrompt: buildSubagentSystemPrompt(subagent.systemPrompt),
+			toolConfig: subagent.tools || defaultTools,
+			model: subagent.model || defaultModel,
+			output: subagent.output
+		};
+		subagentDescriptions.push(`- ${subagent.name}: ${subagent.description}`);
+	}
+	return (0, ai.tool)({
+		description: taskDescription || getTaskToolDescription(subagentDescriptions),
+		inputSchema: zod.z.object({
+			description: zod.z.string().describe("The task to execute with the selected agent"),
+			subagent_type: zod.z.string().describe(`Name of the agent to use. Available: ${Object.keys(subagentRegistry).join(", ")}`)
+		}),
+		execute: async ({ description, subagent_type }) => {
+			if (!(subagent_type in subagentRegistry)) return `Error: invoked agent of type ${subagent_type}, the only allowed types are ${Object.keys(subagentRegistry).map((k) => `\`${k}\``).join(", ")}`;
+			const subagentConfig = subagentRegistry[subagent_type];
+			const subagentSpec = subagents.find((sa) => sa.name === subagent_type);
+			const subagentInterruptOn = subagentSpec?.interruptOn ?? interruptOn;
+			const mergedGenerationOptions = {
+				...parentGenerationOptions,
+				...subagentSpec?.generationOptions
+			};
+			const mergedAdvancedOptions = {
+				...parentAdvancedOptions,
+				...subagentSpec?.advancedOptions
+			};
+			if (onEvent) onEvent(createSubagentStartEvent(subagent_type, description));
+			const subagentState = {
+				todos: [],
+				files: state.files
+			};
+			const customTools = processSubagentTools(subagentConfig.toolConfig, subagentState, {
+				backend,
+				onEvent
+			});
+			let allTools = {
+				write_todos: createTodosTool(subagentState, onEvent),
+				...createFilesystemTools(subagentState, backend, onEvent),
+				...customTools
+			};
+			allTools = applyInterruptConfig(allTools, subagentInterruptOn);
+			try {
+				const subagentSettings = {
+					model: subagentConfig.model,
+					instructions: subagentConfig.systemPrompt,
+					tools: allTools,
+					stopWhen: (0, ai.stepCountIs)(DEFAULT_SUBAGENT_MAX_STEPS),
+					...subagentConfig.output ? { output: ai.Output.object(subagentConfig.output) } : {}
+				};
+				if (Object.keys(mergedGenerationOptions).length > 0) Object.assign(subagentSettings, mergedGenerationOptions);
+				if (mergedAdvancedOptions) {
+					const { toolChoice, activeTools, ...safeAdvancedOptions } = mergedAdvancedOptions;
+					Object.assign(subagentSettings, safeAdvancedOptions);
+				}
+				let subagentStepCount = 0;
+				subagentSettings.onStepFinish = async ({ toolCalls, toolResults }) => {
+					if (onEvent && toolCalls && toolCalls.length > 0) {
+						const toolCallsWithResults = toolCalls.map((tc, index) => ({
+							toolName: tc.toolName,
+							args: tc.args,
+							result: toolResults[index]
+						}));
+						onEvent(createSubagentStepEvent(subagentStepCount++, toolCallsWithResults));
+					}
+				};
+				const result = await new ai.ToolLoopAgent(subagentSettings).generate({ prompt: description });
+				state.files = {
+					...state.files,
+					...subagentState.files
+				};
+				const resultText = result.text || "Task completed successfully.";
+				let formattedResult = resultText;
+				if (subagentConfig.output && "output" in result && result.output) formattedResult = `${resultText}\n\n[Structured Output]\n${JSON.stringify(result.output, null, 2)}`;
+				if (onEvent) onEvent(createSubagentFinishEvent(subagent_type, formattedResult));
+				return formattedResult;
+			} catch (error) {
+				const errorMessage = `Error executing subagent: ${error.message}`;
+				if (onEvent) onEvent(createSubagentFinishEvent(subagent_type, errorMessage));
+				return errorMessage;
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/utils/patch-tool-calls.ts
+/**
+* Check if a message is an assistant message with tool calls.
+*/
+function hasToolCalls(message) {
+	if (message.role !== "assistant") return false;
+	const content = message.content;
+	if (Array.isArray(content)) return content.some((part) => typeof part === "object" && part !== null && "type" in part && part.type === "tool-call");
+	return false;
+}
+/**
+* Extract tool call IDs from an assistant message.
+*/
+function getToolCallIds(message) {
+	if (message.role !== "assistant") return [];
+	const content = message.content;
+	if (!Array.isArray(content)) return [];
+	const ids = [];
+	for (const part of content) if (typeof part === "object" && part !== null && "type" in part && part.type === "tool-call" && "toolCallId" in part) ids.push(part.toolCallId);
+	return ids;
+}
+/**
+* Check if a message is a tool result for a specific tool call ID.
+*/
+function isToolResultFor(message, toolCallId) {
+	if (message.role !== "tool") return false;
+	if ("toolCallId" in message && message.toolCallId === toolCallId) return true;
+	const content = message.content;
+	if (Array.isArray(content)) return content.some((part) => typeof part === "object" && part !== null && "type" in part && part.type === "tool-result" && "toolCallId" in part && part.toolCallId === toolCallId);
+	return false;
+}
+/**
+* Create a synthetic tool result message for a cancelled tool call.
+*/
+function createCancelledToolResult(toolCallId, toolName) {
+	return {
+		role: "tool",
+		content: [{
+			type: "tool-result",
+			toolCallId,
+			toolName,
+			output: {
+				type: "text",
+				value: `Tool call ${toolName} with id ${toolCallId} was cancelled - another message came in before it could be completed.`
+			}
+		}]
+	};
+}
+/**
+* Get tool name from a tool call part.
+*/
+function getToolName(message, toolCallId) {
+	if (message.role !== "assistant") return "unknown";
+	const content = message.content;
+	if (!Array.isArray(content)) return "unknown";
+	for (const part of content) if (typeof part === "object" && part !== null && "type" in part && part.type === "tool-call" && "toolCallId" in part && part.toolCallId === toolCallId && "toolName" in part) return part.toolName;
+	return "unknown";
+}
+/**
+* Patch dangling tool calls in a message array.
+*
+* Scans for assistant messages with tool_calls that don't have corresponding
+* tool result messages, and adds synthetic "cancelled" responses.
+*
+* @param messages - Array of messages to patch
+* @returns New array with patched messages (original array is not modified)
+*
+* @example
+* ```typescript
+* const messages = [
+*   { role: "user", content: "Hello" },
+*   { role: "assistant", content: [{ type: "tool-call", toolCallId: "1", toolName: "search" }] },
+*   // Missing tool result for tool call "1"
+*   { role: "user", content: "Never mind" },
+* ];
+*
+* const patched = patchToolCalls(messages);
+* // patched now includes a synthetic tool result for the dangling call
+* ```
+*/
+function patchToolCalls(messages) {
+	if (!messages || messages.length === 0) return messages;
+	const result = [];
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		if (!message) continue;
+		result.push(message);
+		if (hasToolCalls(message)) {
+			const toolCallIds = getToolCallIds(message);
+			for (const toolCallId of toolCallIds) {
+				let hasResult = false;
+				for (let j = i + 1; j < messages.length; j++) {
+					const subsequentMsg = messages[j];
+					if (subsequentMsg && isToolResultFor(subsequentMsg, toolCallId)) {
+						hasResult = true;
+						break;
+					}
+				}
+				if (!hasResult) {
+					const toolName = getToolName(message, toolCallId);
+					result.push(createCancelledToolResult(toolCallId, toolName));
+				}
+			}
+		}
+	}
+	return result;
+}
+/**
+* Check if messages have any dangling tool calls.
+*
+* @param messages - Array of messages to check
+* @returns True if there are dangling tool calls
+*/
+function hasDanglingToolCalls(messages) {
+	if (!messages || messages.length === 0) return false;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		if (!message) continue;
+		if (hasToolCalls(message)) {
+			const toolCallIds = getToolCallIds(message);
+			for (const toolCallId of toolCallIds) {
+				let hasResult = false;
+				for (let j = i + 1; j < messages.length; j++) {
+					const subsequentMsg = messages[j];
+					if (subsequentMsg && isToolResultFor(subsequentMsg, toolCallId)) {
+						hasResult = true;
+						break;
+					}
+				}
+				if (!hasResult) return true;
+			}
+		}
+	}
+	return false;
+}
+
+//#endregion
+//#region src/utils/summarization.ts
+/**
+* Conversation summarization utility.
+*
+* 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.
+*/
+const DEFAULT_SUMMARIZATION_THRESHOLD = DEFAULT_SUMMARIZATION_THRESHOLD$1;
+/**
+* Default number of recent messages to keep intact.
+*/
+const DEFAULT_KEEP_MESSAGES = DEFAULT_KEEP_MESSAGES$1;
+/**
+* Estimate total tokens in a messages array.
+*/
+function estimateMessagesTokens(messages) {
+	let total = 0;
+	for (const message of messages) if (typeof message.content === "string") total += estimateTokens(message.content);
+	else if (Array.isArray(message.content)) {
+		for (const part of message.content) if (typeof part === "object" && part !== null && "text" in part) total += estimateTokens(String(part.text));
+	}
+	return total;
+}
+/**
+* Extract text content from a message.
+*/
+function getMessageText(message) {
+	if (typeof message.content === "string") return message.content;
+	if (Array.isArray(message.content)) return message.content.map((part) => {
+		if (typeof part === "object" && part !== null && "text" in part) return String(part.text);
+		if (typeof part === "object" && part !== null && "type" in part) {
+			if (part.type === "tool-call") return `[Tool call: ${part.toolName || "unknown"}]`;
+			if (part.type === "tool-result") return `[Tool result]`;
+		}
+		return "";
+	}).filter(Boolean).join("\n");
+	return "";
+}
+/**
+* Format messages for summarization prompt.
+*/
+function formatMessagesForSummary(messages) {
+	return messages.map((msg) => {
+		return `${msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "System"}: ${getMessageText(msg)}`;
+	}).join("\n\n");
+}
+/**
+* Generate a summary of conversation messages.
+*/
+async function generateSummary(messages, model, generationOptions, advancedOptions) {
+	const generateTextOptions = {
+		model,
+		system: `You are a conversation summarizer. Your task is to create a concise but comprehensive summary of the conversation that preserves:
+1. Key decisions and conclusions
+2. Important context and background information
+3. Any tasks or todos mentioned
+4. Technical details that may be referenced later
+5. The overall flow and progression of the conversation
+
+Keep the summary focused and avoid redundancy. The summary should allow someone to understand the conversation context without reading the full history.`,
+		prompt: `Please summarize the following conversation:\n\n${formatMessagesForSummary(messages)}`
+	};
+	if (generationOptions) Object.assign(generateTextOptions, generationOptions);
+	if (advancedOptions) Object.assign(generateTextOptions, advancedOptions);
+	return (await (0, ai.generateText)(generateTextOptions)).text;
+}
+/**
+* Summarize older messages when approaching token limits.
+*
+* This function checks if the total tokens in the messages exceed the threshold.
+* If so, it summarizes older messages while keeping recent ones intact.
+*
+* @param messages - Array of conversation messages
+* @param options - Summarization options
+* @returns Processed messages with optional summary
+*
+* @example
+* ```typescript
+* import { anthropic } from '@ai-sdk/anthropic';
+*
+* const result = await summarizeIfNeeded(messages, {
+*   model: anthropic('claude-haiku-4-5-20251001'),
+*   tokenThreshold: 170000,
+*   keepMessages: 6,
+* });
+*
+* if (result.summarized) {
+*   console.log(`Reduced from ${result.tokensBefore} to ${result.tokensAfter} tokens`);
+* }
+* ```
+*/
+async function summarizeIfNeeded(messages, options) {
+	const { model, tokenThreshold = DEFAULT_SUMMARIZATION_THRESHOLD, keepMessages = DEFAULT_KEEP_MESSAGES } = options;
+	const tokensBefore = estimateMessagesTokens(messages);
+	if (tokensBefore < tokenThreshold) return {
+		summarized: false,
+		messages,
+		tokensBefore
+	};
+	if (messages.length <= keepMessages) return {
+		summarized: false,
+		messages,
+		tokensBefore
+	};
+	const messagesToSummarize = messages.slice(0, -keepMessages);
+	const messagesToKeep = messages.slice(-keepMessages);
+	const newMessages = [{
+		role: "system",
+		content: `[Previous conversation summary]\n${await generateSummary(messagesToSummarize, model, options.generationOptions, options.advancedOptions)}\n\n[End of summary - recent messages follow]`
+	}, ...messagesToKeep];
+	return {
+		summarized: true,
+		messages: newMessages,
+		tokensBefore,
+		tokensAfter: estimateMessagesTokens(newMessages)
+	};
+}
+/**
+* Check if messages need summarization without performing it.
+*/
+function needsSummarization(messages, tokenThreshold = DEFAULT_SUMMARIZATION_THRESHOLD) {
+	return estimateMessagesTokens(messages) >= tokenThreshold;
+}
+
+//#endregion
+//#region src/agent.ts
+/**
+* Deep Agent implementation using Vercel AI SDK v6 ToolLoopAgent.
+*/
+init_limits();
+init_events();
+/**
+* Build the full system prompt from components.
+*/
+function buildSystemPrompt(customPrompt, hasSubagents, hasSandbox, skills) {
+	const parts = [
+		customPrompt || "",
+		BASE_PROMPT,
+		TODO_SYSTEM_PROMPT,
+		FILESYSTEM_SYSTEM_PROMPT
+	];
+	if (hasSandbox) parts.push(EXECUTE_SYSTEM_PROMPT);
+	if (hasSubagents) parts.push(TASK_SYSTEM_PROMPT);
+	if (skills && skills.length > 0) parts.push(buildSkillsPrompt(skills));
+	return parts.filter(Boolean).join("\n\n");
+}
+/**
+* Deep Agent wrapper class that provides generate() and stream() methods.
+* Uses ToolLoopAgent from AI SDK v6 for the agent loop.
+*/
+var DeepAgent = class {
+	model;
+	systemPrompt;
+	userTools;
+	maxSteps;
+	backend;
+	subagentOptions;
+	toolResultEvictionLimit;
+	enablePromptCaching;
+	summarizationConfig;
+	hasSandboxBackend;
+	interruptOn;
+	checkpointer;
+	skillsMetadata = [];
+	outputConfig;
+	loopControl;
+	generationOptions;
+	advancedOptions;
+	constructor(params) {
+		const { model, middleware, tools = {}, systemPrompt, subagents = [], backend, maxSteps = DEFAULT_MAX_STEPS, includeGeneralPurposeAgent = true, toolResultEvictionLimit, enablePromptCaching = false, summarization, interruptOn, checkpointer, skillsDir, agentId, output, loopControl, generationOptions, advancedOptions } = params;
+		if (middleware) this.model = (0, ai.wrapLanguageModel)({
+			model,
+			middleware: Array.isArray(middleware) ? middleware : [middleware]
+		});
+		else this.model = model;
+		this.maxSteps = maxSteps;
+		this.backend = backend || ((state) => new StateBackend(state));
+		this.toolResultEvictionLimit = toolResultEvictionLimit;
+		this.enablePromptCaching = enablePromptCaching;
+		this.summarizationConfig = summarization;
+		this.interruptOn = interruptOn;
+		this.checkpointer = checkpointer;
+		this.outputConfig = output;
+		this.loopControl = loopControl;
+		this.generationOptions = generationOptions;
+		this.advancedOptions = advancedOptions;
+		if (agentId) {
+			if (skillsDir) console.warn("[DeepAgent] agentId parameter takes precedence over skillsDir. skillsDir is deprecated and will be ignored.");
+			this.loadSkills({ agentId }).catch((error) => {
+				console.warn("[DeepAgent] Failed to load skills:", error);
+			});
+		} else if (skillsDir) this.loadSkills({ skillsDir }).catch((error) => {
+			console.warn("[DeepAgent] Failed to load skills:", error);
+		});
+		this.hasSandboxBackend = typeof backend !== "function" && backend !== void 0 && isSandboxBackend(backend);
+		this.systemPrompt = buildSystemPrompt(systemPrompt, includeGeneralPurposeAgent || subagents && subagents.length > 0, this.hasSandboxBackend, this.skillsMetadata);
+		this.userTools = tools;
+		this.subagentOptions = {
+			defaultModel: model,
+			defaultTools: tools,
+			subagents,
+			includeGeneralPurposeAgent
+		};
+	}
+	/**
+	* Create core tools (todos and filesystem).
+	* @private
+	*/
+	createCoreTools(state, onEvent) {
+		return {
+			write_todos: createTodosTool(state, onEvent),
+			...createFilesystemTools(state, {
+				backend: this.backend,
+				onEvent,
+				toolResultEvictionLimit: this.toolResultEvictionLimit
+			}),
+			...this.userTools
+		};
+	}
+	/**
+	* 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) {
+		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.
+	* @private
+	*/
+	createExecuteToolSet(onEvent) {
+		if (!this.hasSandboxBackend) return {};
+		const sandboxBackend = this.backend;
+		return { execute: createExecuteTool({
+			backend: sandboxBackend,
+			onEvent
+		}) };
+	}
+	/**
+	* Create subagent tool if configured.
+	* @private
+	*/
+	createSubagentToolSet(state, onEvent) {
+		if (!this.subagentOptions.includeGeneralPurposeAgent && (!this.subagentOptions.subagents || this.subagentOptions.subagents.length === 0)) return {};
+		return { task: createSubagentTool(state, {
+			defaultModel: this.subagentOptions.defaultModel,
+			defaultTools: this.userTools,
+			subagents: this.subagentOptions.subagents,
+			includeGeneralPurposeAgent: this.subagentOptions.includeGeneralPurposeAgent,
+			backend: this.backend,
+			onEvent,
+			interruptOn: this.interruptOn,
+			parentGenerationOptions: this.generationOptions,
+			parentAdvancedOptions: this.advancedOptions
+		}) };
+	}
+	/**
+	* Create all tools for the agent, combining core, web, execute, and subagent tools.
+	* @private
+	*/
+	createTools(state, onEvent) {
+		let allTools = this.createCoreTools(state, onEvent);
+		const webTools = this.createWebToolSet(state, onEvent);
+		if (Object.keys(webTools).length > 0) allTools = {
+			...allTools,
+			...webTools
+		};
+		const executeTools = this.createExecuteToolSet(onEvent);
+		if (Object.keys(executeTools).length > 0) allTools = {
+			...allTools,
+			...executeTools
+		};
+		const subagentTools = this.createSubagentToolSet(state, onEvent);
+		if (Object.keys(subagentTools).length > 0) allTools = {
+			...allTools,
+			...subagentTools
+		};
+		allTools = applyInterruptConfig(allTools, this.interruptOn);
+		return allTools;
+	}
+	/**
+	* Build stop conditions with maxSteps safety limit.
+	* Combines user-provided stop conditions with the maxSteps limit.
+	*/
+	buildStopConditions(maxSteps) {
+		const conditions = [];
+		conditions.push((0, ai.stepCountIs)(maxSteps ?? this.maxSteps));
+		if (this.loopControl?.stopWhen) if (Array.isArray(this.loopControl.stopWhen)) conditions.push(...this.loopControl.stopWhen);
+		else conditions.push(this.loopControl.stopWhen);
+		return conditions;
+	}
+	/**
+	* Build agent settings by combining passthrough options with defaults.
+	*/
+	buildAgentSettings(onEvent) {
+		const settings = {
+			model: this.model,
+			instructions: this.systemPrompt,
+			tools: void 0
+		};
+		if (this.generationOptions) Object.assign(settings, this.generationOptions);
+		if (this.advancedOptions) Object.assign(settings, this.advancedOptions);
+		if (this.loopControl) {
+			if (this.loopControl.prepareStep) settings.prepareStep = this.composePrepareStep(this.loopControl.prepareStep);
+			if (this.loopControl.onStepFinish) settings.onStepFinish = this.composeOnStepFinish(this.loopControl.onStepFinish);
+			if (this.loopControl.onFinish) settings.onFinish = this.composeOnFinish(this.loopControl.onFinish);
+		}
+		if (this.outputConfig) settings.output = ai.Output.object(this.outputConfig);
+		return settings;
+	}
+	/**
+	* Create a ToolLoopAgent for a given state.
+	* @param state - The shared agent state
+	* @param maxSteps - Optional max steps override
+	* @param onEvent - Optional callback for emitting events
+	*/
+	createAgent(state, maxSteps, onEvent) {
+		const tools = this.createTools(state, onEvent);
+		const settings = this.buildAgentSettings(onEvent);
+		const stopConditions = this.buildStopConditions(maxSteps);
+		return new ai.ToolLoopAgent({
+			...settings,
+			tools,
+			stopWhen: stopConditions
+		});
+	}
+	/**
+	* Load skills from directory asynchronously.
+	* Supports both legacy skillsDir and new agentId modes.
+	*/
+	async loadSkills(options) {
+		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,
+			path: s.path
+		}));
+	}
+	/**
+	* Generate a response (non-streaming).
+	*/
+	async generate(options) {
+		const state = {
+			todos: [],
+			files: {}
+		};
+		const result = await this.createAgent(state, options.maxSteps).generate({ prompt: options.prompt });
+		Object.defineProperty(result, "state", {
+			value: state,
+			enumerable: true,
+			writable: false
+		});
+		return result;
+	}
+	/**
+	* Stream a response.
+	*/
+	async stream(options) {
+		const state = {
+			todos: [],
+			files: {}
+		};
+		const result = await this.createAgent(state, options.maxSteps).stream({ prompt: options.prompt });
+		Object.defineProperty(result, "state", {
+			value: state,
+			enumerable: true,
+			writable: false
+		});
+		return result;
+	}
+	/**
+	* Generate with an existing state (for continuing conversations).
+	*/
+	async generateWithState(options) {
+		const result = await this.createAgent(options.state, options.maxSteps).generate({ prompt: options.prompt });
+		Object.defineProperty(result, "state", {
+			value: options.state,
+			enumerable: true,
+			writable: false
+		});
+		return result;
+	}
+	/**
+	* Get the underlying ToolLoopAgent for advanced usage.
+	* This allows using AI SDK's createAgentUIStream and other utilities.
+	*/
+	getAgent(state) {
+		const agentState = state || {
+			todos: [],
+			files: {}
+		};
+		return this.createAgent(agentState);
+	}
+	/**
+	* Stream a response with real-time events.
+	* This is an async generator that yields DeepAgentEvent objects.
+	* 
+	* Supports conversation history via the `messages` option for multi-turn conversations.
+	* 
+	* @example
+	* ```typescript
+	* // Single turn
+	* for await (const event of agent.streamWithEvents({ prompt: "..." })) {
+	*   switch (event.type) {
+	*     case 'text':
+	*       process.stdout.write(event.text);
+	*       break;
+	*     case 'done':
+	*       // event.messages contains the updated conversation history
+	*       console.log('Messages:', event.messages);
+	*       break;
+	*   }
+	* }
+	* 
+	* // Multi-turn conversation
+	* let messages = [];
+	* for await (const event of agent.streamWithEvents({ prompt: "Hello", messages })) {
+	*   if (event.type === 'done') {
+	*     messages = event.messages; // Save for next turn
+	*   }
+	* }
+	* for await (const event of agent.streamWithEvents({ prompt: "Follow up", messages })) {
+	*   // Agent now has context from previous turn
+	* }
+	* ```
+	*/
+	/**
+	* Compose user's onStepFinish callback with DeepAgent's internal checkpointing logic.
+	* User callback executes first, errors are caught to prevent breaking checkpointing.
+	*/
+	composeOnStepFinish(userOnStepFinish) {
+		return async (params) => {
+			if (userOnStepFinish) try {
+				await userOnStepFinish(params);
+			} catch (error) {
+				console.error("[DeepAgent] User onStepFinish callback failed:", error);
+			}
+		};
+	}
+	/**
+	* Compose user's onFinish callback with DeepAgent's internal cleanup logic.
+	*/
+	composeOnFinish(userOnFinish) {
+		return async (params) => {
+			if (userOnFinish) try {
+				await userOnFinish(params);
+			} catch (error) {
+				console.error("[DeepAgent] User onFinish callback failed:", error);
+			}
+		};
+	}
+	/**
+	* Compose user's prepareStep callback with DeepAgent's internal step preparation.
+	* Returns a function typed as `any` to avoid AI SDK's strict toolName inference.
+	*/
+	composePrepareStep(userPrepareStep) {
+		return async (params) => {
+			if (userPrepareStep) try {
+				return { ...await userPrepareStep(params) };
+			} catch (error) {
+				console.error("[DeepAgent] User prepareStep callback failed:", error);
+				return params;
+			}
+			return params;
+		};
+	}
+	/**
+	* Build streamText options with callbacks for step tracking and checkpointing.
+	*
+	* @private
+	*/
+	buildStreamTextOptions(inputMessages, tools, options, state, baseStep, pendingInterrupt, eventQueue, stepNumberRef) {
+		const { threadId } = options;
+		const streamOptions = {
+			model: this.model,
+			messages: inputMessages,
+			tools,
+			stopWhen: this.buildStopConditions(options.maxSteps),
+			abortSignal: options.abortSignal,
+			onStepFinish: async ({ toolCalls, toolResults }) => {
+				if (this.loopControl?.onStepFinish) await this.composeOnStepFinish(this.loopControl.onStepFinish)({
+					toolCalls,
+					toolResults
+				});
+				stepNumberRef.value++;
+				const cumulativeStep = baseStep + stepNumberRef.value;
+				const stepEvent = {
+					type: "step-finish",
+					stepNumber: stepNumberRef.value,
+					toolCalls: toolCalls.map((tc, i) => ({
+						toolName: tc.toolName,
+						args: "input" in tc ? tc.input : void 0,
+						result: toolResults[i] ? "output" in toolResults[i] ? toolResults[i].output : void 0 : void 0
+					}))
+				};
+				eventQueue.push(stepEvent);
+				if (threadId && this.checkpointer) {
+					const checkpoint = {
+						threadId,
+						step: cumulativeStep,
+						messages: inputMessages,
+						state: { ...state },
+						interrupt: pendingInterrupt,
+						createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+						updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+					};
+					await this.checkpointer.save(checkpoint);
+					eventQueue.push(createCheckpointSavedEvent(threadId, cumulativeStep));
+				}
+			}
+		};
+		if (this.generationOptions) Object.assign(streamOptions, this.generationOptions);
+		if (this.advancedOptions) Object.assign(streamOptions, this.advancedOptions);
+		if (this.outputConfig) streamOptions.output = ai.Output.object(this.outputConfig);
+		if (this.loopControl) {
+			if (this.loopControl.prepareStep) streamOptions.prepareStep = this.composePrepareStep(this.loopControl.prepareStep);
+			if (this.loopControl.onFinish) streamOptions.onFinish = this.composeOnFinish(this.loopControl.onFinish);
+		}
+		if (this.enablePromptCaching) streamOptions.messages = [{
+			role: "system",
+			content: this.systemPrompt,
+			providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } }
+		}, ...inputMessages];
+		else streamOptions.system = this.systemPrompt;
+		return streamOptions;
+	}
+	/**
+	* Build message array from options, handling validation and priority logic.
+	* Priority: explicit messages > prompt > checkpoint history.
+	*
+	* @private
+	*/
+	async buildMessageArray(options, patchedHistory) {
+		const { resume } = options;
+		if (!options.prompt && !options.messages && !resume && !options.threadId) return {
+			messages: [],
+			patchedHistory,
+			error: {
+				type: "error",
+				error: /* @__PURE__ */ new Error("Either 'prompt', 'messages', 'resume', or 'threadId' is required")
+			}
+		};
+		let userMessages = [];
+		let shouldUseCheckpointHistory = true;
+		if (options.messages && options.messages.length > 0) {
+			userMessages = options.messages;
+			shouldUseCheckpointHistory = false;
+			if (options.prompt && process.env.NODE_ENV !== "production") console.warn("prompt parameter is deprecated when messages are provided, using messages instead");
+		} else if (options.messages) {
+			shouldUseCheckpointHistory = false;
+			patchedHistory = [];
+			if (options.prompt && process.env.NODE_ENV !== "production") console.warn("prompt parameter is deprecated when empty messages are provided, prompt ignored");
+		} else if (options.prompt) {
+			userMessages = [{
+				role: "user",
+				content: options.prompt
+			}];
+			if (process.env.NODE_ENV !== "production") console.warn("prompt parameter is deprecated, use messages instead");
+		}
+		if (shouldUseCheckpointHistory && patchedHistory.length > 0) {
+			patchedHistory = patchToolCalls(patchedHistory);
+			if (this.summarizationConfig?.enabled && patchedHistory.length > 0) patchedHistory = (await summarizeIfNeeded(patchedHistory, {
+				model: this.summarizationConfig.model || this.model,
+				tokenThreshold: this.summarizationConfig.tokenThreshold,
+				keepMessages: this.summarizationConfig.keepMessages,
+				generationOptions: this.generationOptions,
+				advancedOptions: this.advancedOptions
+			})).messages;
+		} else if (!shouldUseCheckpointHistory) patchedHistory = [];
+		const hasEmptyMessages = options.messages && options.messages.length === 0;
+		const hasValidInput = userMessages.length > 0 || patchedHistory.length > 0;
+		if (hasEmptyMessages && !hasValidInput && !resume) return {
+			messages: [],
+			patchedHistory,
+			shouldReturnEmpty: true
+		};
+		if (!hasValidInput && !resume) return {
+			messages: [],
+			patchedHistory,
+			error: {
+				type: "error",
+				error: /* @__PURE__ */ new Error("No valid input: provide either non-empty messages, prompt, or threadId with existing checkpoint")
+			}
+		};
+		return {
+			messages: [...patchedHistory, ...userMessages],
+			patchedHistory
+		};
+	}
+	/**
+	* Load checkpoint context if threadId is provided.
+	* Handles checkpoint restoration and resume from interrupt.
+	*
+	* @private
+	*/
+	async loadCheckpointContext(options) {
+		const { threadId, resume } = options;
+		let state = options.state || {
+			todos: [],
+			files: {}
+		};
+		let patchedHistory = [];
+		let currentStep = 0;
+		let pendingInterrupt;
+		let checkpointEvent;
+		if (threadId && this.checkpointer) {
+			const checkpoint = await this.checkpointer.load(threadId);
+			if (checkpoint) {
+				state = checkpoint.state;
+				patchedHistory = checkpoint.messages;
+				currentStep = checkpoint.step;
+				pendingInterrupt = checkpoint.interrupt;
+				checkpointEvent = createCheckpointLoadedEvent(threadId, checkpoint.step, checkpoint.messages.length);
+			}
+		}
+		if (resume && pendingInterrupt) if (resume.decisions[0]?.type === "approve") pendingInterrupt = void 0;
+		else pendingInterrupt = void 0;
+		return {
+			state,
+			patchedHistory,
+			currentStep,
+			pendingInterrupt,
+			checkpointEvent
+		};
+	}
+	async *streamWithEvents(options) {
+		const { threadId, resume } = options;
+		const context = await this.loadCheckpointContext(options);
+		const { state, currentStep, pendingInterrupt, checkpointEvent } = context;
+		let patchedHistory = context.patchedHistory;
+		if (checkpointEvent) yield checkpointEvent;
+		const messageResult = await this.buildMessageArray(options, patchedHistory);
+		if (messageResult.error) {
+			yield messageResult.error;
+			return;
+		}
+		if (messageResult.shouldReturnEmpty) {
+			yield {
+				type: "done",
+				text: "",
+				messages: [],
+				state
+			};
+			return;
+		}
+		const inputMessages = messageResult.messages;
+		patchedHistory = messageResult.patchedHistory;
+		const eventQueue = [];
+		const stepNumberRef = { value: 0 };
+		const baseStep = currentStep;
+		const onEvent = (event) => {
+			eventQueue.push(event);
+		};
+		let tools = this.createTools(state, onEvent);
+		const hasInterruptOn = !!this.interruptOn;
+		const hasApprovalCallback = !!options.onApprovalRequest;
+		if (hasInterruptOn && hasApprovalCallback) tools = wrapToolsWithApproval(tools, this.interruptOn, options.onApprovalRequest);
+		try {
+			const result = (0, ai.streamText)(this.buildStreamTextOptions(inputMessages, tools, options, state, baseStep, pendingInterrupt, eventQueue, stepNumberRef));
+			yield {
+				type: "step-start",
+				stepNumber: 1
+			};
+			for await (const chunk of result.fullStream) {
+				while (eventQueue.length > 0) {
+					const event = eventQueue.shift();
+					yield event;
+					if (event.type === "step-finish") yield {
+						type: "step-start",
+						stepNumber: event.stepNumber + 1
+					};
+				}
+				if (chunk.type === "text-delta") yield {
+					type: "text",
+					text: chunk.text
+				};
+				else if (chunk.type === "tool-call") yield {
+					type: "tool-call",
+					toolName: chunk.toolName,
+					toolCallId: chunk.toolCallId,
+					args: chunk.input
+				};
+				else if (chunk.type === "tool-result") yield {
+					type: "tool-result",
+					toolName: chunk.toolName,
+					toolCallId: chunk.toolCallId,
+					result: chunk.output,
+					isError: false
+				};
+				else if (chunk.type === "tool-error") yield {
+					type: "tool-result",
+					toolName: chunk.toolName,
+					toolCallId: chunk.toolCallId,
+					result: chunk.error,
+					isError: true
+				};
+			}
+			while (eventQueue.length > 0) yield eventQueue.shift();
+			const finalText = await result.text;
+			const updatedMessages = [...inputMessages, ...finalText ? [{
+				role: "assistant",
+				content: finalText
+			}] : []];
+			const output = "output" in result ? result.output : void 0;
+			yield {
+				type: "done",
+				state,
+				text: finalText,
+				messages: updatedMessages,
+				...output !== void 0 ? { output } : {}
+			};
+			if (threadId && this.checkpointer) {
+				const finalCheckpoint = {
+					threadId,
+					step: baseStep + stepNumberRef.value,
+					messages: updatedMessages,
+					state,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				await this.checkpointer.save(finalCheckpoint);
+				yield createCheckpointSavedEvent(threadId, baseStep + stepNumberRef.value);
+			}
+		} catch (error) {
+			yield {
+				type: "error",
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+	}
+	/**
+	* Stream with a simple callback interface.
+	* This is a convenience wrapper around streamWithEvents.
+	*/
+	async streamWithCallback(options, onEvent) {
+		let finalState = options.state || {
+			todos: [],
+			files: {}
+		};
+		let finalText;
+		let finalMessages;
+		for await (const event of this.streamWithEvents(options)) {
+			onEvent(event);
+			if (event.type === "done") {
+				finalState = event.state;
+				finalText = event.text;
+				finalMessages = event.messages;
+			}
+		}
+		return {
+			state: finalState,
+			text: finalText,
+			messages: finalMessages
+		};
+	}
+};
+/**
+* Create a Deep Agent with planning, filesystem, and subagent capabilities.
+*
+* @param params - Configuration object for the Deep Agent
+* @param params.model - **Required.** AI SDK LanguageModel instance (e.g., `anthropic('claude-sonnet-4-20250514')`, `openai('gpt-4o')`)
+* @param params.systemPrompt - Optional custom system prompt for the agent
+* @param params.tools - Optional custom tools to add to the agent (AI SDK ToolSet)
+* @param params.subagents - Optional array of specialized subagent configurations for task delegation
+* @param params.backend - Optional backend for filesystem operations (default: StateBackend for in-memory storage)
+* @param params.maxSteps - Optional maximum number of steps for the agent loop (default: 100)
+* @param params.includeGeneralPurposeAgent - Optional flag to include general-purpose subagent (default: true)
+* @param params.toolResultEvictionLimit - Optional token limit before evicting large tool results to filesystem (default: disabled)
+* @param params.enablePromptCaching - Optional flag to enable prompt caching for improved performance (Anthropic only, default: false)
+* @param params.summarization - Optional summarization configuration for automatic conversation summarization
+* @returns A configured DeepAgent instance
+*
+* @see {@link CreateDeepAgentParams} for detailed parameter types
+*
+* @example Basic usage
+* ```typescript
+* import { createDeepAgent } from 'deepagentsdk';
+* import { anthropic } from '@ai-sdk/anthropic';
+*
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   systemPrompt: 'You are a research assistant...',
+* });
+*
+* const result = await agent.generate({
+*   prompt: 'Research the topic and write a report',
+* });
+* ```
+*
+* @example With custom tools
+* ```typescript
+* import { tool } from 'ai';
+* import { z } from 'zod';
+*
+* const customTool = tool({
+*   description: 'Get current time',
+*   inputSchema: z.object({}),
+*   execute: async () => new Date().toISOString(),
+* });
+*
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   tools: { get_time: customTool },
+* });
+* ```
+*
+* @example With subagents
+* ```typescript
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   subagents: [{
+*     name: 'research-agent',
+*     description: 'Specialized for research tasks',
+*     systemPrompt: 'You are a research specialist...',
+*   }],
+* });
+* ```
+*
+* @example With StateBackend (default, explicit)
+* ```typescript
+* import { StateBackend } from 'deepagentsdk';
+*
+* const state = { todos: [], files: {} };
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend: new StateBackend(state), // Ephemeral in-memory storage
+* });
+* ```
+*
+* @example With FilesystemBackend
+* ```typescript
+* import { FilesystemBackend } from 'deepagentsdk';
+*
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend: new FilesystemBackend({ rootDir: './workspace' }), // Persist to disk
+* });
+* ```
+*
+* @example With PersistentBackend
+* ```typescript
+* import { PersistentBackend, InMemoryStore } from 'deepagentsdk';
+*
+* const store = new InMemoryStore();
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend: new PersistentBackend({ store, namespace: 'project-1' }), // Cross-session persistence
+* });
+* ```
+*
+* @example With CompositeBackend
+* ```typescript
+* import { CompositeBackend, FilesystemBackend, StateBackend } from 'deepagentsdk';
+*
+* const state = { todos: [], files: {} };
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend: new CompositeBackend(
+*     new StateBackend(state),
+*     { '/persistent/': new FilesystemBackend({ rootDir: './persistent' }) }
+*   ), // Route files by path prefix
+* });
+* ```
+*
+* @example With middleware for logging and caching
+* ```typescript
+* import { createDeepAgent } from 'deepagentsdk';
+* import { anthropic } from '@ai-sdk/anthropic';
+*
+* const loggingMiddleware = {
+*   wrapGenerate: async ({ doGenerate, params }) => {
+*     console.log('Model called with:', params.prompt);
+*     const result = await doGenerate();
+*     console.log('Model returned:', result.text);
+*     return result;
+*   },
+* };
+*
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   middleware: [loggingMiddleware],
+* });
+* ```
+*
+* @example With middleware factory for context access
+* ```typescript
+* import { FilesystemBackend } from 'deepagentsdk';
+*
+* function createContextMiddleware(backend: BackendProtocol) {
+*   return {
+*     wrapGenerate: async ({ doGenerate }) => {
+*       const state = await backend.read('state');
+*       const result = await doGenerate();
+*       await backend.write('state', { ...state, lastCall: result });
+*       return result;
+*     },
+*   };
+* }
+*
+* const backend = new FilesystemBackend({ rootDir: './workspace' });
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   backend,
+*   middleware: createContextMiddleware(backend),
+* });
+* ```
+*
+* @example With performance optimizations
+* ```typescript
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   enablePromptCaching: true,
+*   toolResultEvictionLimit: 20000,
+*   summarization: {
+*     enabled: true,
+*     tokenThreshold: 170000,
+*     keepMessages: 6,
+*   },
+* });
+* ```
+*/
+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,
+  get: function () {
+    return BASE_PROMPT;
+  }
+});
+Object.defineProperty(exports, 'BaseSandbox', {
+  enumerable: true,
+  get: function () {
+    return BaseSandbox;
+  }
+});
+Object.defineProperty(exports, 'CONTEXT_WINDOW', {
+  enumerable: true,
+  get: function () {
+    return CONTEXT_WINDOW;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_EVICTION_TOKEN_LIMIT', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_EVICTION_TOKEN_LIMIT;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_EVICTION_TOKEN_LIMIT$1', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_EVICTION_TOKEN_LIMIT$1;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_GENERAL_PURPOSE_DESCRIPTION', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_GENERAL_PURPOSE_DESCRIPTION;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_KEEP_MESSAGES', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_KEEP_MESSAGES;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_KEEP_MESSAGES$1', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_KEEP_MESSAGES$1;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_READ_LIMIT', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_READ_LIMIT;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_SUBAGENT_PROMPT', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_SUBAGENT_PROMPT;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_SUMMARIZATION_THRESHOLD', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_SUMMARIZATION_THRESHOLD;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_SUMMARIZATION_THRESHOLD$1', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_SUMMARIZATION_THRESHOLD$1;
+  }
+});
+Object.defineProperty(exports, 'DeepAgent', {
+  enumerable: true,
+  get: function () {
+    return DeepAgent;
+  }
+});
+Object.defineProperty(exports, 'EXECUTE_SYSTEM_PROMPT', {
+  enumerable: true,
+  get: function () {
+    return EXECUTE_SYSTEM_PROMPT;
+  }
+});
+Object.defineProperty(exports, 'FILESYSTEM_SYSTEM_PROMPT', {
+  enumerable: true,
+  get: function () {
+    return FILESYSTEM_SYSTEM_PROMPT;
+  }
+});
+Object.defineProperty(exports, 'FILE_ALREADY_EXISTS', {
+  enumerable: true,
+  get: function () {
+    return FILE_ALREADY_EXISTS;
+  }
+});
+Object.defineProperty(exports, 'FILE_NOT_FOUND', {
+  enumerable: true,
+  get: function () {
+    return FILE_NOT_FOUND;
+  }
+});
+Object.defineProperty(exports, 'FileSaver', {
+  enumerable: true,
+  get: function () {
+    return FileSaver;
+  }
+});
+Object.defineProperty(exports, 'LocalSandbox', {
+  enumerable: true,
+  get: function () {
+    return LocalSandbox;
+  }
+});
+Object.defineProperty(exports, 'MAX_FILE_SIZE_MB', {
+  enumerable: true,
+  get: function () {
+    return MAX_FILE_SIZE_MB;
+  }
+});
+Object.defineProperty(exports, 'StateBackend', {
+  enumerable: true,
+  get: function () {
+    return StateBackend;
+  }
+});
+Object.defineProperty(exports, 'TASK_SYSTEM_PROMPT', {
+  enumerable: true,
+  get: function () {
+    return TASK_SYSTEM_PROMPT;
+  }
+});
+Object.defineProperty(exports, 'TODO_SYSTEM_PROMPT', {
+  enumerable: true,
+  get: function () {
+    return TODO_SYSTEM_PROMPT;
+  }
+});
+Object.defineProperty(exports, 'checkEmptyContent', {
+  enumerable: true,
+  get: function () {
+    return checkEmptyContent;
+  }
+});
+Object.defineProperty(exports, 'createDeepAgent', {
+  enumerable: true,
+  get: function () {
+    return createDeepAgent;
+  }
+});
+Object.defineProperty(exports, 'createEditFileTool', {
+  enumerable: true,
+  get: function () {
+    return createEditFileTool;
+  }
+});
+Object.defineProperty(exports, 'createExecuteTool', {
+  enumerable: true,
+  get: function () {
+    return createExecuteTool;
+  }
+});
+Object.defineProperty(exports, 'createExecuteToolFromBackend', {
+  enumerable: true,
+  get: function () {
+    return createExecuteToolFromBackend;
+  }
+});
+Object.defineProperty(exports, 'createFetchUrlTool', {
+  enumerable: true,
+  get: function () {
+    return createFetchUrlTool;
+  }
+});
+Object.defineProperty(exports, 'createFileData', {
+  enumerable: true,
+  get: function () {
+    return createFileData;
+  }
+});
+Object.defineProperty(exports, 'createFilesystemTools', {
+  enumerable: true,
+  get: function () {
+    return createFilesystemTools;
+  }
+});
+Object.defineProperty(exports, 'createGlobTool', {
+  enumerable: true,
+  get: function () {
+    return createGlobTool;
+  }
+});
+Object.defineProperty(exports, 'createGrepTool', {
+  enumerable: true,
+  get: function () {
+    return createGrepTool;
+  }
+});
+Object.defineProperty(exports, 'createHttpRequestTool', {
+  enumerable: true,
+  get: function () {
+    return createHttpRequestTool;
+  }
+});
+Object.defineProperty(exports, 'createLsTool', {
+  enumerable: true,
+  get: function () {
+    return createLsTool;
+  }
+});
+Object.defineProperty(exports, 'createReadFileTool', {
+  enumerable: true,
+  get: function () {
+    return createReadFileTool;
+  }
+});
+Object.defineProperty(exports, 'createSubagentTool', {
+  enumerable: true,
+  get: function () {
+    return createSubagentTool;
+  }
+});
+Object.defineProperty(exports, 'createTodosTool', {
+  enumerable: true,
+  get: function () {
+    return createTodosTool;
+  }
+});
+Object.defineProperty(exports, 'createToolResultWrapper', {
+  enumerable: true,
+  get: function () {
+    return createToolResultWrapper;
+  }
+});
+Object.defineProperty(exports, 'createWebSearchTool', {
+  enumerable: true,
+  get: function () {
+    return createWebSearchTool;
+  }
+});
+Object.defineProperty(exports, 'createWebTools', {
+  enumerable: true,
+  get: function () {
+    return createWebTools;
+  }
+});
+Object.defineProperty(exports, 'createWriteFileTool', {
+  enumerable: true,
+  get: function () {
+    return createWriteFileTool;
+  }
+});
+Object.defineProperty(exports, 'edit_file', {
+  enumerable: true,
+  get: function () {
+    return edit_file;
+  }
+});
+Object.defineProperty(exports, 'estimateMessagesTokens', {
+  enumerable: true,
+  get: function () {
+    return estimateMessagesTokens;
+  }
+});
+Object.defineProperty(exports, 'estimateTokens', {
+  enumerable: true,
+  get: function () {
+    return estimateTokens;
+  }
+});
+Object.defineProperty(exports, 'evictToolResult', {
+  enumerable: true,
+  get: function () {
+    return evictToolResult;
+  }
+});
+Object.defineProperty(exports, 'execute', {
+  enumerable: true,
+  get: function () {
+    return execute;
+  }
+});
+Object.defineProperty(exports, 'fetch_url', {
+  enumerable: true,
+  get: function () {
+    return fetch_url;
+  }
+});
+Object.defineProperty(exports, 'fileDataToString', {
+  enumerable: true,
+  get: function () {
+    return fileDataToString;
+  }
+});
+Object.defineProperty(exports, 'formatContentWithLineNumbers', {
+  enumerable: true,
+  get: function () {
+    return formatContentWithLineNumbers;
+  }
+});
+Object.defineProperty(exports, 'formatReadResponse', {
+  enumerable: true,
+  get: function () {
+    return formatReadResponse;
+  }
+});
+Object.defineProperty(exports, 'getTaskToolDescription', {
+  enumerable: true,
+  get: function () {
+    return getTaskToolDescription;
+  }
+});
+Object.defineProperty(exports, 'glob', {
+  enumerable: true,
+  get: function () {
+    return glob;
+  }
+});
+Object.defineProperty(exports, 'globSearchFiles', {
+  enumerable: true,
+  get: function () {
+    return globSearchFiles;
+  }
+});
+Object.defineProperty(exports, 'grep', {
+  enumerable: true,
+  get: function () {
+    return grep;
+  }
+});
+Object.defineProperty(exports, 'grepMatchesFromFiles', {
+  enumerable: true,
+  get: function () {
+    return grepMatchesFromFiles;
+  }
+});
+Object.defineProperty(exports, 'hasDanglingToolCalls', {
+  enumerable: true,
+  get: function () {
+    return hasDanglingToolCalls;
+  }
+});
+Object.defineProperty(exports, 'htmlToMarkdown', {
+  enumerable: true,
+  get: function () {
+    return htmlToMarkdown;
+  }
+});
+Object.defineProperty(exports, 'http_request', {
+  enumerable: true,
+  get: function () {
+    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 () {
+    return isSandboxBackend;
+  }
+});
+Object.defineProperty(exports, 'ls', {
+  enumerable: true,
+  get: function () {
+    return ls;
+  }
+});
+Object.defineProperty(exports, 'needsSummarization', {
+  enumerable: true,
+  get: function () {
+    return needsSummarization;
+  }
+});
+Object.defineProperty(exports, 'parseModelString', {
+  enumerable: true,
+  get: function () {
+    return parseModelString;
+  }
+});
+Object.defineProperty(exports, 'patchToolCalls', {
+  enumerable: true,
+  get: function () {
+    return patchToolCalls;
+  }
+});
+Object.defineProperty(exports, 'performStringReplacement', {
+  enumerable: true,
+  get: function () {
+    return performStringReplacement;
+  }
+});
+Object.defineProperty(exports, 'read_file', {
+  enumerable: true,
+  get: function () {
+    return read_file;
+  }
+});
+Object.defineProperty(exports, 'shouldEvict', {
+  enumerable: true,
+  get: function () {
+    return shouldEvict;
+  }
+});
+Object.defineProperty(exports, 'summarizeIfNeeded', {
+  enumerable: true,
+  get: function () {
+    return summarizeIfNeeded;
+  }
+});
+Object.defineProperty(exports, 'updateFileData', {
+  enumerable: true,
+  get: function () {
+    return updateFileData;
+  }
+});
+Object.defineProperty(exports, 'web_search', {
+  enumerable: true,
+  get: function () {
+    return web_search;
+  }
+});
+Object.defineProperty(exports, 'write_file', {
+  enumerable: true,
+  get: function () {
+    return write_file;
+  }
+});
+Object.defineProperty(exports, 'write_todos', {
+  enumerable: true,
+  get: function () {
+    return write_todos;
+  }
+});
+//# sourceMappingURL=file-saver-BYPKakT4.cjs.map