deepagents 1.6.3 → 1.7.1

package/README.md

@@ -1,25 +1,39 @@
-# 🧠🤖 Deep Agents
-
-Using an LLM to call tools in a loop is the simplest form of an agent.
-This architecture, however, can yield agents that are "shallow" and fail to plan and act over longer, more complex tasks.
+<div align="center">
+  <a href="https://docs.langchain.com/oss/python/deepagents/overview#deep-agents-overview">
+    <picture>
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/langchain-ai/deepagentsjs/refs/heads/main/.github/images/logo-dark.svg">
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/langchain-ai/deepagentsjs/refs/heads/main/.github/images/logo-light.svg">
+      <img alt="Deep Agents Logo" src="https://raw.githubusercontent.com/langchain-ai/deepagentsjs/refs/heads/main/.github/images/logo-dark.svg" width="80%">
+    </picture>
+  </a>
+</div>
+
+<div align="center">
+  <h3>The batteries-included agent harness.</h3>
+</div>
+
+<div align="center">
+  <a href="https://www.npmjs.com/package/deepagents"><img src="https://img.shields.io/npm/v/deepagents.svg" alt="npm version"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+  <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-5.0+-blue.svg" alt="TypeScript"></a>
+  <a href="https://x.com/LangChain_JS" target="_blank"><img src="https://img.shields.io/twitter/url/https/twitter.com/LangChain_JS.svg?style=social&label=Follow%20%40LangChain_JS" alt="Twitter / X"></a>
+</div>
+
+Using an LLM to call tools in a loop is the simplest form of an agent. This architecture, however, can yield agents that are "shallow" and fail to plan and act over longer, more complex tasks.
 
 Applications like "Deep Research", "Manus", and "Claude Code" have gotten around this limitation by implementing a combination of four things:
 a **planning tool**, **sub agents**, access to a **file system**, and a **detailed prompt**.
 
