deepagentsdk 0.11.0 → 0.12.0

package/dist/agent-CrH-He58.mjs

@@ -0,0 +1,2974 @@
+import { Output, ToolLoopAgent, generateText, stepCountIs, streamText, tool, wrapLanguageModel } from "ai";
+import { z } from "zod";
+import micromatch from "micromatch";
+import { basename } from "path";
+import { tavily } from "@tavily/core";
+import TurndownService from "turndown";
+import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+
+//#region src/constants/limits.ts
+/**
+* Centralized token, size, and timeout limits.
+*
+* These constants prevent magic number scattering across the codebase and provide
+* a single source of truth for configuration values. When updating these values,
+* consider the impact on performance, user experience, and API limits.
+*
+* @module constants/limits
+*/
+/**
+* Default token limit for tool result eviction.
+*
+* When a tool result exceeds this limit, it is automatically evicted to a file
+* to prevent context overflow. The evicted content is stored in the backend and
+* a summary is kept in the conversation history.
+*
+* @default 20000
+* @see {@link ../utils/eviction | evictToolResult}
+*/
+const DEFAULT_EVICTION_TOKEN_LIMIT$1 = 2e4;
+/**
+* Default threshold for message summarization.
+*
+* When the estimated token count of messages exceeds this threshold, the system
+* automatically summarizes older messages to stay within context limits. This
+* helps maintain conversation continuity while reducing token usage.
+*
+* @default 170000
+* @see {@link ../utils/summarization | summarizeIfNeeded}
+*/
+const DEFAULT_SUMMARIZATION_THRESHOLD$1 = 17e4;
+/**
+* Maximum context window size for Claude models.
+*
+* This represents the maximum number of tokens that can be processed in a single
+* conversation. Used for calculating token usage percentages and determining when
+* summarization is needed.
+*
+* @default 200000
+* @see {@link ../utils/summarization | estimateMessagesTokens}
+*/
+const CONTEXT_WINDOW = 2e5;
+/**
+* Default number of recent messages to keep during summarization.
+*
+* When summarization is triggered, this many of the most recent messages are
+* preserved verbatim while older messages are summarized. This ensures recent
+* context is immediately available to the agent.
+*
+* @default 6
+*/
+const DEFAULT_KEEP_MESSAGES$1 = 6;
+/**
+* Default maximum number of reasoning steps for the main agent.
+*
+* The agent will stop after reaching this many steps to prevent infinite loops
+* or excessive token usage. Each step represents one tool invocation cycle.
+*
+* @default 100
+*/
+const DEFAULT_MAX_STEPS = 100;
+/**
+* Default maximum number of reasoning steps for subagents.
+*
+* Subagents are given a lower step limit than the main agent to prevent them
+* from consuming too many resources. This ensures the parent agent maintains
+* control over the overall task.
+*
+* @default 50
+* @see {@link ../tools/subagent | createTaskTool}
+*/
+const DEFAULT_SUBAGENT_MAX_STEPS = 50;
+/**
+* Default maximum number of lines to read from a file.
+*
+* The read_file tool defaults to reading this many lines to prevent loading
+* extremely large files into context. Can be overridden per-read operation.
+*
+* @default 2000
+* @see {@link ../tools/filesystem | createReadFileTool}
+*/
+const DEFAULT_READ_LIMIT = 2e3;
+/**
+* Maximum line length before content is considered invalid.
+*
+* Lines exceeding this length may indicate minified code, binary content, or
+* other data that should not be processed as text. Used for validation.
+*
+* @default 10000
+*/
+const MAX_LINE_LENGTH = 1e4;
+/**
+* Maximum file size in megabytes for file operations.
+*
+* Files larger than this size will be rejected to prevent memory issues and
+* excessive token usage. This is a soft limit that can be adjusted for specific
+* use cases.
+*
+* @default 10
+*/
+const MAX_FILE_SIZE_MB = 10;
+/**
+* Default timeout for network requests in seconds.
+*
+* Used by web tools (http_request, fetch_url) to prevent hanging indefinitely
+* on slow or unresponsive servers. Can be overridden per-request.
+*
+* @default 30
+* @see {@link ../tools/web | createHttpRequestTool}
+*/
+const DEFAULT_TIMEOUT_SECONDS = 30;
+/**
+* Default timeout in milliseconds (derived from DEFAULT_TIMEOUT_SECONDS).
+*
+* Provided for convenience when working with APIs that expect milliseconds
+* instead of seconds.
+*
+* @default 30000 (30 seconds)
+*/
+const DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_SECONDS * 1e3;
+/**
+* Width for line number formatting in file read operations.
+*
+* When displaying file content with line numbers, this specifies the minimum
+* width for the line number column. Ensures consistent alignment across
+* different file sizes.
+*
+* @default 6
+* @see {@link ../backends/utils | formatFileContent}
+*/
+const LINE_NUMBER_WIDTH = 6;
+
+//#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, content) {
+	return {
+		type: "file-write-start",
+		path,
+		content
+	};
+}
+/**
+* Create a file-written event (after successful write).
+*/
+function createFileWrittenEvent(path, content) {
+	return {
+		type: "file-written",
+		path,
+		content
+	};
+}
+/**
+* Create a file-edited event.
+*/
+function createFileEditedEvent(path, occurrences) {
+	return {
+		type: "file-edited",
+		path,
+		occurrences
+	};
+}
+/**
+* Create a file-read event.
+*/
+function createFileReadEvent(path, lines) {
+	return {
+		type: "file-read",
+		path,
+		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
+	};
+}
+
+//#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.
+*/
+const TodoItemSchema = z.object({
+	id: z.string().describe("Unique identifier for the todo item"),
+	content: z.string().max(100).describe("The description/content of the todo item (max 100 chars)"),
+	status: 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 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: z.object({
+			todos: z.array(TodoItemSchema).min(1).describe("Array of todo items to write"),
+			merge: 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
+/**
+* Centralized error message constants for backend operations
+* Reduces duplication across 6 backend implementations
+*/
+const FILE_NOT_FOUND = (path) => `Error: File '${path}' not found`;
+const FILE_ALREADY_EXISTS = (path) => `Cannot write to ${path} because it already exists. Read and then make an edit, or write to a new path.`;
+const STRING_NOT_FOUND = (path, string) => `Error: String not found in file: '${path}'\n\n${string}`;
+const INVALID_REGEX = (message) => `Invalid regex pattern: ${message}`;
+const WEB_SEARCH_ERROR = (message) => `Web search error: ${message}`;
+const REQUEST_TIMEOUT = (timeout) => `Request timed out after ${timeout} seconds`;
+const SYSTEM_REMINDER_FILE_EMPTY = "System reminder: File exists but has empty contents";
+
+//#endregion
+//#region src/backends/utils.ts
+/**
+* Shared utility functions for memory backend implementations.
+*/
+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) {
+	const pathStr = path || "/";
+	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 = "/") {
+	let normalizedPath;
+	try {
+		normalizedPath = validatePath(path);
+	} 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.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 = null, glob$1 = null) {
+	let regex;
+	try {
+		regex = new RegExp(pattern);
+	} catch (e) {
+		return INVALID_REGEX(e.message);
+	}
+	let normalizedPath;
+	try {
+		normalizedPath = validatePath(path);
+	} 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.isMatch(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
+/**
+* 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) {
+		const files = this.getFiles();
+		const infos = [];
+		const subdirs = /* @__PURE__ */ new Set();
+		const normalizedPath = path.endsWith("/") ? path : path + "/";
+		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 = "/", glob$1 = null) {
+		return grepMatchesFromFiles(this.getFiles(), pattern, path, glob$1);
+	}
+	/**
+	* Structured glob matching returning FileInfo objects.
+	*/
+	globInfo(pattern, path = "/") {
+		const files = this.getFiles();
+		const result = globSearchFiles(files, pattern, path);
+		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
+/**
+* Default token limit before evicting a tool result.
+* Approximately 20,000 tokens (~80KB of text).
+*/
+const DEFAULT_EVICTION_TOKEN_LIMIT = DEFAULT_EVICTION_TOKEN_LIMIT$1;
+/**
+* Approximate characters per token (rough estimate).
+*/
+const CHARS_PER_TOKEN = 4;
+/**
+* Sanitize a tool call ID for use as a filename.
+* Removes or replaces characters that are invalid in file paths.
+*/
+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;
+	};
+}
+
+//#endregion
+//#region src/tools/filesystem.ts
+/**
+* Filesystem tools for virtual file operations.
+*/
+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 tool({
+		description: LS_TOOL_DESCRIPTION,
+		inputSchema: z.object({ path: z.string().default(".").describe("Directory path to list (default: current directory)") }),
+		execute: async ({ path }) => {
+			const infos = await getBackend$1(backend, state).lsInfo(path || ".");
+			if (onEvent) onEvent({
+				type: "ls",
+				path: path || ".",
+				count: infos.length
+			});
+			if (infos.length === 0) return `No files found in ${path}`;
+			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 tool({
+		description: READ_FILE_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			file_path: z.string().describe("Path to the file to read (e.g., 'src/main.ts' or './main.ts')"),
+			offset: z.number().default(0).describe("Line offset to start reading from (0-indexed)"),
+			limit: 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 tool({
+		description: WRITE_FILE_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			file_path: z.string().describe("Path to the file to write (e.g., 'src/main.ts' or './main.ts')"),
+			content: 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 tool({
+		description: EDIT_FILE_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			file_path: z.string().describe("Path to the file to edit (e.g., 'src/main.ts' or './main.ts')"),
+			old_string: z.string().describe("String to be replaced (must match exactly)"),
+			new_string: z.string().describe("String to replace with"),
+			replace_all: 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 tool({
+		description: GLOB_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			pattern: z.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
+			path: z.string().default(".").describe("Base path to search from (default: current directory)")
+		}),
+		execute: async ({ pattern, path }) => {
+			const infos = await getBackend$1(backend, state).globInfo(pattern, path || ".");
+			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 tool({
+		description: GREP_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			pattern: z.string().describe("Regex pattern to search for"),
+			path: z.string().default(".").describe("Base path to search from (default: current directory)"),
+			glob: z.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
+		}),
+		execute: async ({ pattern, path, glob: glob$1 }, { toolCallId }) => {
+			const resolvedBackend = getBackend$1(backend, state);
+			const result = await resolvedBackend.grepRaw(pattern, path || ".", 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$1] of Object.entries(tools)) {
+		const config = interruptOn[name];
+		if (config === void 0 || config === false) result[name] = tool$1;
+		else result[name] = {
+			...tool$1,
+			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] = 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.
+*/
+/**
+* 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(html, { url });
+		const article = new Readability(dom.window.document).parse();
+		if (!article) return (dom.window.document.body?.textContent || "").trim();
+		const markdown = new TurndownService({
+			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)}`;
+	}
+}
+/**
+* Tool description for web_search.
+*/
+const WEB_SEARCH_TOOL_DESCRIPTION = `Search the web using Tavily API for current information, news, and documentation.
+
+Returns an array of search results with titles, URLs, relevant excerpts, and relevance scores.
+
+IMPORTANT AGENT INSTRUCTIONS:
+- You MUST synthesize information from search results into a coherent answer
+- NEVER show raw JSON or result objects to the user
+- Cite sources by including URLs in your response
+- If search fails or returns no results, explain this clearly to the user`;
+/**
+* Create the web_search tool.
+*/
+function createWebSearchTool(state, options) {
+	const { backend, onEvent, toolResultEvictionLimit, tavilyApiKey } = options;
+	return tool({
+		description: WEB_SEARCH_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			query: z.string().describe("The search query (be specific and detailed for best results)"),
+			max_results: z.number().default(5).describe("Number of results to return (1-20)"),
+			topic: z.enum([
+				"general",
+				"news",
+				"finance"
+			]).default("general").describe("Search topic category"),
+			include_raw_content: 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 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;
+			}
+		}
+	});
+}
+/**
+* Tool description for http_request.
+*/
+const HTTP_REQUEST_TOOL_DESCRIPTION = `Make HTTP requests to APIs and web services.
+
+Supports GET, POST, PUT, DELETE, PATCH methods with custom headers, query parameters, and request bodies.
+
+Returns structured response with status code, headers, and parsed content (JSON or text).`;
+/**
+* Create the http_request tool.
+*/
+function createHttpRequestTool(state, options) {
+	const { backend, onEvent, toolResultEvictionLimit, defaultTimeout } = options;
+	return tool({
+		description: HTTP_REQUEST_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			url: z.string().url().describe("Target URL (must be valid HTTP/HTTPS URL)"),
+			method: z.enum([
+				"GET",
+				"POST",
+				"PUT",
+				"DELETE",
+				"PATCH"
+			]).default("GET").describe("HTTP method"),
+			headers: z.record(z.string()).optional().describe("HTTP headers as key-value pairs"),
+			body: z.union([z.string(), z.record(z.any())]).optional().describe("Request body (string or JSON object)"),
+			params: z.record(z.string()).optional().describe("URL query parameters as key-value pairs"),
+			timeout: 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;
+			}
+		}
+	});
+}
+/**
+* Tool description for fetch_url.
+*/
+const FETCH_URL_TOOL_DESCRIPTION = `Fetch web page content and convert HTML to clean Markdown format.
+
+Uses Mozilla Readability to extract main article content and Turndown to convert to Markdown.
+
+Returns the page content as formatted Markdown, suitable for analysis and summarization.
+
+IMPORTANT AGENT INSTRUCTIONS:
+- Use this tool to read documentation, articles, and web pages
+- The content is already cleaned and formatted as Markdown
+- Cite the URL when referencing fetched content`;
+/**
+* Create the fetch_url tool.
+*/
+function createFetchUrlTool(state, options) {
+	const { backend, onEvent, toolResultEvictionLimit, defaultTimeout } = options;
+	return tool({
+		description: FETCH_URL_TOOL_DESCRIPTION,
+		inputSchema: z.object({
+			url: z.string().url().describe("The URL to fetch (must be valid HTTP/HTTPS URL)"),
+			timeout: z.number().default(defaultTimeout).describe("Request timeout in seconds"),
+			extract_article: 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(html, { url });
+				let contentToConvert = html;
+				if (extract_article) try {
+					const article = new 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 TurndownService({
+					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
+		})
+	};
+}
+/**
+* Individual builtin tool references for selective subagent configuration.
+* These are references to the creator functions, not instances.
+*/
+const web_search = createWebSearchTool;
+const http_request = createHttpRequestTool;
+const fetch_url = createFetchUrlTool;
+
+//#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 tool({
+		description: description || EXECUTE_TOOL_DESCRIPTION,
+		inputSchema: z.object({ command: 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.
+*/
+/**
+* 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 tool({
+		description: taskDescription || getTaskToolDescription(subagentDescriptions),
+		inputSchema: z.object({
+			description: z.string().describe("The task to execute with the selected agent"),
+			subagent_type: 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: stepCountIs(DEFAULT_SUBAGENT_MAX_STEPS),
+					...subagentConfig.output ? { output: 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 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.
+*/
+/**
+* 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 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.
+*/
+/**
+* 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 = 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.
+	* @private
+	*/
+	createWebToolSet(state, onEvent) {
+		return createWebTools(state, {
+			backend: this.backend,
+			onEvent,
+			toolResultEvictionLimit: this.toolResultEvictionLimit
+		});
+	}
+	/**
+	* 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(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 = 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 ToolLoopAgent({
+			...settings,
+			tools,
+			stopWhen: stopConditions
+		});
+	}
+	/**
+	* Load skills from directory asynchronously.
+	* Supports both legacy skillsDir and new agentId modes.
+	*/
+	async loadSkills(options) {
+		const { listSkills } = await import("./load-94gjHorc.mjs");
+		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 = 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 = 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
+export { SYSTEM_REMINDER_FILE_EMPTY as $, glob as A, StateBackend as B, createFilesystemTools as C, createReadFileTool as D, createLsTool as E, DEFAULT_EVICTION_TOKEN_LIMIT as F, formatReadResponse as G, createFileData as H, createToolResultWrapper as I, performStringReplacement as J, globSearchFiles as K, estimateTokens as L, ls as M, read_file as N, createWriteFileTool as O, write_file as P, STRING_NOT_FOUND as Q, evictToolResult as R, createEditFileTool as S, createGrepTool as T, fileDataToString as U, checkEmptyContent as V, formatContentWithLineNumbers as W, FILE_ALREADY_EXISTS as X, updateFileData as Y, FILE_NOT_FOUND as Z, createWebTools as _, estimateMessagesTokens as a, EXECUTE_SYSTEM_PROMPT as at, http_request as b, hasDanglingToolCalls as c, TODO_SYSTEM_PROMPT as ct, createExecuteTool as d, CONTEXT_WINDOW as dt, createTodosTool as et, createExecuteToolFromBackend as f, DEFAULT_EVICTION_TOKEN_LIMIT$1 as ft, createWebSearchTool as g, MAX_FILE_SIZE_MB as gt, createHttpRequestTool as h, DEFAULT_SUMMARIZATION_THRESHOLD$1 as ht, DEFAULT_SUMMARIZATION_THRESHOLD as i, DEFAULT_SUBAGENT_PROMPT as it, grep as j, edit_file as k, patchToolCalls as l, getTaskToolDescription as lt, createFetchUrlTool as m, DEFAULT_READ_LIMIT as mt, createDeepAgent as n, BASE_PROMPT as nt, needsSummarization as o, FILESYSTEM_SYSTEM_PROMPT as ot, execute as p, DEFAULT_KEEP_MESSAGES$1 as pt, grepMatchesFromFiles as q, DEFAULT_KEEP_MESSAGES as r, DEFAULT_GENERAL_PURPOSE_DESCRIPTION as rt, summarizeIfNeeded as s, TASK_SYSTEM_PROMPT as st, DeepAgent as t, write_todos as tt, createSubagentTool as u, isSandboxBackend as ut, fetch_url as v, createGlobTool as w, web_search as x, htmlToMarkdown as y, shouldEvict as z };
+//# sourceMappingURL=agent-CrH-He58.mjs.map