deepagents 1.6.3 → 1.7.0

package/dist/index.js

@@ -1,4 +1,5 @@
 import { AIMessage, SystemMessage, ToolMessage, anthropicPromptCachingMiddleware, createAgent, createMiddleware, humanInTheLoopMiddleware, summarizationMiddleware, todoListMiddleware, tool } from "langchain";
+import { Runnable } from "@langchain/core/runnables";
 import { Command, REMOVE_ALL_MESSAGES, ReducedValue, StateSchema, getCurrentTaskInput, isCommand } from "@langchain/langgraph";
 import { z } from "zod/v4";
 import micromatch from "micromatch";
@@ -7,7 +8,7 @@ import { HumanMessage, RemoveMessage } from "@langchain/core/messages";
 import { z as z$1 } from "zod";
 import yaml from "yaml";
 import "uuid";
-import "@langchain/openai";
+import "langchain/chat_models/universal";
 import fs from "node:fs/promises";
 import fs$1 from "node:fs";
 import path from "node:path";
@@ -247,17 +248,13 @@ 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}`;
-	}
 	let normalizedPath;
 	try {
 		normalizedPath = validatePath(path);
@@ -273,7 +270,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
@@ -680,11 +677,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:
@@ -969,14 +968,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) => {
@@ -1046,12 +1044,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 `
@@ -1166,6 +1186,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.
@@ -1194,6 +1227,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) {
@@ -1221,12 +1296,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(humanInTheLoopMiddleware({ interruptOn: defaultInterruptOn }));
 		agents["general-purpose"] = createAgent({
 			model: defaultModel,
@@ -1260,11 +1336,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
@@ -1294,13 +1371,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 createMiddleware({
 		name: "subAgentMiddleware",
 		tools: [createTaskTool({
 			defaultModel,
 			defaultTools,
 			defaultMiddleware,
+			generalPurposeMiddleware,
 			defaultInterruptOn,
 			subagents,
 			generalPurposeAgent,
@@ -2356,7 +2434,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 = fs$1.constants.O_NOFOLLOW !== void 0;
@@ -2605,14 +2683,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 || ".");
@@ -2625,7 +2705,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,
@@ -2635,12 +2715,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 = spawn("rg", args, { timeout: 3e4 });
@@ -2689,15 +2774,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 fg("**/*", {
 			cwd: (await fs.stat(baseFull)).isDirectory() ? baseFull : path.dirname(baseFull),
@@ -2711,7 +2797,7 @@ var FilesystemBackend = class {
 			const lines = (await fs.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 = path.relative(this.cwd, fp);
@@ -3275,7 +3361,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);
@@ -3289,14 +3379,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
@@ -3321,7 +3403,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,
@@ -3417,14 +3500,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 {
@@ -3553,6 +3638,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 (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 = [
+		todoListMiddleware(),
+		createFilesystemMiddleware({ backend: filesystemBackend }),
+		summarizationMiddleware({
+			model,
+			trigger: { tokens: 17e4 },
+			keep: { messages: 6 }
+		}),
+		anthropicPromptCachingMiddleware({ unsupportedModelBehavior: "ignore" }),
+		createPatchToolCallsMiddleware()
+	];
+	/**
 	* Return as DeepAgent with proper DeepAgentTypeConfig
 	* - Response: TResponse (from responseFormat parameter)
 	* - State: undefined (state comes from middleware)
@@ -3572,20 +3702,10 @@ function createDeepAgent(params = {}) {
 				createSubAgentMiddleware({
 					defaultModel: model,
 					defaultTools: tools,
-					defaultMiddleware: [
-						todoListMiddleware(),
-						...skillsMiddlewareArray,
-						createFilesystemMiddleware({ backend: filesystemBackend }),
-						summarizationMiddleware({
-							model,
-							trigger: { tokens: 17e4 },
-							keep: { messages: 6 }
-						}),
-						anthropicPromptCachingMiddleware({ unsupportedModelBehavior: "ignore" }),
-						createPatchToolCallsMiddleware()
-					],
+					defaultMiddleware: subagentMiddleware,
+					generalPurposeMiddleware: [...subagentMiddleware, ...skillsMiddlewareArray],
 					defaultInterruptOn: interruptOn,
-					subagents,
+					subagents: processedSubagents,
 					generalPurposeAgent: true
 				}),
 				summarizationMiddleware({
@@ -4154,5 +4274,5 @@ function listSkills(options) {
 }
 
 //#endregion
-export { BaseSandbox, CompositeBackend, FilesystemBackend, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, StateBackend, StoreBackend, createAgentMemoryMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgentMiddleware, filesValue, findProjectRoot, isSandboxBackend, listSkills, parseSkillMetadata };
+export { BaseSandbox, CompositeBackend, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT, FilesystemBackend, GENERAL_PURPOSE_SUBAGENT, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, StateBackend, StoreBackend, TASK_SYSTEM_PROMPT, createAgentMemoryMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgentMiddleware, filesValue, findProjectRoot, isSandboxBackend, listSkills, parseSkillMetadata };
 //# sourceMappingURL=index.js.map