-> 💡 **Tip:** Looking for the Python version of this package? See [langchain-ai/deepagents](https://github.com/langchain-ai/deepagents)
-
-![Deep Agents](https://blog.langchain.com/content/images/2025/07/Screenshot-2025-07-30-at-9.08.32-AM.png)
-
 `deepagents` is a TypeScript package that implements these in a general purpose way so that you can easily create a Deep Agent for your application.
 
-**Acknowledgements: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.**
+> 💡 **Tip:** Looking for the Python version of this package? See [langchain-ai/deepagents](https://github.com/langchain-ai/deepagents)
 
-[![npm version](https://img.shields.io/npm/v/deepagents.svg)](https://www.npmjs.com/package/deepagents)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+<div align="center">
 
 [Documentation](https://docs.langchain.com/oss/javascript/deepagents/overview) | [Examples](./examples) | [Report Bug](https://github.com/langchain-ai/deepagentsjs/issues) | [Request Feature](https://github.com/langchain-ai/deepagentsjs/issues)
 
+</div>
+
 ## 📖 Overview
 
 Using an LLM to call tools in a loop is the simplest form of an agent. However, this architecture can yield agents that are "shallow" and fail to plan and act over longer, more complex tasks.
@@ -316,6 +330,7 @@ interface SubAgent {
   model?: LanguageModelLike | string;
   middleware?: AgentMiddleware[];
   interruptOn?: Record<string, boolean | InterruptOnConfig>;
+  skills?: string[];
 }
 ```
 
@@ -328,6 +343,37 @@ interface SubAgent {
 - **model**: Optional model name or model instance.
 - **middleware**: Additional middleware to attach to the subagent. See [here](https://docs.langchain.com/oss/typescript/langchain/middleware) for an introduction into middleware and how it works with createAgent.
 - **interruptOn**: A custom interrupt config that specifies human-in-the-loop interactions for your tools.
+- **skills**: Skill source paths for the subagent (e.g., `["/skills/research/"]`). See skills inheritance below.
+
+#### Skills Inheritance
+
+When you configure `skills` on the main agent via `createDeepAgent`, the behavior differs between subagent types:
+
+- **General-purpose subagent**: Automatically inherits skills from the main agent. This subagent has access to all the same skills as the main agent.
+- **Custom subagents**: Do NOT inherit skills from the main agent by default. If you want a custom subagent to have access to skills, you must explicitly define the `skills` property on that subagent.
+
+```typescript
+const agent = createDeepAgent({
+  model: "claude-sonnet-4-20250514",
+  skills: ["/skills/"], // Main agent and general-purpose subagent get these skills
+  subagents: [
+    {
+      name: "researcher",
+      description: "Research assistant",
+      systemPrompt: "You are a researcher.",
+      // This subagent will NOT have access to /skills/ from the main agent
+    },
+    {
+      name: "coder",
+      description: "Coding assistant",
+      systemPrompt: "You are a coder.",
+      skills: ["/skills/coding/"], // This subagent has its own skills
+    },
+  ],
+});
+```
+
+This design ensures context isolation - custom subagents only have access to the skills they explicitly need, preventing unintended skill leakage between specialized agents.
 
 #### Using SubAgent
 

package/dist/index.cjs

@@ -1,4 +1,5 @@
-//#region rolldown:runtime
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -26,6 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 let langchain = require("langchain");
+let _langchain_core_runnables = require("@langchain/core/runnables");
 let _langchain_langgraph = require("@langchain/langgraph");
 let zod_v4 = require("zod/v4");
 let micromatch = require("micromatch");
@@ -36,7 +38,7 @@ let zod = require("zod");
 let yaml = require("yaml");
 yaml = __toESM(yaml);
 require("uuid");
-require("@langchain/openai");
+require("langchain/chat_models/universal");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
 let node_fs = require("node:fs");
@@ -59,6 +61,55 @@ node_os = __toESM(node_os);
 function isSandboxBackend(backend) {
 	return typeof backend.execute === "function" && typeof backend.id === "string";
 }
+const SANDBOX_ERROR_SYMBOL = Symbol.for("sandbox.error");
+/**
+* Custom error class for sandbox operations.
+*
+* @param message - Human-readable error description
+* @param code - Structured error code for programmatic handling
+* @returns SandboxError with message and code
+*
+* @example
+* ```typescript
+* try {
+*   await sandbox.execute("some command");
+* } catch (error) {
+*   if (error instanceof SandboxError) {
+*     switch (error.code) {
+*       case "NOT_INITIALIZED":
+*         await sandbox.initialize();
+*         break;
+*       case "COMMAND_TIMEOUT":
+*         console.error("Command took too long");
+*         break;
+*       default:
+*         throw error;
+*     }
+*   }
+* }
+* ```
+*/
+var SandboxError = class SandboxError extends Error {
+	/** Symbol for identifying sandbox error instances */
+	[SANDBOX_ERROR_SYMBOL] = true;
+	/** Error name for instanceof checks and logging */
+	name = "SandboxError";
+	/**
+	* Creates a new SandboxError.
+	*
+	* @param message - Human-readable error description
+	* @param code - Structured error code for programmatic handling
+	*/
+	constructor(message, code, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		Object.setPrototypeOf(this, SandboxError.prototype);
+	}
+	static isInstance(error) {
+		return typeof error === "object" && error !== null && error[SANDBOX_ERROR_SYMBOL] === true;
+	}
+};
 
 //#endregion
 //#region src/backends/utils.ts
@@ -229,8 +280,8 @@ function performStringReplacement(content, oldString, newString, replaceAll) {
 * validatePath("C:\\Users\\file")  // Throws: Windows absolute paths not supported
 * ```
 */
-function validatePath(path) {
-	const pathStr = path || "/";
+function validatePath(path$4) {
+	const pathStr = path$4 || "/";
 	if (!pathStr || pathStr.trim() === "") throw new Error("Path cannot be empty");
 	let normalized = pathStr.startsWith("/") ? pathStr : "/" + pathStr;
 	if (!normalized.endsWith("/")) normalized += "/";
@@ -252,10 +303,10 @@ function validatePath(path) {
 * // Returns: "/test.py\n/src/main.py" (sorted by modified_at)
 * ```
 */
-function globSearchFiles(files, pattern, path = "/") {
+function globSearchFiles(files, pattern, path$6 = "/") {
 	let normalizedPath;
 	try {
-		normalizedPath = validatePath(path);
+		normalizedPath = validatePath(path$6);
 	} catch {
 		return "No files found";
 	}
@@ -281,20 +332,16 @@ function globSearchFiles(files, pattern, path = "/") {
 /**
 * Return structured grep matches from an in-memory files mapping.
 *
-* Returns a list of GrepMatch on success, or a string for invalid inputs
-* (e.g., invalid regex). We deliberately do not raise here to keep backends
-* non-throwing in tool contexts and preserve user-facing error messages.
+* Performs literal text search (not regex).
+*
+* Returns a list of GrepMatch on success, or a string for invalid inputs.
+* We deliberately do not raise here to keep backends non-throwing in tool
+* contexts and preserve user-facing error messages.
 */
-function grepMatchesFromFiles(files, pattern, path = null, glob = null) {
-	let regex;
-	try {
-		regex = new RegExp(pattern);
-	} catch (e) {
-		return `Invalid regex pattern: ${e.message}`;
-	}
+function grepMatchesFromFiles(files, pattern, path$8 = null, glob = null) {
 	let normalizedPath;
 	try {
-		normalizedPath = validatePath(path);
+		normalizedPath = validatePath(path$8);
 	} catch {
 		return [];
 	}
@@ -307,7 +354,7 @@ function grepMatchesFromFiles(files, pattern, path = null, glob = null) {
 	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 (regex.test(line)) matches.push({
+		if (line.includes(pattern)) matches.push({
 			path: filePath,
 			line: lineNum,
 			text: line
@@ -714,11 +761,13 @@ Examples:
 const GREP_TOOL_DESCRIPTION = `Search for a text pattern across files.
 
 Searches for literal text (not regex) and returns matching files or content based on output_mode.
+Special characters like parentheses, brackets, pipes, etc. are treated as literal characters, not regex operators.
 
 Examples:
 - Search all files: \`grep(pattern="TODO")\`
 - Search Python files only: \`grep(pattern="import", glob="*.py")\`
-- Show matching lines: \`grep(pattern="error", output_mode="content")\``;
+- Show matching lines: \`grep(pattern="error", output_mode="content")\`
+- Search for code with special chars: \`grep(pattern="def __init__(self):")\``;
 const EXECUTE_TOOL_DESCRIPTION = `Executes a shell command in an isolated sandbox environment.
 
 Usage:
@@ -1003,14 +1052,13 @@ function createFilesystemMiddleware(options = {}) {
 			}));
 			let tools = request.tools;
 			if (!supportsExecution) tools = tools.filter((t) => t.name !== "execute");
-			let systemPrompt = baseSystemPrompt;
-			if (supportsExecution) systemPrompt = `${systemPrompt}\n\n${EXECUTION_SYSTEM_PROMPT}`;
-			const currentSystemPrompt = request.systemPrompt || "";
-			const newSystemPrompt = currentSystemPrompt ? `${currentSystemPrompt}\n\n${systemPrompt}` : systemPrompt;
+			let filesystemPrompt = baseSystemPrompt;
+			if (supportsExecution) filesystemPrompt = `${filesystemPrompt}\n\n${EXECUTION_SYSTEM_PROMPT}`;
+			const newSystemMessage = request.systemMessage.concat(filesystemPrompt);
 			return handler({
 				...request,
 				tools,
-				systemPrompt: newSystemPrompt
+				systemMessage: newSystemMessage
 			});
 		},
 		wrapToolCall: async (request, handler) => {
@@ -1080,12 +1128,34 @@ function createFilesystemMiddleware(options = {}) {
 
 //#endregion
 //#region src/middleware/subagents.ts
+/**
+* Default system prompt for subagents.
+* Provides a minimal base prompt that can be extended by specific subagent configurations.
+*/
 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.";
+/**
+* State keys that are excluded when passing state to subagents and when returning
+* updates from subagents.
+*
+* When returning updates:
+* 1. The messages key is handled explicitly to ensure only the final message is included
+* 2. The todos and structuredResponse keys are excluded as they do not have a defined reducer
+*    and no clear meaning for returning them from a subagent to the main agent.
+* 3. The skillsMetadata and memoryContents keys are automatically excluded from subagent output
+*    to prevent parent state from leaking to child agents. Each agent loads its own skills/memory
+*    independently based on its middleware configuration.
+*/
 const EXCLUDED_STATE_KEYS = [
 	"messages",
 	"todos",
-	"structuredResponse"
+	"structuredResponse",
+	"skillsMetadata",
+	"memoryContents"
 ];
+/**
+* Default description for the general-purpose subagent.
+* This description is shown to the model when selecting which subagent to use.
+*/
 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.";
 function getTaskToolDescription(subagentDescriptions) {
 	return `
@@ -1200,6 +1270,19 @@ assistant: "I'm going to use the Task tool to launch with the greeting-responder
 </example>
   `.trim();
 }
+/**
+* System prompt section that explains how to use the task tool for spawning subagents.
+*
+* This prompt is automatically appended to the main agent's system prompt when
+* using `createSubAgentMiddleware`. It provides guidance on:
+* - When to use the task tool
+* - Subagent lifecycle (spawn → run → return → reconcile)
+* - When NOT to use the task tool
+* - Best practices for parallel task execution
+*
+* You can provide a custom `systemPrompt` to `createSubAgentMiddleware` to override
+* or extend this default.
+*/
 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.
@@ -1228,6 +1311,48 @@ When NOT to use the task tool:
 - 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. These agents are highly competent and efficient.`;
 /**
+* Base specification for the general-purpose subagent.
+*
+* This constant provides the default configuration for the general-purpose subagent
+* that is automatically included when `generalPurposeAgent: true` (the default).
+*
+* The general-purpose subagent:
+* - Has access to all tools from the main agent
+* - Inherits skills from the main agent (when skills are configured)
+* - Uses the same model as the main agent (by default)
+* - Is ideal for delegating complex, multi-step tasks
+*
+* You can spread this constant and override specific properties when creating
+* custom subagents that should behave similarly to the general-purpose agent:
+*
+* @example
+* ```typescript
+* import { GENERAL_PURPOSE_SUBAGENT, createDeepAgent } from "@anthropic/deepagents";
+*
+* // Use as-is (automatically included with generalPurposeAgent: true)
+* const agent = createDeepAgent({ model: "claude-sonnet-4-5-20250929" });
+*
+* // Or create a custom variant with different tools
+* const customGP: SubAgent = {
+*   ...GENERAL_PURPOSE_SUBAGENT,
+*   name: "research-gp",
+*   tools: [webSearchTool, readFileTool],
+* };
+*
+* const agent = createDeepAgent({
+*   model: "claude-sonnet-4-5-20250929",
+*   subagents: [customGP],
+*   // Disable the default general-purpose agent since we're providing our own
+*   // (handled automatically when using createSubAgentMiddleware directly)
+* });
+* ```
+*/
+const GENERAL_PURPOSE_SUBAGENT = {
+	name: "general-purpose",
+	description: DEFAULT_GENERAL_PURPOSE_DESCRIPTION,
+	systemPrompt: DEFAULT_SUBAGENT_PROMPT
+};
+/**
 * Filter state to exclude certain keys when passing to subagents
 */
 function filterStateForSubagent(state) {
@@ -1255,12 +1380,13 @@ function returnCommandWithStateUpdate(result, toolCallId) {
 * Create subagent instances from specifications
 */
 function getSubagents(options) {
-	const { defaultModel, defaultTools, defaultMiddleware, defaultInterruptOn, subagents, generalPurposeAgent } = options;
+	const { defaultModel, defaultTools, defaultMiddleware, generalPurposeMiddleware: gpMiddleware, defaultInterruptOn, subagents, generalPurposeAgent } = options;
 	const defaultSubagentMiddleware = defaultMiddleware || [];
+	const generalPurposeMiddlewareBase = gpMiddleware || defaultSubagentMiddleware;
 	const agents = {};
 	const subagentDescriptions = [];
 	if (generalPurposeAgent) {
-		const generalPurposeMiddleware = [...defaultSubagentMiddleware];
+		const generalPurposeMiddleware = [...generalPurposeMiddlewareBase];
 		if (defaultInterruptOn) generalPurposeMiddleware.push((0, langchain.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn }));
 		agents["general-purpose"] = (0, langchain.createAgent)({
 			model: defaultModel,
@@ -1294,11 +1420,12 @@ function getSubagents(options) {
 * Create the task tool for invoking subagents
 */
 function createTaskTool(options) {
-	const { defaultModel, defaultTools, defaultMiddleware, defaultInterruptOn, subagents, generalPurposeAgent, taskDescription } = options;
+	const { defaultModel, defaultTools, defaultMiddleware, generalPurposeMiddleware, defaultInterruptOn, subagents, generalPurposeAgent, taskDescription } = options;
 	const { agents: subagentGraphs, descriptions: subagentDescriptions } = getSubagents({
 		defaultModel,
 		defaultTools,
 		defaultMiddleware,
+		generalPurposeMiddleware,
 		defaultInterruptOn,
 		subagents,
 		generalPurposeAgent
@@ -1328,13 +1455,14 @@ function createTaskTool(options) {
 * Create subagent middleware with task tool
 */
 function createSubAgentMiddleware(options) {
-	const { defaultModel, defaultTools = [], defaultMiddleware = null, defaultInterruptOn = null, subagents = [], systemPrompt = TASK_SYSTEM_PROMPT, generalPurposeAgent = true, taskDescription = null } = options;
+	const { defaultModel, defaultTools = [], defaultMiddleware = null, generalPurposeMiddleware = null, defaultInterruptOn = null, subagents = [], systemPrompt = TASK_SYSTEM_PROMPT, generalPurposeAgent = true, taskDescription = null } = options;
 	return (0, langchain.createMiddleware)({
 		name: "subAgentMiddleware",
 		tools: [createTaskTool({
 			defaultModel,
 			defaultTools,
 			defaultMiddleware,
+			generalPurposeMiddleware,
 			defaultInterruptOn,
 			subagents,
 			generalPurposeAgent,
@@ -2398,7 +2526,7 @@ var StoreBackend = class {
 * Security and search upgrades:
 * - Secure path resolution with root containment when in virtual_mode (sandboxed to cwd)
 * - Prevent symlink-following on file I/O using O_NOFOLLOW when available
-* - Ripgrep-powered grep with JSON parsing, plus regex fallback
+* - Ripgrep-powered grep with literal (fixed-string) search, plus substring fallback
 *   and optional glob include filtering, while preserving virtual path behavior
 */
 const SUPPORTS_NOFOLLOW = node_fs.default.constants.O_NOFOLLOW !== void 0;
@@ -2647,14 +2775,16 @@ var FilesystemBackend = class {
 		}
 	}
 	/**
-	* Structured search results or error string for invalid input.
+	* Search for a literal text pattern in files.
+	*
+	* Uses ripgrep if available, falling back to substring search.
+	*
+	* @param pattern - Literal string to search for (NOT regex).
+	* @param dirPath - Directory or file path to search in. Defaults to current directory.
+	* @param glob - Optional glob pattern to filter which files to search.
+	* @returns List of GrepMatch dicts containing path, line number, and matched text.
 	*/
 	async grepRaw(pattern, dirPath = "/", glob = null) {
-		try {
-			new RegExp(pattern);
-		} catch (e) {
-			return `Invalid regex pattern: ${e.message}`;
-		}
 		let baseFull;
 		try {
 			baseFull = this.resolvePath(dirPath || ".");
@@ -2667,7 +2797,7 @@ var FilesystemBackend = class {
 			return [];
 		}
 		let results = await this.ripgrepSearch(pattern, baseFull, glob);
-		if (results === null) results = await this.pythonSearch(pattern, baseFull, glob);
+		if (results === null) results = await this.literalSearch(pattern, baseFull, glob);
 		const matches = [];
 		for (const [fpath, items] of Object.entries(results)) for (const [lineNum, lineText] of items) matches.push({
 			path: fpath,
@@ -2677,12 +2807,17 @@ var FilesystemBackend = class {
 		return matches;
 	}
 	/**
-	* Try to use ripgrep for fast searching.
-	* Returns null if ripgrep is not available or fails.
+	* Search using ripgrep with fixed-string (literal) mode.
+	*
+	* @param pattern - Literal string to search for (unescaped).
+	* @param baseFull - Resolved base path to search in.
+	* @param includeGlob - Optional glob pattern to filter files.
+	* @returns Dict mapping file paths to list of (line_number, line_text) tuples.
+	*          Returns null if ripgrep is unavailable or times out.
 	*/
 	async ripgrepSearch(pattern, baseFull, includeGlob) {
 		return new Promise((resolve) => {
-			const args = ["--json"];
+			const args = ["--json", "-F"];
 			if (includeGlob) args.push("--glob", includeGlob);
 			args.push("--", pattern, baseFull);
 			const proc = (0, node_child_process.spawn)("rg", args, { timeout: 3e4 });
@@ -2731,15 +2866,16 @@ var FilesystemBackend = class {
 		});
 	}
 	/**
-	* Fallback regex search implementation.
+	* Fallback search using literal substring matching when ripgrep is unavailable.
+	*
+	* Recursively searches files, respecting maxFileSizeBytes limit.
+	*
+	* @param pattern - Literal string to search for.
+	* @param baseFull - Resolved base path to search in.
+	* @param includeGlob - Optional glob pattern to filter files by name.
+	* @returns Dict mapping file paths to list of (line_number, line_text) tuples.
 	*/
-	async pythonSearch(pattern, baseFull, includeGlob) {
-		let regex;
-		try {
-			regex = new RegExp(pattern);
-		} catch {
-			return {};
-		}
+	async literalSearch(pattern, baseFull, includeGlob) {
 		const results = {};
 		const files = await (0, fast_glob.default)("**/*", {
 			cwd: (await node_fs_promises.default.stat(baseFull)).isDirectory() ? baseFull : node_path.default.dirname(baseFull),
@@ -2753,7 +2889,7 @@ var FilesystemBackend = class {
 			const lines = (await node_fs_promises.default.readFile(fp, "utf-8")).split("\n");
 			for (let i = 0; i < lines.length; i++) {
 				const line = lines[i];
-				if (regex.test(line)) {
+				if (line.includes(pattern)) {
 					let virtPath;
 					if (this.virtualMode) try {
 						const relative = node_path.default.relative(this.cwd, fp);
@@ -3317,7 +3453,11 @@ console.log(count);
 "`;
 }
 /**
-* Node.js command template for grep operations.
+* Node.js command template for grep operations with literal (fixed-string) search.
+*
+* @param pattern - Literal string to search for (NOT regex).
+* @param searchPath - Base path to search in.
+* @param globPattern - Optional glob pattern to filter files.
 */
 function buildGrepCommand(pattern, searchPath, globPattern) {
 	const patternB64 = btoa(pattern);
@@ -3331,14 +3471,6 @@ const pattern = atob('${patternB64}');
 const searchPath = atob('${pathB64}');
 const globPattern = ${globPattern ? `atob('${globB64}')` : "null"};
 
-let regex;
-try {
-  regex = new RegExp(pattern);
-} catch (e) {
-  console.error('Invalid regex: ' + e.message);
-  process.exit(1);
-}
-
 function globMatch(filePath, pattern) {
   if (!pattern) return true;
   const regexPattern = pattern
@@ -3363,7 +3495,8 @@ function walkDir(dir, results) {
             const content = fs.readFileSync(fullPath, 'utf-8');
             const lines = content.split('\\n');
             for (let i = 0; i < lines.length; i++) {
-              if (regex.test(lines[i])) {
+              // Simple substring search for literal matching
+              if (lines[i].includes(pattern)) {
                 console.log(JSON.stringify({
                   path: fullPath,
                   line: i + 1,
@@ -3459,14 +3592,16 @@ var BaseSandbox = class {
 		};
 	}
 	/**
-	* Structured search results or error string for invalid input.
+	* Search for a literal text pattern in files.
+	*
+	* @param pattern - Literal string to search for (NOT regex).
+	* @param path - Directory or file path to search in.
+	* @param glob - Optional glob pattern to filter which files to search.
+	* @returns List of GrepMatch dicts containing path, line number, and matched text.
 	*/
 	async grepRaw(pattern, path = "/", glob = null) {
 		const command = buildGrepCommand(pattern, path, glob);
 		const result = await this.execute(command);
-		if (result.exitCode === 1) {
-			if (result.output.includes("Invalid regex:")) return result.output.trim();
-		}
 		const matches = [];
 		const lines = result.output.trim().split("\n").filter(Boolean);
 		for (const line of lines) try {
@@ -3595,6 +3730,51 @@ function createDeepAgent(params = {}) {
 		sources: memory
 	})] : [];
 	/**
+	* Process subagents to add SkillsMiddleware for those with their own skills.
+	*
+	* Custom subagents do NOT inherit skills from the main agent by default.
+	* Only the general-purpose subagent inherits the main agent's skills (via defaultMiddleware).
+	* If a custom subagent needs skills, it must specify its own `skills` array.
+	*/
+	const processedSubagents = subagents.map((subagent) => {
+		/**
+		* CompiledSubAgent - use as-is (already has its own middleware baked in)
+		*/
+		if (_langchain_core_runnables.Runnable.isRunnable(subagent)) return subagent;
+		/**
+		* SubAgent without skills - use as-is
+		*/
+		if (!("skills" in subagent) || subagent.skills?.length === 0) return subagent;
+		/**
+		* SubAgent with skills - add SkillsMiddleware BEFORE user's middleware
+		* Order: base middleware (via defaultMiddleware) → skills → user's middleware
+		* This matches Python's ordering in create_deep_agent
+		*/
+		const subagentSkillsMiddleware = createSkillsMiddleware({
+			backend: filesystemBackend,
+			sources: subagent.skills ?? []
+		});
+		return {
+			...subagent,
+			middleware: [subagentSkillsMiddleware, ...subagent.middleware || []]
+		};
+	});
+	/**
+	* Middleware for custom subagents (does NOT include skills from main agent).
+	* Custom subagents must define their own `skills` property to get skills.
+	*/
+	const subagentMiddleware = [
+		(0, langchain.todoListMiddleware)(),
+		createFilesystemMiddleware({ backend: filesystemBackend }),
+		(0, langchain.summarizationMiddleware)({
+			model,
+			trigger: { tokens: 17e4 },
+			keep: { messages: 6 }
+		}),
+		(0, langchain.anthropicPromptCachingMiddleware)({ unsupportedModelBehavior: "ignore" }),
+		createPatchToolCallsMiddleware()
+	];
+	/**
 	* Return as DeepAgent with proper DeepAgentTypeConfig
 	* - Response: TResponse (from responseFormat parameter)
 	* - State: undefined (state comes from middleware)
@@ -3614,20 +3794,10 @@ function createDeepAgent(params = {}) {
 				createSubAgentMiddleware({
 					defaultModel: model,
 					defaultTools: tools,
-					defaultMiddleware: [
-						(0, langchain.todoListMiddleware)(),
-						...skillsMiddlewareArray,
-						createFilesystemMiddleware({ backend: filesystemBackend }),
-						(0, langchain.summarizationMiddleware)({
-							model,
-							trigger: { tokens: 17e4 },
-							keep: { messages: 6 }
-						}),
-						(0, langchain.anthropicPromptCachingMiddleware)({ unsupportedModelBehavior: "ignore" }),
-						createPatchToolCallsMiddleware()
-					],
+					defaultMiddleware: subagentMiddleware,
+					generalPurposeMiddleware: [...subagentMiddleware, ...skillsMiddlewareArray],
 					defaultInterruptOn: interruptOn,
-					subagents,
+					subagents: processedSubagents,
 					generalPurposeAgent: true
 				}),
 				(0, langchain.summarizationMiddleware)({
@@ -4198,12 +4368,17 @@ function listSkills(options) {
 //#endregion
 exports.BaseSandbox = BaseSandbox;
 exports.CompositeBackend = CompositeBackend;
+exports.DEFAULT_GENERAL_PURPOSE_DESCRIPTION = DEFAULT_GENERAL_PURPOSE_DESCRIPTION;
+exports.DEFAULT_SUBAGENT_PROMPT = DEFAULT_SUBAGENT_PROMPT;
 exports.FilesystemBackend = FilesystemBackend;
+exports.GENERAL_PURPOSE_SUBAGENT = GENERAL_PURPOSE_SUBAGENT;
 exports.MAX_SKILL_DESCRIPTION_LENGTH = MAX_SKILL_DESCRIPTION_LENGTH;
 exports.MAX_SKILL_FILE_SIZE = MAX_SKILL_FILE_SIZE;
 exports.MAX_SKILL_NAME_LENGTH = MAX_SKILL_NAME_LENGTH;
+exports.SandboxError = SandboxError;
 exports.StateBackend = StateBackend;
 exports.StoreBackend = StoreBackend;
+exports.TASK_SYSTEM_PROMPT = TASK_SYSTEM_PROMPT;
 exports.createAgentMemoryMiddleware = createAgentMemoryMiddleware;
 exports.createDeepAgent = createDeepAgent;
 exports.createFilesystemMiddleware = createFilesystemMiddleware;