deepagents 1.8.0 → 1.8.1

package/dist/index.cjs

@@ -1085,7 +1085,13 @@ function createFilesystemMiddleware(options = {}) {
 						message: new langchain.ToolMessage({
 							content: TOO_LARGE_TOOL_MSG.replace("{tool_call_id}", msg.tool_call_id).replace("{file_path}", evictPath).replace("{content_sample}", contentSample),
 							tool_call_id: msg.tool_call_id,
-							name: msg.name
+							name: msg.name,
+							id: msg.id,
+							artifact: msg.artifact,
+							status: msg.status,
+							metadata: msg.metadata,
+							additional_kwargs: msg.additional_kwargs,
+							response_metadata: msg.response_metadata
 						}),
 						filesUpdate: writeResult.filesUpdate
 					};
@@ -1363,16 +1369,28 @@ function filterStateForSubagent(state) {
 	return filtered;
 }
 /**
+* Invalid tool message block types
+*/
+const INVALID_TOOL_MESSAGE_BLOCK_TYPES = [
+	"tool_use",
+	"thinking",
+	"redacted_thinking"
+];
+/**
 * Create Command with filtered state update from subagent result
 */
 function returnCommandWithStateUpdate(result, toolCallId) {
 	const stateUpdate = filterStateForSubagent(result);
 	const messages = result.messages;
-	const lastMessage = messages?.[messages.length - 1];
+	let content = (messages?.[messages.length - 1])?.content || "Task completed";
+	if (Array.isArray(content)) {
+		content = content.filter((block) => !INVALID_TOOL_MESSAGE_BLOCK_TYPES.includes(block.type));
+		if (content.length === 0) content = "Task completed";
+	}
 	return new _langchain_langgraph.Command({ update: {
 		...stateUpdate,
 		messages: [new langchain.ToolMessage({
-			content: lastMessage?.content || "Task completed",
+			content,
 			tool_call_id: toolCallId,
 			name: "task"
 		})]
@@ -2702,31 +2720,44 @@ function createSummarizationMiddleware(options) {
 		return messages.filter((msg) => !isSummaryMessage(msg));
 	}
 	/**
-	* Offload messages to backend.
+	* Offload messages to backend by appending to the history file.
+	*
+	* Uses uploadFiles() directly with raw byte concatenation instead of
+	* edit() to avoid downloading the file twice and performing a full
+	* string search-and-replace. This keeps peak memory at ~2x file size
+	* (existing bytes + combined bytes) instead of ~6x with the old
+	* download → edit(oldContent, newContent) approach.
 	*/
 	async function offloadToBackend(resolvedBackend, messages, state) {
-		const path = getHistoryPath(state);
+		const filePath = getHistoryPath(state);
 		const filteredMessages = filterSummaryMessages(messages);
 		const newSection = `## Summarized at ${(/* @__PURE__ */ new Date()).toISOString()}\n\n${(0, _langchain_core_messages.getBufferString)(filteredMessages)}\n\n`;
-		let existingContent = "";
-		try {
-			if (resolvedBackend.downloadFiles) {
-				const responses = await resolvedBackend.downloadFiles([path]);
-				if (responses.length > 0 && responses[0].content && !responses[0].error) existingContent = new TextDecoder().decode(responses[0].content);
-			}
-		} catch {}
-		const combinedContent = existingContent + newSection;
+		const sectionBytes = new TextEncoder().encode(newSection);
 		try {
+			let existingBytes = null;
+			if (resolvedBackend.downloadFiles) try {
+				const responses = await resolvedBackend.downloadFiles([filePath]);
+				if (responses.length > 0 && responses[0].content && !responses[0].error) existingBytes = responses[0].content;
+			} catch {}
 			let result;
-			if (existingContent) result = await resolvedBackend.edit(path, existingContent, combinedContent);
-			else result = await resolvedBackend.write(path, combinedContent);
+			if (existingBytes && resolvedBackend.uploadFiles) {
+				const combined = new Uint8Array(existingBytes.byteLength + sectionBytes.byteLength);
+				combined.set(existingBytes, 0);
+				combined.set(sectionBytes, existingBytes.byteLength);
+				const uploadResults = await resolvedBackend.uploadFiles([[filePath, combined]]);
+				result = uploadResults[0].error ? { error: uploadResults[0].error } : { path: filePath };
+			} else if (!existingBytes) result = await resolvedBackend.write(filePath, newSection);
+			else {
+				const existingContent = new TextDecoder().decode(existingBytes);
+				result = await resolvedBackend.edit(filePath, existingContent, existingContent + newSection);
+			}
 			if (result.error) {
-				console.warn(`Failed to offload conversation history to ${path}: ${result.error}`);
+				console.warn(`Failed to offload conversation history to ${filePath}: ${result.error}`);
 				return null;
 			}
-			return path;
+			return filePath;
 		} catch (e) {
-			console.warn(`Exception offloading conversation history to ${path}:`, e);
+			console.warn(`Exception offloading conversation history to ${filePath}:`, e);
 			return null;
 		}
 	}
@@ -2916,18 +2947,43 @@ ${summary}
 
 //#endregion
 //#region src/backends/store.ts
+const NAMESPACE_COMPONENT_RE = /^[A-Za-z0-9\-_.@+:~]+$/;
+/**
+* Validate a namespace array.
+*
+* Each component must be a non-empty string containing only safe characters:
+* alphanumeric (a-z, A-Z, 0-9), hyphen (-), underscore (_), dot (.),
+* at sign (@), plus (+), colon (:), and tilde (~).
+*
+* Characters like *, ?, [, ], {, } etc. are rejected to prevent
+* wildcard or glob injection in store lookups.
+*/
+function validateNamespace(namespace) {
+	if (namespace.length === 0) throw new Error("Namespace array must not be empty.");
+	for (let i = 0; i < namespace.length; i++) {
+		const component = namespace[i];
+		if (typeof component !== "string") throw new TypeError(`Namespace component at index ${i} must be a string, got ${typeof component}.`);
+		if (!component) throw new Error(`Namespace component at index ${i} must not be empty.`);
+		if (!NAMESPACE_COMPONENT_RE.test(component)) throw new Error(`Namespace component at index ${i} contains disallowed characters: "${component}". Only alphanumeric characters, hyphens, underscores, dots, @, +, colons, and tildes are allowed.`);
+	}
+	return namespace;
+}
 /**
 * Backend that stores files in LangGraph's BaseStore (persistent).
 *
 * Uses LangGraph's Store for persistent, cross-conversation storage.
 * Files are organized via namespaces and persist across all threads.
 *
-* The namespace can include an optional assistant_id for multi-agent isolation.
+* The namespace can be customized via a factory function for flexible
+* isolation patterns (user-scoped, org-scoped, etc.), or falls back
+* to legacy assistant_id-based isolation.
 */
 var StoreBackend = class {
 	stateAndStore;
-	constructor(stateAndStore) {
+	_namespace;
+	constructor(stateAndStore, options) {
 		this.stateAndStore = stateAndStore;
+		if (options?.namespace) this._namespace = validateNamespace(options.namespace);
 	}
 	/**
 	* Get the store instance.
@@ -2943,15 +2999,17 @@ var StoreBackend = class {
 	/**
 	* Get the namespace for store operations.
 	*
-	* If an assistant_id is available in stateAndStore, return
-	* [assistant_id, "filesystem"] to provide per-assistant isolation.
-	* Otherwise return ["filesystem"].
+	* If a custom namespace was provided, returns it directly.
+	*
+	* Otherwise, falls back to legacy behavior:
+	* - If assistantId is set: [assistantId, "filesystem"]
+	* - Otherwise: ["filesystem"]
 	*/
 	getNamespace() {
-		const namespace = "filesystem";
+		if (this._namespace) return this._namespace;
 		const assistantId = this.stateAndStore.assistantId;
-		if (assistantId) return [assistantId, namespace];
-		return [namespace];
+		if (assistantId) return [assistantId, "filesystem"];
+		return ["filesystem"];
 	}
 	/**
 	* Convert a store Item to FileData format.
@@ -4611,17 +4669,85 @@ var BaseSandbox = class {
 	*
 	* Uses downloadFiles() to read, performs string replacement in TypeScript,
 	* then uploadFiles() to write back. No runtime needed on the sandbox host.
+	*
+	* Memory-conscious: releases intermediate references early so the GC can
+	* reclaim buffers before the next large allocation is made.
 	*/
 	async edit(filePath, oldString, newString, replaceAll = false) {
 		const results = await this.downloadFiles([filePath]);
 		if (results[0].error || !results[0].content) return { error: `Error: File '${filePath}' not found` };
 		const text = new TextDecoder().decode(results[0].content);
-		const count = text.split(oldString).length - 1;
-		if (count === 0) return { error: `String not found in file '${filePath}'` };
-		if (count > 1 && !replaceAll) return { error: `Multiple occurrences found in '${filePath}'. Use replaceAll=true to replace all.` };
-		const newText = replaceAll ? text.split(oldString).join(newString) : text.replace(oldString, newString);
-		const encoder = new TextEncoder();
-		const uploadResults = await this.uploadFiles([[filePath, encoder.encode(newText)]]);
+		results[0].content = null;
+		/**
+		* are we editing an empty file?
+		*/
+		if (oldString.length === 0) {
+			/**
+			* if the file is not empty, we cannot edit it with an empty oldString
+			*/
+			if (text.length !== 0) return { error: "oldString must not be empty unless the file is empty" };
+			/**
+			* if the newString is empty, we can just return the file as is
+			*/
+			if (newString.length === 0) return {
+				path: filePath,
+				filesUpdate: null,
+				occurrences: 0
+			};
+			/**
+			* if the newString is not empty, we can edit the file
+			*/
+			const encoded = new TextEncoder().encode(newString);
+			const uploadResults = await this.uploadFiles([[filePath, encoded]]);
+			/**
+			* if the upload fails, we return an error
+			*/
+			if (uploadResults[0].error) return { error: `Failed to write edited file '${filePath}': ${uploadResults[0].error}` };
+			return {
+				path: filePath,
+				filesUpdate: null,
+				occurrences: 1
+			};
+		}
+		const firstIdx = text.indexOf(oldString);
+		if (firstIdx === -1) return { error: `String not found in file '${filePath}'` };
+		if (oldString === newString) return {
+			path: filePath,
+			filesUpdate: null,
+			occurrences: 1
+		};
+		let newText;
+		let count;
+		if (replaceAll) {
+			newText = text.replaceAll(oldString, newString);
+			/**
+			* Derive count from the length delta to avoid a separate O(n) counting pass
+			*/
+			const lenDiff = oldString.length - newString.length;
+			if (lenDiff !== 0) count = (text.length - newText.length) / lenDiff;
+			else {
+				/**
+				* Lengths are equal — count via indexOf (we already found the first)
+				*/
+				count = 1;
+				let pos = firstIdx + oldString.length;
+				while (pos <= text.length) {
+					const idx = text.indexOf(oldString, pos);
+					if (idx === -1) break;
+					count++;
+					pos = idx + oldString.length;
+				}
+			}
+		} else {
+			if (text.indexOf(oldString, firstIdx + oldString.length) !== -1) return { error: `Multiple occurrences found in '${filePath}'. Use replaceAll=true to replace all.` };
+			count = 1;
+			/**
+			* Build result from the known index — avoids a redundant search by .replace()
+			*/
+			newText = text.slice(0, firstIdx) + newString + text.slice(firstIdx + oldString.length);
+		}
+		const encoded = new TextEncoder().encode(newText);
+		const uploadResults = await this.uploadFiles([[filePath, encoded]]);
 		if (uploadResults[0].error) return { error: `Failed to write edited file '${filePath}': ${uploadResults[0].error}` };
 		return {
 			path: filePath,