deepagents 1.6.1 → 1.6.3

package/dist/index.js

@@ -159,8 +159,14 @@ function formatReadResponse(fileData, offset, limit) {
 * @param newString - Replacement string
 * @param replaceAll - Whether to replace all occurrences
 * @returns Tuple of [new_content, occurrences] on success, or error message string
+*
+* Special case: When both content and oldString are empty, this sets the initial
+* content to newString. This allows editing empty files by treating empty oldString
+* as "set initial content" rather than "replace nothing".
 */
 function performStringReplacement(content, oldString, newString, replaceAll) {
+	if (content === "" && oldString === "") return [newString, 0];
+	if (oldString === "") return "Error: oldString cannot be empty when file has content";
 	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.`;
@@ -523,6 +529,18 @@ const TOOLS_EXCLUDED_FROM_EVICTION = [
 */
 const NUM_CHARS_PER_TOKEN = 4;
 /**
+* Default values for read_file tool pagination (in lines).
+*/
+const DEFAULT_READ_LINE_OFFSET = 0;
+const DEFAULT_READ_LINE_LIMIT = 100;
+/**
+* Template for truncation message in read_file.
+* {file_path} will be filled in at runtime.
+*/
+const READ_FILE_TRUNCATION_MSG = `
+
+[Output was truncated due to size limits. The file content is very large. Consider reformatting the file to make it easier to navigate. For example, if this is JSON, use execute(command='jq . {file_path}') to pretty-print it with line breaks. For other formats, you can use appropriate formatting tools to split long lines.]`;
+/**
 * Message template for evicted tool results.
 */
 const TOO_LARGE_TOOL_MSG = `Tool result too large, the result of this tool call {tool_call_id} was saved in the filesystem at this path: {file_path}
@@ -627,7 +645,7 @@ const READ_FILE_TOOL_DESCRIPTION = `Reads a file from the filesystem.
 Assume this tool is able to read all files. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
 
 Usage:
-- By default, it reads up to 500 lines starting from the beginning of the file
+- By default, it reads up to 100 lines starting from the beginning of the file
 - **IMPORTANT for large files and codebase exploration**: Use pagination with offset and limit parameters to avoid context overflow
   - First scan: read_file(path, limit=100) to see file structure
   - Read more sections: read_file(path, offset=100, limit=200) for next 200 lines
@@ -747,21 +765,29 @@ function createLsTool(backend, options) {
 * Create read_file tool using backend.
 */
 function createReadFileTool(backend, options) {
-	const { customDescription } = options;
+	const { customDescription, toolTokenLimitBeforeEvict } = options;
 	return tool(async (input, config) => {
 		const resolvedBackend = getBackend(backend, {
 			state: getCurrentTaskInput(config),
 			store: config.store
 		});
-		const { file_path, offset = 0, limit = 500 } = input;
-		return await resolvedBackend.read(file_path, offset, limit);
+		const { file_path, offset = DEFAULT_READ_LINE_OFFSET, limit = DEFAULT_READ_LINE_LIMIT } = input;
+		let result = await resolvedBackend.read(file_path, offset, limit);
+		const lines = result.split("\n");
+		if (lines.length > limit) result = lines.slice(0, limit).join("\n");
+		if (toolTokenLimitBeforeEvict && result.length >= NUM_CHARS_PER_TOKEN * toolTokenLimitBeforeEvict) {
+			const truncationMsg = READ_FILE_TRUNCATION_MSG.replace("{file_path}", file_path);
+			const maxContentLength = NUM_CHARS_PER_TOKEN * toolTokenLimitBeforeEvict - truncationMsg.length;
+			result = result.substring(0, maxContentLength) + truncationMsg;
+		}
+		return result;
 	}, {
 		name: "read_file",
 		description: customDescription || READ_FILE_TOOL_DESCRIPTION,
 		schema: z.object({
 			file_path: z.string().describe("Absolute path to the file to read"),
-			offset: z.coerce.number().optional().default(0).describe("Line offset to start reading from (0-indexed)"),
-			limit: z.coerce.number().optional().default(500).describe("Maximum number of lines to read")
+			offset: z.coerce.number().optional().default(DEFAULT_READ_LINE_OFFSET).describe("Line offset to start reading from (0-indexed)"),
+			limit: z.coerce.number().optional().default(DEFAULT_READ_LINE_LIMIT).describe("Maximum number of lines to read")
 		})
 	});
 }
@@ -926,7 +952,10 @@ function createFilesystemMiddleware(options = {}) {
 		stateSchema: FilesystemStateSchema,
 		tools: [
 			createLsTool(backend, { customDescription: customToolDescriptions?.ls }),
-			createReadFileTool(backend, { customDescription: customToolDescriptions?.read_file }),
+			createReadFileTool(backend, {
+				customDescription: customToolDescriptions?.read_file,
+				toolTokenLimitBeforeEvict
+			}),
 			createWriteFileTool(backend, { customDescription: customToolDescriptions?.write_file }),
 			createEditFileTool(backend, { customDescription: customToolDescriptions?.edit_file }),
 			createGlobTool(backend, { customDescription: customToolDescriptions?.glob }),
@@ -1290,12 +1319,52 @@ function createSubAgentMiddleware(options) {
 //#endregion
 //#region src/middleware/patch_tool_calls.ts
 /**
+* Patch dangling tool calls in a messages array.
+* Returns the patched messages array and a flag indicating if patching was needed.
+*
+* @param messages - The messages array to patch
+* @returns Object with patched messages and needsPatch flag
+*/
+function patchDanglingToolCalls(messages) {
+	if (!messages || messages.length === 0) return {
+		patchedMessages: [],
+		needsPatch: false
+	};
+	const patchedMessages = [];
+	let needsPatch = false;
+	for (let i = 0; i < messages.length; i++) {
+		const msg = messages[i];
+		patchedMessages.push(msg);
+		if (AIMessage.isInstance(msg) && msg.tool_calls != null) {
+			for (const toolCall of msg.tool_calls) if (!messages.slice(i).find((m) => ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id)) {
+				needsPatch = true;
+				const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
+				patchedMessages.push(new ToolMessage({
+					content: toolMsg,
+					name: toolCall.name,
+					tool_call_id: toolCall.id
+				}));
+			}
+		}
+	}
+	return {
+		patchedMessages,
+		needsPatch
+	};
+}
+/**
 * Create middleware that patches dangling tool calls in the messages history.
 *
 * When an AI message contains tool_calls but subsequent messages don't include
 * the corresponding ToolMessage responses, this middleware adds synthetic
 * ToolMessages saying the tool call was cancelled.
 *
+* This middleware patches in two places:
+* 1. `beforeAgent`: Patches state at the start of the agent loop (handles most cases)
+* 2. `wrapModelCall`: Patches the request right before model invocation (handles
+*    edge cases like HITL rejection during graph resume where state updates from
+*    beforeAgent may not be applied in time)
+*
 * @returns AgentMiddleware that patches dangling tool calls
 *
 * @example
@@ -1315,26 +1384,61 @@ function createPatchToolCallsMiddleware() {
 		beforeAgent: async (state) => {
 			const messages = state.messages;
 			if (!messages || messages.length === 0) return;
-			const patchedMessages = [];
-			for (let i = 0; i < messages.length; i++) {
-				const msg = messages[i];
-				patchedMessages.push(msg);
-				if (AIMessage.isInstance(msg) && msg.tool_calls != null) {
-					for (const toolCall of msg.tool_calls) if (!messages.slice(i).find((m) => ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id)) {
-						const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
-						patchedMessages.push(new ToolMessage({
-							content: toolMsg,
-							name: toolCall.name,
-							tool_call_id: toolCall.id
-						}));
-					}
-				}
-			}
+			const { patchedMessages, needsPatch } = patchDanglingToolCalls(messages);
+			/**
+			* Only trigger REMOVE_ALL_MESSAGES if patching is actually needed
+			*/
+			if (!needsPatch) return;
 			return { messages: [new RemoveMessage({ id: REMOVE_ALL_MESSAGES }), ...patchedMessages] };
+		},
+		wrapModelCall: async (request, handler) => {
+			const messages = request.messages;
+			if (!messages || messages.length === 0) return handler(request);
+			const { patchedMessages, needsPatch } = patchDanglingToolCalls(messages);
+			if (!needsPatch) return handler(request);
+			return handler({
+				...request,
+				messages: patchedMessages
+			});
 		}
 	});
 }
 
+//#endregion
+//#region src/values.ts
+/**
+* Shared state values for use in StateSchema definitions.
+*
+* This module provides pre-configured ReducedValue instances that can be
+* reused across different state schemas, similar to LangGraph's messagesValue.
+*/
+/**
+* Shared ReducedValue for file data state management.
+*
+* This provides a reusable pattern for managing file state with automatic
+* merging of concurrent updates from parallel subagents. Files can be updated
+* or deleted (using null values) and the reducer handles the merge logic.
+*
+* Similar to LangGraph's messagesValue, this encapsulates the common pattern
+* of managing files in agent state so you don't have to manually configure
+* the ReducedValue each time.
+*
+* @example
+* ```typescript
+* import { filesValue } from "@anthropic/deepagents";
+* import { StateSchema } from "@langchain/langgraph";
+*
+* const MyStateSchema = new StateSchema({
+*   files: filesValue,
+*   // ... other state fields
+* });
+* ```
+*/
+const filesValue = new ReducedValue(z$1.record(z$1.string(), FileDataSchema).default(() => ({})), {
+	inputSchema: z$1.record(z$1.string(), FileDataSchema.nullable()).optional(),
+	reducer: fileDataReducer
+});
+
 //#endregion
 //#region src/middleware/memory.ts
 /**
@@ -1389,7 +1493,10 @@ function createPatchToolCallsMiddleware() {
 /**
 * State schema for memory middleware.
 */
-const MemoryStateSchema = z$1.object({ memoryContents: z$1.record(z$1.string(), z$1.string()).optional() });
+const MemoryStateSchema = new StateSchema({
+	memoryContents: z$1.record(z$1.string(), z$1.string()).optional(),
+	files: filesValue
+});
 /**
 * Default system prompt template for memory.
 * Ported from Python's comprehensive memory guidelines.
@@ -1533,12 +1640,10 @@ function createMemoryMiddleware(options) {
 		},
 		wrapModelCall(request, handler) {
 			const formattedContents = formatMemoryContents(request.state?.memoryContents || {}, sources);
-			const memorySection = MEMORY_SYSTEM_PROMPT.replace("{memory_contents}", formattedContents);
-			const currentSystemPrompt = request.systemPrompt || "";
-			const newSystemPrompt = currentSystemPrompt ? `${memorySection}\n\n${currentSystemPrompt}` : memorySection;
+			const newSystemMessage = new SystemMessage(MEMORY_SYSTEM_PROMPT.replace("{memory_contents}", formattedContents)).concat(request.systemMessage);
 			return handler({
 				...request,
-				systemPrompt: newSystemPrompt
+				systemMessage: newSystemMessage
 			});
 		}
 	});
@@ -1621,10 +1726,13 @@ function skillsMetadataReducer(current, update) {
 * State schema for skills middleware.
 * Uses ReducedValue for skillsMetadata to allow concurrent updates from parallel subagents.
 */
-const SkillsStateSchema = new StateSchema({ skillsMetadata: new ReducedValue(z$1.array(SkillMetadataEntrySchema).default(() => []), {
-	inputSchema: z$1.array(SkillMetadataEntrySchema).optional(),
-	reducer: skillsMetadataReducer
-}) });
+const SkillsStateSchema = new StateSchema({
+	skillsMetadata: new ReducedValue(z$1.array(SkillMetadataEntrySchema).default(() => []), {
+		inputSchema: z$1.array(SkillMetadataEntrySchema).optional(),
+		reducer: skillsMetadataReducer
+	}),
+	files: filesValue
+});
 /**
 * Skills System Documentation prompt template.
 */
@@ -1845,7 +1953,7 @@ function createSkillsMiddleware(options) {
 		stateSchema: SkillsStateSchema,
 		async beforeAgent(state) {
 			if (loadedSkills.length > 0) return;
-			if ("skillsMetadata" in state && state.skillsMetadata != null) {
+			if ("skillsMetadata" in state && Array.isArray(state.skillsMetadata) && state.skillsMetadata.length > 0) {
 				loadedSkills = state.skillsMetadata;
 				return;
 			}
@@ -3415,6 +3523,9 @@ const BASE_PROMPT = `In order to complete the objective that the user asks of yo
 */
 function createDeepAgent(params = {}) {
 	const { model = "claude-sonnet-4-5-20250929", tools = [], systemPrompt, middleware: customMiddleware = [], subagents = [], responseFormat, contextSchema, checkpointer, store, backend, interruptOn, name, memory, skills } = params;
+	/**
+	* Combine system prompt with base prompt like Python implementation
+	*/
 	const finalSystemPrompt = systemPrompt ? typeof systemPrompt === "string" ? `${systemPrompt}\n\n${BASE_PROMPT}` : new SystemMessage({ content: [{
 		type: "text",
 		text: BASE_PROMPT
@@ -3422,22 +3533,61 @@ function createDeepAgent(params = {}) {
 		type: "text",
 		text: systemPrompt.content
 	}] : systemPrompt.content] }) : BASE_PROMPT;
+	/**
+	* Create backend configuration for filesystem middleware
+	* If no backend is provided, use a factory that creates a StateBackend
+	*/
 	const filesystemBackend = backend ? backend : (config) => new StateBackend(config);
-	const skillsMiddleware = skills != null && skills.length > 0 ? [createSkillsMiddleware({
+	/**
+	* Skills middleware (created conditionally for runtime use)
+	*/
+	const skillsMiddlewareArray = skills != null && skills.length > 0 ? [createSkillsMiddleware({
 		backend: filesystemBackend,
 		sources: skills
 	})] : [];
-	const builtInMiddleware = [
-		todoListMiddleware(),
-		...skillsMiddleware,
-		createFilesystemMiddleware({ backend: filesystemBackend }),
-		createSubAgentMiddleware({
-			defaultModel: model,
-			defaultTools: tools,
-			defaultMiddleware: [
+	/**
+	* Memory middleware (created conditionally for runtime use)
+	*/
+	const memoryMiddlewareArray = memory != null && memory.length > 0 ? [createMemoryMiddleware({
+		backend: filesystemBackend,
+		sources: memory
+	})] : [];
+	/**
+	* Return as DeepAgent with proper DeepAgentTypeConfig
+	* - Response: TResponse (from responseFormat parameter)
+	* - State: undefined (state comes from middleware)
+	* - Context: ContextSchema
+	* - Middleware: AllMiddleware (built-in + custom + subagent middleware for state inference)
+	* - Tools: TTools
+	* - Subagents: TSubagents (for type-safe streaming)
+	*/
+	return createAgent({
+		model,
+		systemPrompt: finalSystemPrompt,
+		tools,
+		middleware: [
+			...[
 				todoListMiddleware(),
-				...skillsMiddleware,
 				createFilesystemMiddleware({ backend: filesystemBackend }),
+				createSubAgentMiddleware({
+					defaultModel: model,
+					defaultTools: tools,
+					defaultMiddleware: [
+						todoListMiddleware(),
+						...skillsMiddlewareArray,
+						createFilesystemMiddleware({ backend: filesystemBackend }),
+						summarizationMiddleware({
+							model,
+							trigger: { tokens: 17e4 },
+							keep: { messages: 6 }
+						}),
+						anthropicPromptCachingMiddleware({ unsupportedModelBehavior: "ignore" }),
+						createPatchToolCallsMiddleware()
+					],
+					defaultInterruptOn: interruptOn,
+					subagents,
+					generalPurposeAgent: true
+				}),
 				summarizationMiddleware({
 					model,
 					trigger: { tokens: 17e4 },
@@ -3446,34 +3596,17 @@ function createDeepAgent(params = {}) {
 				anthropicPromptCachingMiddleware({ unsupportedModelBehavior: "ignore" }),
 				createPatchToolCallsMiddleware()
 			],
-			defaultInterruptOn: interruptOn,
-			subagents,
-			generalPurposeAgent: true
-		}),
-		summarizationMiddleware({
-			model,
-			trigger: { tokens: 17e4 },
-			keep: { messages: 6 }
-		}),
-		anthropicPromptCachingMiddleware({ unsupportedModelBehavior: "ignore" }),
-		createPatchToolCallsMiddleware(),
-		...memory != null && memory.length > 0 ? [createMemoryMiddleware({
-			backend: filesystemBackend,
-			sources: memory
-		})] : []
-	];
-	if (interruptOn) builtInMiddleware.push(humanInTheLoopMiddleware({ interruptOn }));
-	return createAgent({
-		model,
-		systemPrompt: finalSystemPrompt,
-		tools,
-		middleware: [...builtInMiddleware, ...customMiddleware],
+			...skillsMiddlewareArray,
+			...memoryMiddlewareArray,
+			...interruptOn ? [humanInTheLoopMiddleware({ interruptOn })] : [],
+			...customMiddleware
+		],
 		responseFormat,
 		contextSchema,
 		checkpointer,
 		store,
 		name
-	});
+	}).withConfig({ recursionLimit: 1e4 });
 }
 
 //#endregion
@@ -4021,5 +4154,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, findProjectRoot, isSandboxBackend, listSkills, parseSkillMetadata };
+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 };
 //# sourceMappingURL=index.js.map