deepagents 1.8.5 → 1.8.7

package/dist/index.cjs

@@ -106,6 +106,17 @@ var SandboxError = class SandboxError extends Error {
 		return typeof error === "object" && error !== null && error[SANDBOX_ERROR_SYMBOL] === true;
 	}
 };
+/**
+* Resolve a backend instance or await a {@link BackendFactory}.
+*
+* Accepts {@link BackendRuntime} or {@link ToolRuntime} — store typing differs
+* between LangGraph checkpoint stores and core `ToolRuntime`; factories receive
+* a value that is structurally compatible at runtime.
+*/
+async function resolveBackend(backend, runtime) {
+	if (typeof backend === "function") return await backend(runtime);
+	return backend;
+}
 //#endregion
 //#region src/backends/utils.ts
 /**
@@ -387,15 +398,15 @@ function grepMatchesFromFiles(files, pattern, path$9 = null, glob = null) {
 * for the middleware to apply via Command.
 */
 var StateBackend = class {
-	stateAndStore;
-	constructor(stateAndStore) {
-		this.stateAndStore = stateAndStore;
+	runtime;
+	constructor(runtime) {
+		this.runtime = runtime;
 	}
 	/**
 	* Get files from current state.
 	*/
 	getFiles() {
-		return this.stateAndStore.state.files || {};
+		return this.runtime.state.files || {};
 	}
 	/**
 	* List files and directories in the specified directory (non-recursive).
@@ -647,6 +658,62 @@ indicate omitted lines in the middle of the content):
 
 {content_sample}`;
 /**
+* Message template for evicted HumanMessages.
+*/
+const TOO_LARGE_HUMAN_MSG = `Message content too large and was saved to the filesystem at: {file_path}
+
+You can read the full content using the read_file tool with pagination (offset and limit parameters).
+
+Here is a preview showing the head and tail of the content:
+
+{content_sample}`;
+/**
+* Extract text content from a message.
+*
+* For string content, returns it directly. For array content (mixed block types
+* like text + image), joins all text blocks. Returns empty string if no text found.
+*/
+function extractTextFromMessage(message) {
+	if (typeof message.content === "string") return message.content;
+	if (Array.isArray(message.content)) return message.content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+	return String(message.content);
+}
+/**
+* Build replacement content for an evicted HumanMessage, preserving non-text blocks.
+*
+* For plain string content, returns the replacement text directly. For list content
+* with mixed block types (e.g., text + image), replaces all text blocks with a single
+* text block containing the replacement text while keeping non-text blocks intact.
+*/
+function buildEvictedHumanContent(message, replacementText) {
+	if (typeof message.content === "string") return replacementText;
+	if (Array.isArray(message.content)) {
+		const mediaBlocks = message.content.filter((block) => typeof block === "object" && block !== null && block.type !== "text");
+		if (mediaBlocks.length === 0) return replacementText;
+		return [{
+			type: "text",
+			text: replacementText
+		}, ...mediaBlocks];
+	}
+	return replacementText;
+}
+/**
+* Build a truncated HumanMessage for the model request.
+*
+* Computes a preview from the full content still in state and returns a
+* lightweight replacement the model will see. Pure string computation — no
+* backend I/O.
+*/
+function buildTruncatedHumanMessage(message, filePath) {
+	const contentSample = createContentPreview(extractTextFromMessage(message));
+	return new langchain.HumanMessage({
+		content: buildEvictedHumanContent(message, TOO_LARGE_HUMAN_MSG.replace("{file_path}", filePath).replace("{content_sample}", contentSample)),
+		id: message.id,
+		additional_kwargs: { ...message.additional_kwargs },
+		response_metadata: { ...message.response_metadata }
+	});
+}
+/**
 * Create a preview of content showing head and tail with truncation marker.
 *
 * @param contentStr - The full content string to preview.
@@ -708,16 +775,6 @@ const FilesystemStateSchema = new _langchain_langgraph.StateSchema({ files: new
 	inputSchema: zod_v4.z.record(zod_v4.z.string(), FileDataSchema.nullable()).optional(),
 	reducer: fileDataReducer
 }) });
-/**
-* Resolve backend from factory or instance.
-*
-* @param backend - Backend instance or factory function
-* @param stateAndStore - State and store container for backend initialization
-*/
-function getBackend(backend, stateAndStore) {
-	if (typeof backend === "function") return backend(stateAndStore);
-	return backend;
-}
 const FILESYSTEM_SYSTEM_PROMPT = `## Filesystem Tools \`ls\`, \`read_file\`, \`write_file\`, \`edit_file\`, \`glob\`, \`grep\`
 
 You have access to a filesystem which you can interact with using these tools.
@@ -835,11 +892,8 @@ Use this tool to run commands, scripts, tests, builds, and other shell operation
 */
 function createLsTool(backend, options) {
 	const { customDescription } = options;
-	return (0, langchain.tool)(async (input, config) => {
-		const resolvedBackend = getBackend(backend, {
-			state: (0, _langchain_langgraph.getCurrentTaskInput)(config),
-			store: config.store
-		});
+	return (0, langchain.tool)(async (input, runtime) => {
+		const resolvedBackend = await resolveBackend(backend, runtime);
 		const path = input.path || "/";
 		const infos = await resolvedBackend.lsInfo(path);
 		if (infos.length === 0) return `No files found in ${path}`;
@@ -863,11 +917,8 @@ function createLsTool(backend, options) {
 */
 function createReadFileTool(backend, options) {
 	const { customDescription, toolTokenLimitBeforeEvict } = options;
-	return (0, langchain.tool)(async (input, config) => {
-		const resolvedBackend = getBackend(backend, {
-			state: (0, _langchain_langgraph.getCurrentTaskInput)(config),
-			store: config.store
-		});
+	return (0, langchain.tool)(async (input, runtime) => {
+		const resolvedBackend = await resolveBackend(backend, runtime);
 		const { file_path, offset = 0, limit = 100 } = input;
 		let result = await resolvedBackend.read(file_path, offset, limit);
 		const lines = result.split("\n");
@@ -893,17 +944,14 @@ function createReadFileTool(backend, options) {
 */
 function createWriteFileTool(backend, options) {
 	const { customDescription } = options;
-	return (0, langchain.tool)(async (input, config) => {
-		const resolvedBackend = getBackend(backend, {
-			state: (0, _langchain_langgraph.getCurrentTaskInput)(config),
-			store: config.store
-		});
+	return (0, langchain.tool)(async (input, runtime) => {
+		const resolvedBackend = await resolveBackend(backend, runtime);
 		const { file_path, content } = input;
 		const result = await resolvedBackend.write(file_path, content);
 		if (result.error) return result.error;
 		const message = new langchain.ToolMessage({
 			content: `Successfully wrote to '${file_path}'`,
-			tool_call_id: config.toolCall?.id,
+			tool_call_id: runtime.toolCall?.id,
 			name: "write_file",
 			metadata: result.metadata
 		});
@@ -926,17 +974,14 @@ function createWriteFileTool(backend, options) {
 */
 function createEditFileTool(backend, options) {
 	const { customDescription } = options;
-	return (0, langchain.tool)(async (input, config) => {
-		const resolvedBackend = getBackend(backend, {
-			state: (0, _langchain_langgraph.getCurrentTaskInput)(config),
-			store: config.store
-		});
+	return (0, langchain.tool)(async (input, runtime) => {
+		const resolvedBackend = await resolveBackend(backend, runtime);
 		const { file_path, old_string, new_string, replace_all = false } = input;
 		const result = await resolvedBackend.edit(file_path, old_string, new_string, replace_all);
 		if (result.error) return result.error;
 		const message = new langchain.ToolMessage({
 			content: `Successfully replaced ${result.occurrences} occurrence(s) in '${file_path}'`,
-			tool_call_id: config.toolCall?.id,
+			tool_call_id: runtime.toolCall?.id,
 			name: "edit_file",
 			metadata: result.metadata
 		});
@@ -961,11 +1006,8 @@ function createEditFileTool(backend, options) {
 */
 function createGlobTool(backend, options) {
 	const { customDescription } = options;
-	return (0, langchain.tool)(async (input, config) => {
-		const resolvedBackend = getBackend(backend, {
-			state: (0, _langchain_langgraph.getCurrentTaskInput)(config),
-			store: config.store
-		});
+	return (0, langchain.tool)(async (input, runtime) => {
+		const resolvedBackend = await resolveBackend(backend, runtime);
 		const { pattern, path = "/" } = input;
 		const infos = await resolvedBackend.globInfo(pattern, path);
 		if (infos.length === 0) return `No files found matching pattern '${pattern}'`;
@@ -986,11 +1028,8 @@ function createGlobTool(backend, options) {
 */
 function createGrepTool(backend, options) {
 	const { customDescription } = options;
-	return (0, langchain.tool)(async (input, config) => {
-		const resolvedBackend = getBackend(backend, {
-			state: (0, _langchain_langgraph.getCurrentTaskInput)(config),
-			store: config.store
-		});
+	return (0, langchain.tool)(async (input, runtime) => {
+		const resolvedBackend = await resolveBackend(backend, runtime);
 		const { pattern, path = "/", glob = null } = input;
 		const result = await resolvedBackend.grepRaw(pattern, path, glob);
 		if (typeof result === "string") return result;
@@ -1022,11 +1061,8 @@ function createGrepTool(backend, options) {
 */
 function createExecuteTool(backend, options) {
 	const { customDescription } = options;
-	return (0, langchain.tool)(async (input, config) => {
-		const resolvedBackend = getBackend(backend, {
-			state: (0, _langchain_langgraph.getCurrentTaskInput)(config),
-			store: config.store
-		});
+	return (0, langchain.tool)(async (input, runtime) => {
+		const resolvedBackend = await resolveBackend(backend, runtime);
 		if (!isSandboxBackend(resolvedBackend)) return "Error: Execution not available. This agent's backend does not support command execution (SandboxBackendProtocol). To use the execute tool, provide a backend that implements SandboxBackendProtocol.";
 		const result = await resolvedBackend.execute(input.command);
 		const parts = [result.output];
@@ -1046,7 +1082,7 @@ function createExecuteTool(backend, options) {
 * Create filesystem middleware with all tools and features.
 */
 function createFilesystemMiddleware(options = {}) {
-	const { backend = (stateAndStore) => new StateBackend(stateAndStore), systemPrompt: customSystemPrompt = null, customToolDescriptions = null, toolTokenLimitBeforeEvict = 2e4 } = options;
+	const { backend = (runtime) => new StateBackend(runtime), systemPrompt: customSystemPrompt = null, customToolDescriptions = null, toolTokenLimitBeforeEvict = 2e4, humanMessageTokenLimitBeforeEvict = 5e4 } = options;
 	const baseSystemPrompt = customSystemPrompt || FILESYSTEM_SYSTEM_PROMPT;
 	const allToolsByName = {
 		ls: createLsTool(backend, { customDescription: customToolDescriptions?.ls }),
@@ -1064,19 +1100,53 @@ function createFilesystemMiddleware(options = {}) {
 		name: "FilesystemMiddleware",
 		stateSchema: FilesystemStateSchema,
 		tools: Object.values(allToolsByName),
+		async beforeAgent(state) {
+			if (!humanMessageTokenLimitBeforeEvict) return;
+			const messages = state.messages;
+			if (!messages || messages.length === 0) return;
+			const last = messages[messages.length - 1];
+			if (!langchain.HumanMessage.isInstance(last)) return;
+			if (last.additional_kwargs?.lc_evicted_to) return;
+			const contentStr = extractTextFromMessage(last);
+			const threshold = 4 * humanMessageTokenLimitBeforeEvict;
+			if (contentStr.length <= threshold) return;
+			const resolvedBackend = await resolveBackend(backend, { state: state || {} });
+			const filePath = `/conversation_history/${crypto.randomUUID().replace(/-/g, "").slice(0, 12)}`;
+			const writeResult = await resolvedBackend.write(filePath, contentStr);
+			if (writeResult.error) return;
+			const result = { messages: [new langchain.HumanMessage({
+				content: last.content,
+				id: last.id,
+				additional_kwargs: {
+					...last.additional_kwargs,
+					lc_evicted_to: filePath
+				},
+				response_metadata: { ...last.response_metadata }
+			})] };
+			if (writeResult.filesUpdate) result.files = writeResult.filesUpdate;
+			return result;
+		},
 		wrapModelCall: async (request, handler) => {
-			const supportsExecution = isSandboxBackend(getBackend(backend, {
-				state: request.state || {},
-				store: request.runtime?.store
+			const supportsExecution = isSandboxBackend(await resolveBackend(backend, {
+				...request.runtime,
+				state: request.state
 			}));
 			let tools = request.tools;
 			if (!supportsExecution) tools = tools.filter((t) => t.name !== "execute");
 			let filesystemPrompt = baseSystemPrompt;
 			if (supportsExecution) filesystemPrompt = `${filesystemPrompt}\n\n${EXECUTION_SYSTEM_PROMPT}`;
 			const newSystemMessage = request.systemMessage.concat(filesystemPrompt);
+			let messages = request.messages;
+			if (humanMessageTokenLimitBeforeEvict && messages) {
+				if (messages.some((msg) => langchain.HumanMessage.isInstance(msg) && msg.additional_kwargs?.lc_evicted_to)) messages = messages.map((msg) => {
+					if (langchain.HumanMessage.isInstance(msg) && msg.additional_kwargs?.lc_evicted_to) return buildTruncatedHumanMessage(msg, msg.additional_kwargs.lc_evicted_to);
+					return msg;
+				});
+			}
 			return handler({
 				...request,
 				tools,
+				messages,
 				systemMessage: newSystemMessage
 			});
 		},
@@ -1087,9 +1157,9 @@ function createFilesystemMiddleware(options = {}) {
 			const result = await handler(request);
 			async function processToolMessage(msg, toolTokenLimitBeforeEvict) {
 				if (typeof msg.content === "string" && msg.content.length > toolTokenLimitBeforeEvict * 4) {
-					const resolvedBackend = getBackend(backend, {
-						state: request.state || {},
-						store: request.runtime?.store
+					const resolvedBackend = await resolveBackend(backend, {
+						...request.runtime,
+						state: request.state
 					});
 					const evictPath = `/large_tool_results/${sanitizeToolCallId(request.toolCall?.id || msg.tool_call_id)}`;
 					const writeResult = await resolvedBackend.write(evictPath, msg.content);
@@ -1857,19 +1927,12 @@ async function loadMemoryFromBackend(backend, path) {
 */
 function createMemoryMiddleware(options) {
 	const { backend, sources, addCacheControl = false } = options;
-	/**
-	* Resolve backend from instance or factory.
-	*/
-	function getBackend(state) {
-		if (typeof backend === "function") return backend({ state });
-		return backend;
-	}
 	return (0, langchain.createMiddleware)({
 		name: "MemoryMiddleware",
 		stateSchema: MemoryStateSchema,
 		async beforeAgent(state) {
 			if ("memoryContents" in state && state.memoryContents != null) return;
-			const resolvedBackend = getBackend(state);
+			const resolvedBackend = await resolveBackend(backend, { state });
 			const contents = {};
 			for (const path of sources) try {
 				const content = await loadMemoryFromBackend(resolvedBackend, path);
@@ -2271,13 +2334,6 @@ function formatSkillsList(skills, sources) {
 function createSkillsMiddleware(options) {
 	const { backend, sources } = options;
 	let loadedSkills = [];
-	/**
-	* Resolve backend from instance or factory.
-	*/
-	function getBackend(state) {
-		if (typeof backend === "function") return backend({ state });
-		return backend;
-	}
 	return (0, langchain.createMiddleware)({
 		name: "SkillsMiddleware",
 		stateSchema: SkillsStateSchema,
@@ -2287,7 +2343,7 @@ function createSkillsMiddleware(options) {
 				loadedSkills = state.skillsMetadata;
 				return;
 			}
-			const resolvedBackend = getBackend(state);
+			const resolvedBackend = await resolveBackend(backend, { state });
 			const allSkills = /* @__PURE__ */ new Map();
 			for (const sourcePath of sources) try {
 				const skills = await listSkillsFromBackend(resolvedBackend, sourcePath);
@@ -2511,13 +2567,6 @@ function createSummarizationMiddleware(options) {
 	let sessionId = null;
 	let tokenEstimationMultiplier = 1;
 	/**
-	* Resolve backend from instance or factory.
-	*/
-	function getBackend(state) {
-		if (typeof backend === "function") return backend({ state });
-		return backend;
-	}
-	/**
 	* Get or create session ID for history file naming.
 	*/
 	function getSessionId(state) {
@@ -2883,7 +2932,7 @@ ${summary}
 	* the file path, and the state cutoff index.
 	*/
 	async function summarizeMessages(messagesToSummarize, resolvedModel, state, previousCutoffIndex, cutoffIndex) {
-		const filePath = await offloadToBackend(getBackend(state), messagesToSummarize, state);
+		const filePath = await offloadToBackend(await resolveBackend(backend, { state }), messagesToSummarize, state);
 		if (filePath === null) console.warn(`[SummarizationMiddleware] Backend offload failed during summarization. Proceeding with summary generation.`);
 		return {
 			summaryMessage: buildSummaryMessage(await createSummary(messagesToSummarize, resolvedModel), filePath),
@@ -4964,9 +5013,9 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 	* ```
 	*/
 	static async create(options = {}) {
-		const { templateName = "deepagents", apiKey = process.env.LANGSMITH_API_KEY, defaultTimeout } = options;
+		const { templateName = "deepagents", apiKey = process.env.LANGSMITH_API_KEY, defaultTimeout, ...createSandboxOptions } = options;
 		return new LangSmithSandbox({
-			sandbox: await new langsmith_experimental_sandbox.SandboxClient({ apiKey }).createSandbox(templateName),
+			sandbox: await new langsmith_experimental_sandbox.SandboxClient({ apiKey }).createSandbox(templateName, createSandboxOptions),
 			defaultTimeout
 		});
 	}
@@ -5125,7 +5174,7 @@ function createDeepAgent(params = {}) {
 	* 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 filesystemBackend = backend ? backend : (runtime) => new StateBackend(runtime);
 	/**
 	* Skills middleware (created conditionally for runtime use)
 	*/
@@ -5793,5 +5842,6 @@ exports.findProjectRoot = findProjectRoot;
 exports.isSandboxBackend = isSandboxBackend;
 exports.listSkills = listSkills;
 exports.parseSkillMetadata = parseSkillMetadata;
+exports.resolveBackend = resolveBackend;
 
 //# sourceMappingURL=index.cjs.map