deepagents 1.9.0-alpha.0 → 1.9.0

package/dist/index.cjs

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let langchain = require("langchain");
-let _langchain_core_runnables = require("@langchain/core/runnables");
+let _langchain_anthropic = require("@langchain/anthropic");
 let _langchain_langgraph = require("@langchain/langgraph");
 let zod_v4 = require("zod/v4");
 let micromatch = require("micromatch");
@@ -31,6 +31,7 @@ let path = require("path");
 path = __toESM(path);
 let _langchain_core_messages = require("@langchain/core/messages");
 let zod = require("zod");
+zod = __toESM(zod);
 let yaml = require("yaml");
 yaml = __toESM(yaml);
 let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
@@ -49,78 +50,6 @@ fast_glob = __toESM(fast_glob);
 let langsmith_experimental_sandbox = require("langsmith/experimental/sandbox");
 let node_os = require("node:os");
 node_os = __toESM(node_os);
-//#region src/backends/protocol.ts
-/**
-* Type guard to check if a backend supports execution.
-*
-* @param backend - Backend instance to check
-* @returns True if the backend implements SandboxBackendProtocolV2
-*/
-function isSandboxBackend(backend) {
-	return backend != null && typeof backend === "object" && typeof backend.execute === "function" && typeof backend.id === "string" && backend.id !== "";
-}
-/**
-* Type guard to check if a backend is a sandbox protocol (v1 or v2).
-*
-* Checks for the presence of `execute` function and `id` string,
-* which are the defining features of sandbox protocols.
-*
-* @param backend - Backend instance to check
-* @returns True if the backend implements sandbox protocol (v1 or v2)
-*/
-function isSandboxProtocol(backend) {
-	return backend != null && typeof backend === "object" && typeof backend.execute === "function" && typeof backend.id === "string" && backend.id !== "";
-}
-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
 /**
 * Shared utility functions for memory backend implementations.
@@ -130,7 +59,7 @@ var SandboxError = class SandboxError extends Error {
 * enable composition without fragile string parsing.
 */
 const EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents";
-const MAX_LINE_LENGTH = 1e4;
+const MAX_LINE_LENGTH = 5e3;
 const TOOL_RESULT_TOKEN_LIMIT = 2e4;
 const TRUNCATION_GUIDANCE = "... [results truncated, try being more specific with your parameters]";
 const MIME_TYPES = {
@@ -140,11 +69,26 @@ const MIME_TYPES = {
 	".gif": "image/gif",
 	".webp": "image/webp",
 	".svg": "image/svg+xml",
+	".heic": "image/heic",
+	".heif": "image/heif",
 	".mp3": "audio/mpeg",
 	".wav": "audio/wav",
+	".aiff": "audio/aiff",
+	".aac": "audio/aac",
+	".ogg": "audio/ogg",
+	".flac": "audio/flac",
 	".mp4": "video/mp4",
 	".webm": "video/webm",
-	".pdf": "application/pdf"
+	".mpeg": "video/mpeg",
+	".mov": "video/quicktime",
+	".avi": "video/x-msvideo",
+	".flv": "video/x-flv",
+	".mpg": "video/mpeg",
+	".wmv": "video/x-ms-wmv",
+	".3gpp": "video/3gpp",
+	".pdf": "application/pdf",
+	".ppt": "application/vnd.ms-powerpoint",
+	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
 /**
 * Sanitize tool_call_id to prevent path traversal and separator issues.
@@ -173,7 +117,7 @@ function formatContentWithLineNumbers(content, startLine = 1) {
 	for (let i = 0; i < lines.length; i++) {
 		const line = lines[i];
 		const lineNum = i + startLine;
-		if (line.length <= 1e4) resultLines.push(`${lineNum.toString().padStart(6)}\t${line}`);
+		if (line.length <= 5e3) resultLines.push(`${lineNum.toString().padStart(6)}\t${line}`);
 		else {
 			const numChunks = Math.ceil(line.length / MAX_LINE_LENGTH);
 			for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
@@ -538,7 +482,96 @@ function adaptSandboxProtocol(sandbox) {
 	return adapted;
 }
 //#endregion
+//#region src/backends/protocol.ts
+/**
+* Type guard to check if a backend supports execution.
+*
+* @param backend - Backend instance to check
+* @returns True if the backend implements SandboxBackendProtocolV2
+*/
+function isSandboxBackend(backend) {
+	return backend != null && typeof backend === "object" && typeof backend.execute === "function" && typeof backend.id === "string" && backend.id !== "";
+}
+/**
+* Type guard to check if a backend is a sandbox protocol (v1 or v2).
+*
+* Checks for the presence of `execute` function and `id` string,
+* which are the defining features of sandbox protocols.
+*
+* @param backend - Backend instance to check
+* @returns True if the backend implements sandbox protocol (v1 or v2)
+*/
+function isSandboxProtocol(backend) {
+	return backend != null && typeof backend === "object" && typeof backend.execute === "function" && typeof backend.id === "string" && backend.id !== "";
+}
+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;
+	}
+};
+/**
+* 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.
+*
+* @internal
+*/
+async function resolveBackend(backend, runtime) {
+	if (typeof backend === "function") {
+		const resolved = await backend(runtime);
+		return isSandboxProtocol(resolved) ? adaptSandboxProtocol(resolved) : adaptBackendProtocol(resolved);
+	}
+	return isSandboxProtocol(backend) ? adaptSandboxProtocol(backend) : adaptBackendProtocol(backend);
+}
+//#endregion
 //#region src/backends/state.ts
+const PREGEL_SEND_KEY = "__pregel_send";
 /**
 * Backend that stores files in agent state (ephemeral).
 *
@@ -551,17 +584,52 @@ function adaptSandboxProtocol(sandbox) {
 * for the middleware to apply via Command.
 */
 var StateBackend = class {
-	stateAndStore;
+	runtime;
 	fileFormat;
-	constructor(stateAndStore, options) {
-		this.stateAndStore = stateAndStore;
-		this.fileFormat = options?.fileFormat ?? "v2";
+	constructor(runtimeOrOptions, options) {
+		if (runtimeOrOptions != null && typeof runtimeOrOptions === "object" && "state" in runtimeOrOptions) {
+			this.runtime = runtimeOrOptions;
+			this.fileFormat = options?.fileFormat ?? "v2";
+		} else {
+			this.runtime = void 0;
+			this.fileFormat = runtimeOrOptions?.fileFormat ?? "v2";
+		}
+	}
+	/**
+	* Whether this instance was constructed with the legacy factory pattern.
+	*
+	* When true, state is read from the injected `runtime` and `filesUpdate`
+	* is returned to the caller. When false, state is read from LangGraph's
+	* execution context and updates are sent via `__pregel_send`.
+	*/
+	get isLegacy() {
+		return this.runtime !== void 0;
 	}
 	/**
 	* Get files from current state.
+	*
+	* In legacy mode, reads from the injected {@link BackendRuntime}.
+	* In zero-arg mode, reads from the LangGraph execution context via
+	* {@link getCurrentTaskInput}.
 	*/
 	getFiles() {
-		return this.stateAndStore.state.files || {};
+		if (this.runtime) return this.runtime.state.files || {};
+		return (0, _langchain_langgraph.getCurrentTaskInput)()?.files || {};
+	}
+	/**
+	* Push a files state update through LangGraph's internal send channel.
+	*
+	* In zero-arg mode, sends the update via the `__pregel_send` function
+	* from {@link getConfig}, mirroring Python's `CONFIG_KEY_SEND`.
+	* In legacy mode, this is a no-op — the caller uses `filesUpdate`
+	* from the return value instead.
+	*
+	* @param update - Map of file paths to their updated {@link FileData}
+	*/
+	sendFilesUpdate(update) {
+		if (this.isLegacy) return;
+		const send = (0, _langchain_langgraph.getConfig)().configurable?.[PREGEL_SEND_KEY];
+		if (typeof send === "function") send([["files", update]]);
 	}
 	/**
 	* List files and directories in the specified directory (non-recursive).
@@ -644,6 +712,11 @@ var StateBackend = class {
 		if (filePath in this.getFiles()) return { error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.` };
 		const mimeType = getMimeType(filePath);
 		const newFileData = createFileData(content, void 0, this.fileFormat, mimeType);
+		const update = { [filePath]: newFileData };
+		if (!this.isLegacy) {
+			this.sendFilesUpdate(update);
+			return { path: filePath };
+		}
 		return {
 			path: filePath,
 			filesUpdate: { [filePath]: newFileData }
@@ -660,6 +733,14 @@ var StateBackend = class {
 		if (typeof result === "string") return { error: result };
 		const [newContent, occurrences] = result;
 		const newFileData = updateFileData(fileData, newContent);
+		const update = { [filePath]: newFileData };
+		if (!this.isLegacy) {
+			this.sendFilesUpdate(update);
+			return {
+				path: filePath,
+				occurrences
+			};
+		}
 		return {
 			path: filePath,
 			filesUpdate: { [filePath]: newFileData },
@@ -720,6 +801,10 @@ var StateBackend = class {
 				error: "invalid_path"
 			});
 		}
+		if (!this.isLegacy) {
+			if (Object.keys(updates).length > 0) this.sendFilesUpdate(updates);
+			return responses;
+		}
 		const result = responses;
 		result.filesUpdate = updates;
 		return result;
@@ -769,6 +854,7 @@ var StateBackend = class {
 * - Pluggable backends (StateBackend, StoreBackend, FilesystemBackend, CompositeBackend)
 * - Tool result eviction for large outputs
 */
+const INT_FORMATTER = new Intl.NumberFormat("en-US");
 /**
 * Tools that should be excluded from the large result eviction logic.
 *
@@ -830,17 +916,75 @@ const READ_FILE_TRUNCATION_MSG = `
 /**
 * 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}
-You can read the result from the filesystem by using the read_file tool, but make sure to only read part of the result at a time.
-You can do this by specifying an offset and limit in the read_file tool call.
-For example, to read the first 100 lines, you can use the read_file tool with offset=0 and limit=100.
+const TOO_LARGE_TOOL_MSG = langchain.context`
+  Tool result too large, the result of this tool call {tool_call_id} was saved in the filesystem at this path: {file_path}
+  You can read the result from the filesystem by using the read_file tool, but make sure to only read part of the result at a time.
+  You can do this by specifying an offset and limit in the read_file tool call.
+  For example, to read the first 100 lines, you can use the read_file tool with offset=0 and limit=100.
+
+  Here is a preview showing the head and tail of the result (lines of the form
+  ... [N lines truncated] ...
+  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 result (lines of the form
-... [N lines truncated] ...
-indicate omitted lines in the middle of the content):
+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.
@@ -915,138 +1059,148 @@ 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) {
-	const actualBackend = typeof backend === "function" ? backend(stateAndStore) : backend;
-	return isSandboxProtocol(actualBackend) ? adaptSandboxProtocol(actualBackend) : adaptBackendProtocol(actualBackend);
-}
-const FILESYSTEM_SYSTEM_PROMPT = `## Filesystem Tools \`ls\`, \`read_file\`, \`write_file\`, \`edit_file\`, \`glob\`, \`grep\`
+const FILESYSTEM_SYSTEM_PROMPT = langchain.context`
+  ## Following Conventions
 
-You have access to a filesystem which you can interact with using these tools.
-All file paths must start with a /.
+  - Read files before editing — understand existing content before making changes
+  - Mimic existing style, naming conventions, and patterns
 
-- ls: list files in a directory (requires absolute path)
-- read_file: read a file from the filesystem
-- write_file: write to a file in the filesystem
-- edit_file: edit a file in the filesystem
-- glob: find files matching a pattern (e.g., "**/*.py")
-- grep: search for text within files`;
-const LS_TOOL_DESCRIPTION = `Lists all files in a directory.
+  ## Filesystem Tools \`ls\`, \`read_file\`, \`write_file\`, \`edit_file\`, \`glob\`, \`grep\`
 
-This is useful for exploring the filesystem and finding the right file to read or edit.
-You should almost ALWAYS use this tool before using the read_file or edit_file tools.`;
-const READ_FILE_TOOL_DESCRIPTION = `Reads a file from the filesystem.
+  You have access to a filesystem which you can interact with using these tools.
+  All file paths must start with a /.
 
-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.
+  - ls: list files in a directory (requires absolute path)
+  - read_file: read a file from the filesystem
+  - write_file: write to a file in the filesystem
+  - edit_file: edit a file in the filesystem
+  - glob: find files matching a pattern (e.g., "**/*.py")
+  - grep: search for text within files
+`;
+const LS_TOOL_DESCRIPTION = langchain.context`
+  Lists all files in a directory.
 
-Usage:
-- 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
-  - Only omit limit (read full file) when necessary for editing
-- Specify offset and limit: read_file(path, offset=0, limit=100) reads first 100 lines
-- Results are returned using cat -n format, with line numbers starting at 1
-- Lines longer than 10,000 characters will be split into multiple lines with continuation markers (e.g., 5.1, 5.2, etc.). When you specify a limit, these continuation lines count towards the limit.
-- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
-- You should ALWAYS make sure a file has been read before editing it.`;
-const WRITE_FILE_TOOL_DESCRIPTION = `Writes to a new file in the filesystem.
+  This is useful for exploring the filesystem and finding the right file to read or edit.
+  You should almost ALWAYS use this tool before using the read_file or edit_file tools.
+`;
+const READ_FILE_TOOL_DESCRIPTION = langchain.context`
+  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:
-- The write_file tool will create a new file.
-- Prefer to edit existing files (with the edit_file tool) over creating new ones when possible.`;
-const EDIT_FILE_TOOL_DESCRIPTION = `Performs exact string replacements in files.
+  Usage:
+  - 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
+    - Only omit limit (read full file) when necessary for editing
+  - Specify offset and limit: read_file(path, offset=0, limit=100) reads first 100 lines
+  - Results are returned using cat -n format, with line numbers starting at 1
+- Lines longer than ${INT_FORMATTER.format(MAX_LINE_LENGTH)} characters will be split into multiple lines with continuation markers (e.g., 5.1, 5.2, etc.). When you specify a limit, these continuation lines count towards the limit.
+  - You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
+  - If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
+  - You should ALWAYS make sure a file has been read before editing it.
+`;
+const WRITE_FILE_TOOL_DESCRIPTION = langchain.context`
+  Writes to a new file in the filesystem.
+
+  Usage:
+  - The write_file tool will create a new file.
+  - Prefer to edit existing files (with the edit_file tool) over creating new ones when possible.
+`;
+const EDIT_FILE_TOOL_DESCRIPTION = langchain.context`
+  Performs exact string replacements in files.
 
-Usage:
-- You must read the file before editing. This tool will error if you attempt an edit without reading the file first.
-- When editing, preserve the exact indentation (tabs/spaces) from the read output. Never include line number prefixes in old_string or new_string.
-- ALWAYS prefer editing existing files over creating new ones.
-- Only use emojis if the user explicitly requests it.`;
-const GLOB_TOOL_DESCRIPTION = `Find files matching a glob pattern.
+  Usage:
+  - You must read the file before editing. This tool will error if you attempt an edit without reading the file first.
+  - When editing, preserve the exact indentation (tabs/spaces) from the read output. Never include line number prefixes in old_string or new_string.
+  - ALWAYS prefer editing existing files over creating new ones.
+  - Only use emojis if the user explicitly requests it.
+`;
+const GLOB_TOOL_DESCRIPTION = langchain.context`
+  Find files matching a glob pattern.
 
-Supports standard glob patterns: \`*\` (any characters), \`**\` (any directories), \`?\` (single character).
-Returns a list of absolute file paths that match the pattern.
+  Supports standard glob patterns: \`*\` (any characters), \`**\` (any directories), \`?\` (single character).
+  Returns a list of absolute file paths that match the pattern.
 
-Examples:
-- \`**/*.py\` - Find all Python files
-- \`*.txt\` - Find all text files in root
-- \`/subdir/**/*.md\` - Find all markdown files under /subdir`;
-const GREP_TOOL_DESCRIPTION = `Search for a text pattern across files.
+  Examples:
+  - \`**/*.py\` - Find all Python files
+  - \`*.txt\` - Find all text files in root
+  - \`/subdir/**/*.md\` - Find all markdown files under /subdir
+`;
+const GREP_TOOL_DESCRIPTION = langchain.context`
+  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.
+  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")\`
-- Search for code with special chars: \`grep(pattern="def __init__(self):")\``;
-const EXECUTE_TOOL_DESCRIPTION = `Executes a shell command in an isolated sandbox environment.
+  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")\`
+  - Search for code with special chars: \`grep(pattern="def __init__(self):")\`
+`;
+const EXECUTE_TOOL_DESCRIPTION = langchain.context`
+  Executes a shell command in an isolated sandbox environment.
 
-Usage:
-Executes a given command in the sandbox environment with proper handling and security measures.
-Before executing the command, please follow these steps:
+  Usage:
+  Executes a given command in the sandbox environment with proper handling and security measures.
+  Before executing the command, please follow these steps:
 
-1. Directory Verification:
-   - If the command will create new directories or files, first use the ls tool to verify the parent directory exists and is the correct location
-   - For example, before running "mkdir foo/bar", first use ls to check that "foo" exists and is the intended parent directory
+  1. Directory Verification:
+    - If the command will create new directories or files, first use the ls tool to verify the parent directory exists and is the correct location
+    - For example, before running "mkdir foo/bar", first use ls to check that "foo" exists and is the intended parent directory
 
-2. Command Execution:
-   - Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt")
-   - Examples of proper quoting:
-     - cd "/Users/name/My Documents" (correct)
-     - cd /Users/name/My Documents (incorrect - will fail)
-     - python "/path/with spaces/script.py" (correct)
-     - python /path/with spaces/script.py (incorrect - will fail)
-   - After ensuring proper quoting, execute the command
-   - Capture the output of the command
+  2. Command Execution:
+    - Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt")
+    - Examples of proper quoting:
+      - cd "/Users/name/My Documents" (correct)
+      - cd /Users/name/My Documents (incorrect - will fail)
+      - python "/path/with spaces/script.py" (correct)
+      - python /path/with spaces/script.py (incorrect - will fail)
+    - After ensuring proper quoting, execute the command
+    - Capture the output of the command
 
-Usage notes:
-  - Commands run in an isolated sandbox environment
-  - Returns combined stdout/stderr output with exit code
-  - If the output is very large, it may be truncated
-  - VERY IMPORTANT: You MUST avoid using search commands like find and grep. Instead use the grep, glob tools to search. You MUST avoid read tools like cat, head, tail, and use read_file to read files.
-  - When issuing multiple commands, use the ';' or '&&' operator to separate them. DO NOT use newlines (newlines are ok in quoted strings)
-    - Use '&&' when commands depend on each other (e.g., "mkdir dir && cd dir")
-    - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
-  - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of cd
+  Usage notes:
+    - Commands run in an isolated sandbox environment
+    - Returns combined stdout/stderr output with exit code
+    - If the output is very large, it may be truncated
+    - VERY IMPORTANT: You MUST avoid using search commands like find and grep. Instead use the grep, glob tools to search. You MUST avoid read tools like cat, head, tail, and use read_file to read files.
+    - When issuing multiple commands, use the ';' or '&&' operator to separate them. DO NOT use newlines (newlines are ok in quoted strings)
+      - Use '&&' when commands depend on each other (e.g., "mkdir dir && cd dir")
+      - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
+    - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of cd
 
-Examples:
-  Good examples:
-    - execute(command="pytest /foo/bar/tests")
-    - execute(command="python /path/to/script.py")
-    - execute(command="npm install && npm test")
+  Examples:
+    Good examples:
+      - execute(command="pytest /foo/bar/tests")
+      - execute(command="python /path/to/script.py")
+      - execute(command="npm install && npm test")
 
-  Bad examples (avoid these):
-    - execute(command="cd /foo/bar && pytest tests")  # Use absolute path instead
-    - execute(command="cat file.txt")  # Use read_file tool instead
-    - execute(command="find . -name '*.py'")  # Use glob tool instead
-    - execute(command="grep -r 'pattern' .")  # Use grep tool instead
+    Bad examples (avoid these):
+      - execute(command="cd /foo/bar && pytest tests")  # Use absolute path instead
+      - execute(command="cat file.txt")  # Use read_file tool instead
+      - execute(command="find . -name '*.py'")  # Use glob tool instead
+      - execute(command="grep -r 'pattern' .")  # Use grep tool instead
 
-Note: This tool is only available if the backend supports execution (SandboxBackendProtocol).
-If execution is not supported, the tool will return an error message.`;
-const EXECUTION_SYSTEM_PROMPT = `## Execute Tool \`execute\`
+  Note: This tool is only available if the backend supports execution (SandboxBackendProtocol).
+  If execution is not supported, the tool will return an error message.
+`;
+const EXECUTION_SYSTEM_PROMPT = langchain.context`
+  ## Execute Tool \`execute\`
 
-You have access to an \`execute\` tool for running shell commands in a sandboxed environment.
-Use this tool to run commands, scripts, tests, builds, and other shell operations.
+  You have access to an \`execute\` tool for running shell commands in a sandboxed environment.
+  Use this tool to run commands, scripts, tests, builds, and other shell operations.
 
-- execute: run a shell command in the sandbox (returns output and exit code)`;
+  - execute: run a shell command in the sandbox (returns output and exit code)
+`;
 /**
 * Create ls tool using backend.
 */
 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 lsResult = await resolvedBackend.ls(path);
 		if (lsResult.error) return `Error listing files: ${lsResult.error}`;
@@ -1072,11 +1226,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;
 		const readResult = await resolvedBackend.read(file_path, offset, limit);
 		if (readResult.error) return [{
@@ -1151,17 +1302,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
 		});
@@ -1184,17 +1332,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
 		});
@@ -1219,11 +1364,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 globResult = await resolvedBackend.glob(pattern, path);
 		if (globResult.error) return `Error finding files: ${globResult.error}`;
@@ -1246,11 +1388,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.grep(pattern, path, glob);
 		if (result.error) return result.error;
@@ -1274,7 +1413,7 @@ function createGrepTool(backend, options) {
 		schema: zod_v4.z.object({
 			pattern: zod_v4.z.string().describe("Regex pattern to search for"),
 			path: zod_v4.z.string().optional().default("/").describe("Base path to search from (default: /)"),
-			glob: zod_v4.z.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
+			glob: zod_v4.z.string().optional().nullable().default(null).describe("Optional glob pattern to filter files (e.g., '*.py')")
 		})
 	});
 }
@@ -1283,11 +1422,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];
@@ -1307,7 +1443,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 }),
@@ -1325,19 +1461,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
 			});
 		},
@@ -1348,9 +1518,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);
@@ -1443,117 +1613,117 @@ const EXCLUDED_STATE_KEYS = [
 */
 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 `
-Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
+	return langchain.context`
+    Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
 
-Available agent types and the tools they have access to:
-${subagentDescriptions.join("\n")}
+    Available agent types and the tools they have access to:
+    ${subagentDescriptions.join("\n")}
 
-When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+    When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
 
-## Usage notes:
-1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
-2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
-3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
-4. The agent's outputs should generally be trusted
-5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
-6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
-7. When only the general-purpose agent is provided, you should use it for all tasks. It is great for isolating context and token usage, and completing specific, complex tasks, as it has all the same capabilities as the main agent.
+    ## Usage notes:
+    1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+    2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+    3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+    4. The agent's outputs should generally be trusted
+    5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+    6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+    7. When only the general-purpose agent is provided, you should use it for all tasks. It is great for isolating context and token usage, and completing specific, complex tasks, as it has all the same capabilities as the main agent.
 
-### Example usage of the general-purpose agent:
+    ### Example usage of the general-purpose agent:
 
-<example_agent_descriptions>
-"general-purpose": use this agent for general purpose tasks, it has access to all tools as the main agent.
-</example_agent_descriptions>
+    <example_agent_descriptions>
+    "general-purpose": use this agent for general purpose tasks, it has access to all tools as the main agent.
+    </example_agent_descriptions>
 
-<example>
-User: "I want to conduct research on the accomplishments of Lebron James, Michael Jordan, and Kobe Bryant, and then compare them."
-Assistant: *Uses the task tool in parallel to conduct isolated research on each of the three players*
-Assistant: *Synthesizes the results of the three isolated research tasks and responds to the User*
-<commentary>
-Research is a complex, multi-step task in it of itself.
-The research of each individual player is not dependent on the research of the other players.
-The assistant uses the task tool to break down the complex objective into three isolated tasks.
-Each research task only needs to worry about context and tokens about one player, then returns synthesized information about each player as the Tool Result.
-This means each research task can dive deep and spend tokens and context deeply researching each player, but the final result is synthesized information, and saves us tokens in the long run when comparing the players to each other.
-</commentary>
-</example>
+    <example>
+    User: "I want to conduct research on the accomplishments of Lebron James, Michael Jordan, and Kobe Bryant, and then compare them."
+    Assistant: *Uses the task tool in parallel to conduct isolated research on each of the three players*
+    Assistant: *Synthesizes the results of the three isolated research tasks and responds to the User*
+    <commentary>
+    Research is a complex, multi-step task in it of itself.
+    The research of each individual player is not dependent on the research of the other players.
+    The assistant uses the task tool to break down the complex objective into three isolated tasks.
+    Each research task only needs to worry about context and tokens about one player, then returns synthesized information about each player as the Tool Result.
+    This means each research task can dive deep and spend tokens and context deeply researching each player, but the final result is synthesized information, and saves us tokens in the long run when comparing the players to each other.
+    </commentary>
+    </example>
 
-<example>
-User: "Analyze a single large code repository for security vulnerabilities and generate a report."
-Assistant: *Launches a single \`task\` subagent for the repository analysis*
-Assistant: *Receives report and integrates results into final summary*
-<commentary>
-Subagent is used to isolate a large, context-heavy task, even though there is only one. This prevents the main thread from being overloaded with details.
-If the user then asks followup questions, we have a concise report to reference instead of the entire history of analysis and tool calls, which is good and saves us time and money.
-</commentary>
-</example>
+    <example>
+    User: "Analyze a single large code repository for security vulnerabilities and generate a report."
+    Assistant: *Launches a single \`task\` subagent for the repository analysis*
+    Assistant: *Receives report and integrates results into final summary*
+    <commentary>
+    Subagent is used to isolate a large, context-heavy task, even though there is only one. This prevents the main thread from being overloaded with details.
+    If the user then asks followup questions, we have a concise report to reference instead of the entire history of analysis and tool calls, which is good and saves us time and money.
+    </commentary>
+    </example>
 
-<example>
-User: "Schedule two meetings for me and prepare agendas for each."
-Assistant: *Calls the task tool in parallel to launch two \`task\` subagents (one per meeting) to prepare agendas*
-Assistant: *Returns final schedules and agendas*
-<commentary>
-Tasks are simple individually, but subagents help silo agenda preparation.
-Each subagent only needs to worry about the agenda for one meeting.
-</commentary>
-</example>
+    <example>
+    User: "Schedule two meetings for me and prepare agendas for each."
+    Assistant: *Calls the task tool in parallel to launch two \`task\` subagents (one per meeting) to prepare agendas*
+    Assistant: *Returns final schedules and agendas*
+    <commentary>
+    Tasks are simple individually, but subagents help silo agenda preparation.
+    Each subagent only needs to worry about the agenda for one meeting.
+    </commentary>
+    </example>
 
-<example>
-User: "I want to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway."
-Assistant: *Calls tools directly in parallel to order a pizza from Dominos, a burger from McDonald's, and a salad from Subway*
-<commentary>
-The assistant did not use the task tool because the objective is super simple and clear and only requires a few trivial tool calls.
-It is better to just complete the task directly and NOT use the \`task\`tool.
-</commentary>
-</example>
+    <example>
+    User: "I want to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway."
+    Assistant: *Calls tools directly in parallel to order a pizza from Dominos, a burger from McDonald's, and a salad from Subway*
+    <commentary>
+    The assistant did not use the task tool because the objective is super simple and clear and only requires a few trivial tool calls.
+    It is better to just complete the task directly and NOT use the \`task\`tool.
+    </commentary>
+    </example>
 
-### Example usage with custom agents:
+    ### Example usage with custom agents:
 
-<example_agent_descriptions>
-"content-reviewer": use this agent after you are done creating significant content or documents
-"greeting-responder": use this agent when to respond to user greetings with a friendly joke
-"research-analyst": use this agent to conduct thorough research on complex topics
-</example_agent_description>
+    <example_agent_descriptions>
+    "content-reviewer": use this agent after you are done creating significant content or documents
+    "greeting-responder": use this agent when to respond to user greetings with a friendly joke
+    "research-analyst": use this agent to conduct thorough research on complex topics
+    </example_agent_description>
 
-<example>
-user: "Please write a function that checks if a number is prime"
-assistant: Sure let me write a function that checks if a number is prime
-assistant: First let me use the Write tool to write a function that checks if a number is prime
-assistant: I'm going to use the Write tool to write the following code:
-<code>
-function isPrime(n) {
-  if (n <= 1) return false
-  for (let i = 2; i * i <= n; i++) {
-    if (n % i === 0) return false
-  }
-  return true
-}
-</code>
-<commentary>
-Since significant content was created and the task was completed, now use the content-reviewer agent to review the work
-</commentary>
-assistant: Now let me use the content-reviewer agent to review the code
-assistant: Uses the Task tool to launch with the content-reviewer agent
-</example>
+    <example>
+    user: "Please write a function that checks if a number is prime"
+    assistant: Sure let me write a function that checks if a number is prime
+    assistant: First let me use the Write tool to write a function that checks if a number is prime
+    assistant: I'm going to use the Write tool to write the following code:
+    <code>
+    function isPrime(n) {{
+      if (n <= 1) return false
+      for (let i = 2; i * i <= n; i++) {{
+        if (n % i === 0) return false
+      }}
+      return true
+    }}
+    </code>
+    <commentary>
+    Since significant content was created and the task was completed, now use the content-reviewer agent to review the work
+    </commentary>
+    assistant: Now let me use the content-reviewer agent to review the code
+    assistant: Uses the Task tool to launch with the content-reviewer agent
+    </example>
 
-<example>
-user: "Can you help me research the environmental impact of different renewable energy sources and create a comprehensive report?"
-<commentary>
-This is a complex research task that would benefit from using the research-analyst agent to conduct thorough analysis
-</commentary>
-assistant: I'll help you research the environmental impact of renewable energy sources. Let me use the research-analyst agent to conduct comprehensive research on this topic.
-assistant: Uses the Task tool to launch with the research-analyst agent, providing detailed instructions about what research to conduct and what format the report should take
-</example>
+    <example>
+    user: "Can you help me research the environmental impact of different renewable energy sources and create a comprehensive report?"
+    <commentary>
+    This is a complex research task that would benefit from using the research-analyst agent to conduct thorough analysis
+    </commentary>
+    assistant: I'll help you research the environmental impact of renewable energy sources. Let me use the research-analyst agent to conduct comprehensive research on this topic.
+    assistant: Uses the Task tool to launch with the research-analyst agent, providing detailed instructions about what research to conduct and what format the report should take
+    </example>
 
-<example>
-user: "Hello"
-<commentary>
-Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
-</commentary>
-assistant: "I'm going to use the Task tool to launch with the greeting-responder agent"
-</example>
-  `.trim();
+    <example>
+    user: "Hello"
+    <commentary>
+    Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+    </commentary>
+    assistant: "I'm going to use the Task tool to launch with the greeting-responder agent"
+    </example>
+  `;
 }
 /**
 * System prompt section that explains how to use the task tool for spawning subagents.
@@ -1568,33 +1738,35 @@ assistant: "I'm going to use the Task tool to launch with the greeting-responder
 * You can provide a custom `systemPrompt` to `createSubAgentMiddleware` to override
 * or extend this default.
 */
-const TASK_SYSTEM_PROMPT = `## \`task\` (subagent spawner)
+const TASK_SYSTEM_PROMPT = langchain.context`
+  ## \`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.
+  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.
 
-When to use the task tool:
-- When a task is complex and multi-step, and can be fully delegated in isolation
-- When a task is independent of other tasks and can run in parallel
-- When a task requires focused reasoning or heavy token/context usage that would bloat the orchestrator thread
-- When sandboxing improves reliability (e.g. code execution, structured searches, data formatting)
-- When you only care about the output of the subagent, and not the intermediate steps (ex. performing a lot of research and then returned a synthesized report, performing a series of computations or lookups to achieve a concise, relevant answer.)
+  When to use the task tool:
+  - When a task is complex and multi-step, and can be fully delegated in isolation
+  - When a task is independent of other tasks and can run in parallel
+  - When a task requires focused reasoning or heavy token/context usage that would bloat the orchestrator thread
+  - When sandboxing improves reliability (e.g. code execution, structured searches, data formatting)
+  - When you only care about the output of the subagent, and not the intermediate steps (ex. performing a lot of research and then returned a synthesized report, performing a series of computations or lookups to achieve a concise, relevant answer.)
 
-Subagent lifecycle:
-1. **Spawn** → Provide clear role, instructions, and expected output
-2. **Run** → The subagent completes the task autonomously
-3. **Return** → The subagent provides a single structured result
-4. **Reconcile** → Incorporate or synthesize the result into the main thread
+  Subagent lifecycle:
+  1. **Spawn** → Provide clear role, instructions, and expected output
+  2. **Run** → The subagent completes the task autonomously
+  3. **Return** → The subagent provides a single structured result
+  4. **Reconcile** → Incorporate or synthesize the result into the main thread
 
-When NOT to use the task tool:
-- If you need to see the intermediate reasoning or steps after the subagent has completed (the task tool hides them)
-- If the task is trivial (a few tool calls or simple lookup)
-- If delegating does not reduce token usage, complexity, or context switching
-- If splitting would add latency without benefit
+  When NOT to use the task tool:
+  - If you need to see the intermediate reasoning or steps after the subagent has completed (the task tool hides them)
+  - If the task is trivial (a few tool calls or simple lookup)
+  - If delegating does not reduce token usage, complexity, or context switching
+  - If splitting would add latency without benefit
 
-## Important Task Tool Usage Notes to Remember
-- Whenever possible, parallelize the work that you do. This is true for both tool_calls, and for tasks. Whenever you have independent steps to complete - make tool_calls, or kick off tasks (subagents) in parallel to accomplish them faster. This saves time for the user, which is incredibly important.
-- 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.`;
+  ## Important Task Tool Usage Notes to Remember
+  - Whenever possible, parallelize the work that you do. This is true for both tool_calls, and for tasks. Whenever you have independent steps to complete - make tool_calls, or kick off tasks (subagents) in parallel to accomplish them faster. This saves time for the user, which is incredibly important.
+  - 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.
 *
@@ -2003,65 +2175,67 @@ const MemoryStateSchema = new _langchain_langgraph.StateSchema({
 * Default system prompt template for memory.
 * Ported from Python's comprehensive memory guidelines.
 */
-const MEMORY_SYSTEM_PROMPT = `<agent_memory>
-{memory_contents}
-</agent_memory>
+const MEMORY_SYSTEM_PROMPT = langchain.context`
+  <agent_memory>
+  {memory_contents}
+  </agent_memory>
 
-<memory_guidelines>
-    The above <agent_memory> was loaded in from files in your filesystem. As you learn from your interactions with the user, you can save new knowledge by calling the \`edit_file\` tool.
+  <memory_guidelines>
+      The above <agent_memory> was loaded in from files in your filesystem. As you learn from your interactions with the user, you can save new knowledge by calling the \`edit_file\` tool.
 
-    **Learning from feedback:**
-    - One of your MAIN PRIORITIES is to learn from your interactions with the user. These learnings can be implicit or explicit. This means that in the future, you will remember this important information.
-    - When you need to remember something, updating memory must be your FIRST, IMMEDIATE action - before responding to the user, before calling other tools, before doing anything else. Just update memory immediately.
-    - When user says something is better/worse, capture WHY and encode it as a pattern.
-    - Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions.
-    - A great opportunity to update your memories is when the user interrupts a tool call and provides feedback. You should update your memories immediately before revising the tool call.
-    - Look for the underlying principle behind corrections, not just the specific mistake.
-    - The user might not explicitly ask you to remember something, but if they provide information that is useful for future use, you should update your memories immediately.
+      **Learning from feedback:**
+      - One of your MAIN PRIORITIES is to learn from your interactions with the user. These learnings can be implicit or explicit. This means that in the future, you will remember this important information.
+      - When you need to remember something, updating memory must be your FIRST, IMMEDIATE action - before responding to the user, before calling other tools, before doing anything else. Just update memory immediately.
+      - When user says something is better/worse, capture WHY and encode it as a pattern.
+      - Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions.
+      - A great opportunity to update your memories is when the user interrupts a tool call and provides feedback. You should update your memories immediately before revising the tool call.
+      - Look for the underlying principle behind corrections, not just the specific mistake.
+      - The user might not explicitly ask you to remember something, but if they provide information that is useful for future use, you should update your memories immediately.
 
-    **Asking for information:**
-    - If you lack context to perform an action (e.g. send a Slack DM, requires a user ID/email) you should explicitly ask the user for this information.
-    - It is preferred for you to ask for information, don't assume anything that you do not know!
-    - When the user provides information that is useful for future use, you should update your memories immediately.
+      **Asking for information:**
+      - If you lack context to perform an action (e.g. send a Slack DM, requires a user ID/email) you should explicitly ask the user for this information.
+      - It is preferred for you to ask for information, don't assume anything that you do not know!
+      - When the user provides information that is useful for future use, you should update your memories immediately.
 
-    **When to update memories:**
-    - When the user explicitly asks you to remember something (e.g., "remember my email", "save this preference")
-    - When the user describes your role or how you should behave (e.g., "you are a web researcher", "always do X")
-    - When the user gives feedback on your work - capture what was wrong and how to improve
-    - When the user provides information required for tool use (e.g., slack channel ID, email addresses)
-    - When the user provides context useful for future tasks, such as how to use tools, or which actions to take in a particular situation
-    - When you discover new patterns or preferences (coding styles, conventions, workflows)
+      **When to update memories:**
+      - When the user explicitly asks you to remember something (e.g., "remember my email", "save this preference")
+      - When the user describes your role or how you should behave (e.g., "you are a web researcher", "always do X")
+      - When the user gives feedback on your work - capture what was wrong and how to improve
+      - When the user provides information required for tool use (e.g., slack channel ID, email addresses)
+      - When the user provides context useful for future tasks, such as how to use tools, or which actions to take in a particular situation
+      - When you discover new patterns or preferences (coding styles, conventions, workflows)
 
-    **When to NOT update memories:**
-    - When the information is temporary or transient (e.g., "I'm running late", "I'm on my phone right now")
-    - When the information is a one-time task request (e.g., "Find me a recipe", "What's 25 * 4?")
-    - When the information is a simple question that doesn't reveal lasting preferences (e.g., "What day is it?", "Can you explain X?")
-    - When the information is an acknowledgment or small talk (e.g., "Sounds good!", "Hello", "Thanks for that")
-    - When the information is stale or irrelevant in future conversations
-    - Never store API keys, access tokens, passwords, or any other credentials in any file, memory, or system prompt.
-    - If the user asks where to put API keys or provides an API key, do NOT echo or save it.
+      **When to NOT update memories:**
+      - When the information is temporary or transient (e.g., "I'm running late", "I'm on my phone right now")
+      - When the information is a one-time task request (e.g., "Find me a recipe", "What's 25 * 4?")
+      - When the information is a simple question that doesn't reveal lasting preferences (e.g., "What day is it?", "Can you explain X?")
+      - When the information is an acknowledgment or small talk (e.g., "Sounds good!", "Hello", "Thanks for that")
+      - When the information is stale or irrelevant in future conversations
+      - Never store API keys, access tokens, passwords, or any other credentials in any file, memory, or system prompt.
+      - If the user asks where to put API keys or provides an API key, do NOT echo or save it.
 
-    **Examples:**
-    Example 1 (remembering user information):
-    User: Can you connect to my google account?
-    Agent: Sure, I'll connect to your google account, what's your google account email?
-    User: john@example.com
-    Agent: Let me save this to my memory.
-    Tool Call: edit_file(...) -> remembers that the user's google account email is john@example.com
+      **Examples:**
+      Example 1 (remembering user information):
+      User: Can you connect to my google account?
+      Agent: Sure, I'll connect to your google account, what's your google account email?
+      User: john@example.com
+      Agent: Let me save this to my memory.
+      Tool Call: edit_file(...) -> remembers that the user's google account email is john@example.com
 
-    Example 2 (remembering implicit user preferences):
-    User: Can you write me an example for creating a deep agent in LangChain?
-    Agent: Sure, I'll write you an example for creating a deep agent in LangChain <example code in Python>
-    User: Can you do this in JavaScript
-    Agent: Let me save this to my memory.
-    Tool Call: edit_file(...) -> remembers that the user prefers to get LangChain code examples in JavaScript
-    Agent: Sure, here is the JavaScript example<example code in JavaScript>
+      Example 2 (remembering implicit user preferences):
+      User: Can you write me an example for creating a deep agent in LangChain?
+      Agent: Sure, I'll write you an example for creating a deep agent in LangChain <example code in Python>
+      User: Can you do this in JavaScript
+      Agent: Let me save this to my memory.
+      Tool Call: edit_file(...) -> remembers that the user prefers to get LangChain code examples in JavaScript
+      Agent: Sure, here is the JavaScript example<example code in JavaScript>
 
-    Example 3 (do not remember transient information):
-    User: I'm going to play basketball tonight so I will be offline for a few hours.
-    Agent: Okay I'll add a block to your calendar.
-    Tool Call: create_calendar_event(...) -> just calls a tool, does not commit anything to memory, as it is transient information
-</memory_guidelines>`;
+      Example 3 (do not remember transient information):
+      User: I'm going to play basketball tonight so I will be offline for a few hours.
+      Agent: Okay I'll add a block to your calendar.
+      Tool Call: create_calendar_event(...) -> just calls a tool, does not commit anything to memory, as it is transient information
+  </memory_guidelines>
+`;
 /**
 * Format loaded memory contents for injection into prompt.
 * Pairs memory locations with their contents for clarity.
@@ -2120,19 +2294,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 adaptBackendProtocol(backend({ state }));
-		return adaptBackendProtocol(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);
@@ -2266,7 +2433,7 @@ Skills follow a **progressive disclosure** pattern - you know they exist (name +
 1. **Recognize when a skill applies**: Check if the user's task matches any skill's description
 2. **Read the skill's full instructions**: The skill list above shows the exact path to use with read_file
 3. **Follow the skill's instructions**: SKILL.md contains step-by-step workflows, best practices, and examples
-4. **Access supporting files**: Skills may include Python scripts, configs, or reference docs - use absolute paths
+4. **Access supporting files**: Skills may include scripts, configs, or reference docs - use absolute paths
 
 **When to Use Skills:**
 - When the user's request matches a skill's domain (e.g., "research X" → web-research skill)
@@ -2278,7 +2445,7 @@ Skills follow a **progressive disclosure** pattern - you know they exist (name +
 - The skill list above shows the full path for each skill's SKILL.md file
 
 **Executing Skill Scripts:**
-Skills may contain Python scripts or other executable files. Always use absolute paths from the skill list.
+Skills may contain scripts or other executable files. Always use absolute paths from the skill list.
 
 **Example Workflow:**
 
@@ -2538,13 +2705,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 adaptBackendProtocol(backend({ state }));
-		return adaptBackendProtocol(backend);
-	}
 	return (0, langchain.createMiddleware)({
 		name: "SkillsMiddleware",
 		stateSchema: SkillsStateSchema,
@@ -2554,7 +2714,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);
@@ -2586,25 +2746,26 @@ function createSkillsMiddleware(options) {
 * This module provides shared helpers used across middleware implementations.
 */
 //#endregion
-//#region src/middleware/completion_notifier.ts
+//#region src/middleware/completion_callback.ts
 /**
-* Completion notifier middleware for async subagents.
+* Callback middleware for async subagents.
 *
-* **Experimental** — this middleware is experimental and may change in future releases.
+* @experimental - this middleware is experimental and may change in future releases.
 *
-* When an async subagent finishes (success or error), this middleware sends a
-* message back to the **supervisor's** thread so the supervisor wakes up and can
-* proactively relay results to the user — without the user having to poll via
+* This middleware sends a notification to a callback thread when a subagent
+* completes successfully or raises an error. The callback agent can then
+* process that notification instead of relying only on polling via
 * `check_async_task`.
 *
 * ## Architecture
 *
-* The async subagent protocol is inherently fire-and-forget: the supervisor
-* launches a job via `start_async_task` and only learns about completion
-* when someone calls `check_async_task`. This middleware closes that gap.
+* A parent agent launches a subagent with `start_async_task` and can later
+* inspect task state with `check_async_task`. This middleware adds an optional
+* completion signal by creating a run on the callback thread when the subagent
+* finishes.
 *
 * ```
-* Supervisor                    Subagent
+* Parent                        Subagent
 *     |                            |
 *     |--- start_async_task -----> |
 *     |<-- task_id (immediately) - |
@@ -2612,67 +2773,74 @@ function createSkillsMiddleware(options) {
 *     |                            |  (done!)
 *     |                            |
 *     |<-- runs.create(            |
-*     |      supervisor_thread,    |
+*     |      callback_thread,      |
 *     |      "completed: ...")     |
 *     |                            |
-*     |  (wakes up, sees result)   |
+*     |  (processes result)        |
 * ```
 *
-* The notifier calls `runs.create()` on the supervisor's thread, which
-* queues a new run. From the supervisor's perspective, it looks like a new
-* user message arrived — except the content is a structured notification
-* from the subagent.
-*
-* ## How parent context is propagated
-*
-* - `parentGraphId` is passed as a **constructor argument** to the middleware.
-*   This is the supervisor's graph ID (or assistant ID), which the subagent
-*   developer knows at configuration time.
-* - `url` is the URL of the LangGraph server where the supervisor is deployed.
-*   This is required since JS does not support in-process ASGI transport.
-* - `headers` are optional additional headers for authenticating with the
-*   supervisor's server.
-* - `parent_thread_id` is injected into the subagent's input state by the
-*   supervisor's `start_async_task` tool. It survives thread interrupts and
-*   updates because it lives in state, not config.
-* - If `parent_thread_id` is not present in state, the notifier silently no-ops.
+* The middleware calls `runs.create()` on the callback thread. From the
+* callback agent's perspective, this appears as a new user message containing
+* structured output from the subagent.
+*
+* ## Callback context
+*
+* - `callbackGraphId` identifies the callback graph or assistant. It is
+*   provided when the middleware is constructed.
+* - `url` and `headers` optionally configure a remote callback destination.
+*   Omit `url` for same-deployment ASGI transport.
+* - `callback_thread_id` is stored in the subagent state by the parent's
+*   `start_async_task` tool. Because it is stored in state rather than config,
+*   it survives thread updates and interrupts.
+* - If `callback_thread_id` is not present in state, the middleware does
+*   nothing.
 *
 * ## Usage
 *
 * ```typescript
-* import { createCompletionNotifierMiddleware } from "deepagents";
+* import { createCompletionCallbackMiddleware } from "deepagents";
 *
-* const notifier = createCompletionNotifierMiddleware({
-*   parentGraphId: "supervisor",
+* // Same deployment (callback agent and subagent share a server):
+* const notifier = createCompletionCallbackMiddleware({
+*   callbackGraphId: "supervisor",
+* });
+*
+* // Remote deployment (callback destination on a different server):
+* const notifier = createCompletionCallbackMiddleware({
+*   callbackGraphId: "supervisor",
 *   url: "https://my-deployment.langsmith.dev",
 * });
 *
 * const agent = createDeepAgent({
-*   model: "claude-sonnet-4-5-20250929",
+*   model,
 *   middleware: [notifier],
 * });
 * ```
 *
-* The middleware will read `parent_thread_id` from the agent's state at the
-* end of execution. This is injected automatically by the supervisor's
-* `start_async_task` tool when it creates the run.
+* The middleware reads `callbackThreadId` from the agent state at the end of
+* execution. This value is injected by the parent's `start_async_task` tool
+* when it creates the run.
 *
 * @module
 */
-/** State key where the supervisor's launch tool stores the parent thread ID. */
-const PARENT_THREAD_ID_KEY = "parent_thread_id";
 /** Maximum characters to include from the last message in notifications. */
-const MAX_SUMMARY_LENGTH = 500;
+const MAX_MESSAGE_LENGTH = 500;
+/** Suffix appended when truncating long messages. */
+const TRUNCATION_SUFFIX = "... [full result truncated]";
+/** State key for the callback thread ID. */
+const CALLBACK_THREAD_ID_KEY = "callbackThreadId";
 /**
-* State extension for subagents that use the completion notifier.
+* State extension for subagents that use completion callbacks.
 *
-* These fields are injected by the supervisor's `start_async_task`
-* tool and read by the completion notifier middleware to send notifications
-* back to the supervisor's thread.
+* @experimental - this state schema is experimental and may change in future releases.
+*
+* `callbackThreadId` is written by the parent's `start_async_task` tool
+* and read by `CompletionCallbackMiddleware` when sending callback
+* notifications.
 */
-const CompletionNotifierStateSchema = zod_v4.z.object({ parent_thread_id: zod_v4.z.string().nullish() });
+const CompletionCallbackStateSchema = zod.object({ [CALLBACK_THREAD_ID_KEY]: zod.string().optional() });
 /**
-* Build headers for the supervisor's LangGraph server.
+* Build headers for the callback LangGraph server.
 *
 * Ensures `x-auth-scheme: langsmith` is present unless explicitly overridden.
 */
@@ -2682,55 +2850,63 @@ function resolveHeaders(headers) {
 	return resolved;
 }
 /**
-* Send a notification run to the parent supervisor's thread.
+* Send a notification run to the callback thread.
+*
+* @param callbackGraphId - The callback graph ID used as `assistant_id`
+*   in the `runs.create` call.
+* @param callbackThreadId - The callback thread ID.
+* @param message - The message content to send.
+* @param options - Optional url and headers for the callback server.
 */
-async function notifyParent(parentThreadId, parentGraphId, notification, options) {
+async function notifyParent(callbackGraphId, callbackThreadId, message, options) {
 	try {
 		await new _langchain_langgraph_sdk.Client({
-			apiUrl: options.url,
+			apiUrl: options?.url ?? void 0,
 			apiKey: null,
-			defaultHeaders: resolveHeaders(options.headers)
-		}).runs.create(parentThreadId, parentGraphId, { input: { messages: [{
+			defaultHeaders: resolveHeaders(options?.headers)
+		}).runs.create(callbackThreadId, callbackGraphId, { input: { messages: [{
 			role: "user",
-			content: notification
+			content: message
 		}] } });
 	} catch (e) {
-		console.warn(`[CompletionNotifierMiddleware] Failed to notify parent thread ${parentThreadId}:`, e);
+		console.warn(`[CompletionCallbackMiddleware] Failed to notify callback thread ${callbackThreadId}:`, e);
 	}
 }
 /**
 * Extract a summary from the subagent's final message.
 *
 * Returns at most 500 characters from the last message's content.
+* Throws if no messages exist or if the last message is not an AIMessage.
+*
+* @param state - The agent state dict.
+* @param taskId - Optional task ID to include in truncation hint.
 */
-function extractLastMessage(state) {
+function extractLastMessage(state, taskId) {
 	const messages = state.messages;
-	if (!messages || messages.length === 0) return "(no output)";
+	if (!messages || messages.length === 0) throw new Error(`Expected at least one message in state ${JSON.stringify(state)}`);
 	const last = messages[messages.length - 1];
-	if (last && typeof last === "object" && "content" in last) {
-		const content = last.content;
-		if (typeof content === "string") return content.slice(0, MAX_SUMMARY_LENGTH);
-		return JSON.stringify(content).slice(0, MAX_SUMMARY_LENGTH);
+	if (!_langchain_core_messages.AIMessage.isInstance(last)) throw new TypeError(`Expected an AIMessage, got ${typeof last === "object" && last !== null ? last.constructor?.name ?? typeof last : typeof last} instead`);
+	let textContent = last.text;
+	if (textContent.length > MAX_MESSAGE_LENGTH) {
+		textContent = textContent.slice(0, MAX_MESSAGE_LENGTH) + TRUNCATION_SUFFIX;
+		if (taskId) textContent += ` Result truncated. Use \`check_async_task(task_id='${taskId}')\` to retrieve the full result if needed.`;
 	}
-	return String(last).slice(0, MAX_SUMMARY_LENGTH);
+	return textContent;
 }
 /**
-* Create a completion notifier middleware for async subagents.
+* Create a completion callback middleware for async subagents.
 *
 * **Experimental** — this middleware is experimental and may change.
 *
-* This middleware is added to the **subagent's** middleware stack (not the
-* supervisor's). When the subagent finishes, it sends a message to the
-* supervisor's thread via `runs.create()`, waking the supervisor so it can
-* proactively relay results.
+* This middleware is added to a subagent's middleware stack. On success or
+* model-call error, it sends a notification to the configured callback
+* thread by calling `runs.create()`.
 *
-* The supervisor's `parent_thread_id` is read from the subagent's own state
-* (injected by the supervisor's `start_async_task` tool at launch time).
-* The `parentGraphId` is provided as a constructor argument since it's static
-* configuration known at deployment time.
+* The callback destination is configured with `callbackGraphId` and
+* optional `url` and `headers`. The target thread is read from
+* `callbackThreadId` in the subagent state.
 *
-* If `parent_thread_id` is not present in state (e.g., the subagent was
-* launched manually without a supervisor), the middleware silently does
+* If `callbackThreadId` is not present in state, the middleware does
 * nothing.
 *
 * @param options - Configuration options.
@@ -2738,11 +2914,10 @@ function extractLastMessage(state) {
 *
 * @example
 * ```typescript
-* import { createCompletionNotifierMiddleware } from "deepagents";
+* import { createCompletionCallbackMiddleware } from "deepagents";
 *
-* const notifier = createCompletionNotifierMiddleware({
-*   parentGraphId: "supervisor",
-*   url: "https://my-deployment.langsmith.dev",
+* const notifier = createCompletionCallbackMiddleware({
+*   callbackGraphId: "supervisor",
 * });
 *
 * const agent = createDeepAgent({
@@ -2751,23 +2926,13 @@ function extractLastMessage(state) {
 * });
 * ```
 */
-function createCompletionNotifierMiddleware(options) {
-	const { parentGraphId, url, headers } = options;
-	let notified = false;
+function createCompletionCallbackMiddleware(options) {
+	const { callbackGraphId, url, headers } = options;
 	/**
-	* Check whether we should send a notification.
+	* Send a notification to the callback destination.
 	*/
-	function shouldNotify(state) {
-		if (notified) return false;
-		return Boolean(state[PARENT_THREAD_ID_KEY]);
-	}
-	/**
-	* Send a notification to the parent if conditions are met.
-	*/
-	async function sendNotification(state, message) {
-		if (!shouldNotify(state)) return;
-		notified = true;
-		await notifyParent(state[PARENT_THREAD_ID_KEY], parentGraphId, message, {
+	async function sendNotification(callbackThreadId, message) {
+		await notifyParent(callbackGraphId, callbackThreadId, message, {
 			url,
 			headers
 		});
@@ -2776,7 +2941,7 @@ function createCompletionNotifierMiddleware(options) {
 	* Read the subagent's own thread_id from runtime config.
 	*
 	* The subagent's `thread_id` is the same as the `task_id` from the
-	* supervisor's perspective.
+	* parent's perspective.
 	*/
 	function getTaskId(runtime) {
 		return runtime?.configurable?.thread_id;
@@ -2789,17 +2954,20 @@ function createCompletionNotifierMiddleware(options) {
 		return `${taskId ? `[task_id=${taskId}]` : ""}${body}`;
 	}
 	return (0, langchain.createMiddleware)({
-		name: "CompletionNotifierMiddleware",
-		stateSchema: CompletionNotifierStateSchema,
+		name: "CompletionCallbackMiddleware",
+		stateSchema: CompletionCallbackStateSchema,
 		async afterAgent(state, runtime) {
-			await sendNotification(state, formatNotification(`Completed. Result: ${extractLastMessage(state)}`, runtime));
+			const callbackThreadId = state[CALLBACK_THREAD_ID_KEY];
+			if (callbackThreadId == null) throw new Error(`Missing required state key '${CALLBACK_THREAD_ID_KEY}'`);
+			const taskId = getTaskId(runtime);
+			await sendNotification(callbackThreadId, formatNotification(`Completed. Result: ${extractLastMessage(state, typeof taskId === "string" ? taskId : void 0)}`, runtime));
 		},
 		async wrapModelCall(request, handler) {
 			try {
 				return await handler(request);
 			} catch (e) {
-				const notification = formatNotification(`Error: ${e instanceof Error ? e.message : String(e)}`, request.runtime);
-				await sendNotification(request.state, notification);
+				const callbackThreadId = request.state[CALLBACK_THREAD_ID_KEY];
+				if (typeof callbackThreadId === "string") await sendNotification(callbackThreadId, formatNotification("The agent encountered an error while calling the model.", request.runtime));
 				throw e;
 			}
 		}
@@ -2998,13 +3166,6 @@ function createSummarizationMiddleware(options) {
 	let sessionId = null;
 	let tokenEstimationMultiplier = 1;
 	/**
-	* Resolve backend from instance or factory.
-	*/
-	function getBackend(state) {
-		if (typeof backend === "function") return adaptBackendProtocol(backend({ state }));
-		return adaptBackendProtocol(backend);
-	}
-	/**
 	* Get or create session ID for history file naming.
 	*/
 	function getSessionId(state) {
@@ -3336,15 +3497,17 @@ function createSummarizationMiddleware(options) {
 	*/
 	function buildSummaryMessage(summary, filePath) {
 		let content;
-		if (filePath) content = `You are in the middle of a conversation that has been summarized.
+		if (filePath) content = langchain.context`
+        You are in the middle of a conversation that has been summarized.
 
-The full conversation history has been saved to ${filePath} should you need to refer back to it for details.
+        The full conversation history has been saved to ${filePath} should you need to refer back to it for details.
 
-A condensed summary follows:
+        A condensed summary follows:
 
-<summary>
-${summary}
-</summary>`;
+        <summary>
+        ${summary}
+        </summary>
+      `;
 		else content = `Here is a summary of the conversation to date:\n\n${summary}`;
 		return new langchain.HumanMessage({
 			content,
@@ -3370,7 +3533,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),
@@ -3512,6 +3675,7 @@ const AsyncTaskSchema = zod_v4.z.object({
 	runId: zod_v4.z.string(),
 	status: zod_v4.z.string(),
 	createdAt: zod_v4.z.string(),
+	description: zod_v4.z.string().optional(),
 	updatedAt: zod_v4.z.string().optional(),
 	checkedAt: zod_v4.z.string().optional()
 });
@@ -3549,7 +3713,7 @@ function asyncTasksReducer(existing, update) {
 * The `{available_agents}` placeholder is replaced at middleware creation
 * time with a formatted list of configured async subagent names and descriptions.
 */
-const ASYNC_TASK_TOOL_DESCRIPTION = `Launch an async subagent on a remote LangGraph server. The subagent runs in the background and returns a task ID immediately.
+const ASYNC_TASK_TOOL_DESCRIPTION = `Launch an async subagent on a remote server. The subagent runs in the background and returns a task ID immediately.
 
 Available async agent types:
 {available_agents}
@@ -3559,7 +3723,7 @@ Available async agent types:
 2. Use \`check_async_task\` only when the user asks for a status update or result.
 3. Use \`update_async_task\` to send new instructions to a running task.
 4. Multiple async subagents can run concurrently — launch several and let them run in the background.
-5. The subagent runs on a remote LangGraph server, so it has its own tools and capabilities.`;
+5. The subagent runs on a remote server, so it has its own tools and capabilities.`;
 /**
 * Default system prompt appended to the main agent's system message when
 * async subagent middleware is active.
@@ -3569,9 +3733,9 @@ Available async agent types:
 * critical rules about polling behavior, and guidance on when to use async
 * subagents vs. synchronous delegation.
 */
-const ASYNC_TASK_SYSTEM_PROMPT = `## Async subagents (remote LangGraph servers)
+const ASYNC_TASK_SYSTEM_PROMPT = `## Async subagents (remote servers)
 
-You have access to async subagent tools that launch background tasks on remote LangGraph servers.
+You have access to async subagent tools that launch background tasks on remote servers.
 
 ### Tools:
 - \`start_async_task\`: Start a new background task. Returns a task ID immediately.
@@ -3611,6 +3775,19 @@ You have access to async subagent tools that launch background tasks on remote L
 * When listing tasks, live-status fetches are skipped for tasks whose
 * cached status is in this set, since they are guaranteed to be final.
 */
+/**
+* Names of the tools added by the async subagent middleware.
+*
+* Exported so `agent.ts` can include them in `BUILTIN_TOOL_NAMES` and
+* surface a `ConfigurationError` if a user-provided tool collides.
+*/
+const ASYNC_TASK_TOOL_NAMES = [
+	"start_async_task",
+	"check_async_task",
+	"update_async_task",
+	"cancel_async_task",
+	"list_async_tasks"
+];
 const TERMINAL_STATUSES = new Set([
 	"cancelled",
 	"success",
@@ -3702,8 +3879,11 @@ var ClientCache = class {
 		this.agents = agents;
 	}
 	/**
-	* Build headers for a remote LangGraph server, adding the default
-	* `x-auth-scheme: langsmith` header if not already present.
+	* Build headers for a remote Agent Protocol server.
+	*
+	* Adds `x-auth-scheme: langsmith` by default unless already provided.
+	* For self-hosted servers that don't require this header, it is typically
+	* ignored. Override via the `headers` field on the AsyncSubAgent config.
 	*/
 	resolveHeaders(spec) {
 		const headers = { ...spec.headers || {} };
@@ -3736,6 +3916,20 @@ var ClientCache = class {
 	}
 };
 /**
+* Extract the callback thread ID from the tool runtime.
+*
+* The thread ID is included in the subagent's input state so the subagent
+* can notify the parent when it completes (via
+* `CompletionCallbackMiddleware`).
+*
+* @returns Object with `callbackThreadId` if available. Empty object otherwise.
+*/
+function extractCallbackContext(runtime) {
+	const threadId = (runtime.config?.configurable)?.thread_id;
+	if (typeof threadId === "string" && threadId) return { callbackThreadId: threadId };
+	return {};
+}
+/**
 * Build the `start_async_task` tool.
 *
 * Creates a thread on the remote server, starts a run, and returns a
@@ -3748,13 +3942,17 @@ function buildStartTool(agentMap, clients, toolDescription) {
 			return `Unknown async subagent type \`${input.agentName}\`. Available types: ${allowed}`;
 		}
 		const spec = agentMap[input.agentName];
+		const callbackContext = extractCallbackContext(runtime);
 		try {
 			const client = clients.getClient(input.agentName);
 			const thread = await client.threads.create();
-			const run = await client.runs.create(thread.thread_id, spec.graphId, { input: { messages: [{
-				role: "user",
-				content: input.description
-			}] } });
+			const run = await client.runs.create(thread.thread_id, spec.graphId, { input: {
+				messages: [{
+					role: "user",
+					content: input.description
+				}],
+				...callbackContext
+			} });
 			const taskId = thread.thread_id;
 			const task = {
 				taskId,
@@ -3762,7 +3960,8 @@ function buildStartTool(agentMap, clients, toolDescription) {
 				threadId: taskId,
 				runId: run.run_id,
 				status: "running",
-				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				description: input.description
 			};
 			return new _langchain_langgraph.Command({ update: {
 				messages: [new langchain.ToolMessage({
@@ -3812,7 +4011,7 @@ function buildCheckTool(clients) {
 			runId: task.runId,
 			status: result.status,
 			createdAt: task.createdAt,
-			updatedAt: task.updatedAt,
+			updatedAt: result.status !== task.status ? (/* @__PURE__ */ new Date()).toISOString() : task.updatedAt,
 			checkedAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		return new _langchain_langgraph.Command({ update: {
@@ -3856,6 +4055,7 @@ function buildUpdateTool(agentMap, clients) {
 				runId: run.run_id,
 				status: "running",
 				createdAt: tracked.createdAt,
+				description: input.message,
 				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				checkedAt: tracked.checkedAt
 			};
@@ -3901,7 +4101,7 @@ function buildCancelTool(clients) {
 			runId: tracked.runId,
 			status: "cancelled",
 			createdAt: tracked.createdAt,
-			updatedAt: tracked.updatedAt,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 			checkedAt: tracked.checkedAt
 		};
 		return new _langchain_langgraph.Command({ update: {
@@ -3942,7 +4142,7 @@ function buildListTool(clients) {
 				runId: task.runId,
 				status,
 				createdAt: task.createdAt,
-				updatedAt: task.updatedAt,
+				updatedAt: status !== task.status ? (/* @__PURE__ */ new Date()).toISOString() : task.updatedAt,
 				checkedAt: task.checkedAt
 			};
 		}
@@ -3963,10 +4163,13 @@ function buildListTool(clients) {
 * Create middleware that adds async subagent tools to an agent.
 *
 * Provides five tools for launching, checking, updating, cancelling, and
-* listing background tasks on remote LangGraph deployments. Task state is
+* listing background tasks on remote Agent Protocol servers. Task state is
 * persisted in the `asyncTasks` state channel so it survives
 * context compaction.
 *
+* Works with any Agent Protocol-compliant server — LangGraph Platform (managed)
+* or self-hosted (e.g. a Hono/Express server implementing the Agent Protocol spec).
+*
 * @throws {Error} If no async subagents are provided or names are duplicated.
 *
 * @example
@@ -3975,7 +4178,7 @@ function buildListTool(clients) {
 *   asyncSubAgents: [{
 *     name: "researcher",
 *     description: "Research agent for deep analysis",
-*     url: "https://my-deployment.langsmith.dev",
+*     url: "https://my-agent-protocol-server.example.com",
 *     graphId: "research_agent",
 *   }],
 * });
@@ -4022,6 +4225,9 @@ function createAsyncSubAgentMiddleware(options) {
 }
 //#endregion
 //#region src/backends/store.ts
+/**
+* StoreBackend: Adapter for LangGraph's BaseStore (persistent, cross-thread).
+*/
 const NAMESPACE_COMPONENT_RE = /^[A-Za-z0-9\-_.@+:~]+$/;
 /**
 * Validate a namespace array.
@@ -4057,35 +4263,54 @@ var StoreBackend = class {
 	stateAndStore;
 	_namespace;
 	fileFormat;
-	constructor(stateAndStore, options) {
-		this.stateAndStore = stateAndStore;
-		if (options?.namespace) this._namespace = validateNamespace(options.namespace);
-		this.fileFormat = options?.fileFormat ?? "v2";
+	constructor(stateAndStoreOrOptions, options) {
+		let opts;
+		if (stateAndStoreOrOptions != null && typeof stateAndStoreOrOptions === "object" && "state" in stateAndStoreOrOptions) {
+			this.stateAndStore = stateAndStoreOrOptions;
+			opts = options;
+		} else {
+			this.stateAndStore = void 0;
+			opts = stateAndStoreOrOptions;
+		}
+		if (opts?.namespace) this._namespace = validateNamespace(opts.namespace);
+		this.fileFormat = opts?.fileFormat ?? "v2";
 	}
 	/**
-	* Get the store instance.
+	* Get the BaseStore instance for persistent storage operations.
+	*
+	* In legacy mode, reads from the injected {@link StateAndStore}.
+	* In zero-arg mode, retrieves the store from the LangGraph execution
+	* context via {@link getLangGraphStore}.
 	*
 	* @returns BaseStore instance
-	* @throws Error if no store is available
+	* @throws Error if no store is available in either mode
 	*/
 	getStore() {
-		const store = this.stateAndStore.store;
-		if (!store) throw new Error("Store is required but not available in StateAndStore");
+		if (this.stateAndStore) {
+			const store = this.stateAndStore.store;
+			if (!store) throw new Error("Store is required but not available in runtime");
+			return store;
+		}
+		const store = (0, _langchain_langgraph.getStore)();
+		if (!store) throw new Error("Store is required but not available in LangGraph execution context. Ensure the graph was configured with a store.");
 		return store;
 	}
 	/**
 	* Get the namespace for store operations.
 	*
-	* If a custom namespace was provided, returns it directly.
-	*
-	* Otherwise, falls back to legacy behavior:
-	* - If assistantId is set: [assistantId, "filesystem"]
-	* - Otherwise: ["filesystem"]
+	* Resolution order:
+	* 1. Explicit namespace from constructor options (both modes)
+	* 2. Legacy mode: `[assistantId, "filesystem"]` fallback from {@link StateAndStore}
+	* 3. Zero-arg mode without namespace: `["filesystem"]` with a deprecation warning
+	*    nudging callers to pass an explicit namespace
+	* 4. Legacy mode without assistantId: `["filesystem"]`
 	*/
 	getNamespace() {
 		if (this._namespace) return this._namespace;
-		const assistantId = this.stateAndStore.assistantId;
-		if (assistantId) return [assistantId, "filesystem"];
+		if (this.stateAndStore) {
+			const assistantId = this.stateAndStore.assistantId;
+			if (assistantId) return [assistantId, "filesystem"];
+		}
 		return ["filesystem"];
 	}
 	/**
@@ -6094,9 +6319,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
 		});
 	}
@@ -6184,9 +6409,44 @@ function createCacheBreakpointMiddleware() {
 }
 //#endregion
 //#region src/agent.ts
-const BASE_PROMPT = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
+const BASE_AGENT_PROMPT = langchain.context`
+  You are a Deep Agent, an AI assistant that helps users accomplish tasks using tools. You respond with text and tool calls. The user can see your responses and tool outputs in real time.
+
+  ## Core Behavior
+
+  - Be concise and direct. Don't over-explain unless asked.
+  - NEVER add unnecessary preamble (\"Sure!\", \"Great question!\", \"I'll now...\").
+  - Don't say \"I'll now do X\" — just do it.
+  - If the request is ambiguous, ask questions before acting.
+  - If asked how to approach something, explain first, then act.
+
+  ## Professional Objectivity
+
+  - Prioritize accuracy over validating the user's beliefs
+  - Disagree respectfully when the user is incorrect
+  - Avoid unnecessary superlatives, praise, or emotional validation
+
+  ## Doing Tasks
+
+  When the user asks you to do something:
+
+  1. **Understand first** — read relevant files, check existing patterns. Quick but thorough — gather enough evidence to start, then iterate.
+  2. **Act** — implement the solution. Work quickly but accurately.
+  3. **Verify** — check your work against what was asked, not against your own output. Your first attempt is rarely correct — iterate.
+
+  Keep working until the task is fully complete. Don't stop partway and explain what you would do — just do it. Only yield back to the user when the task is done or you're genuinely blocked.
+
+  **When things go wrong:**
+  - If something fails repeatedly, stop and analyze *why* — don't keep retrying the same approach.
+  - If you're blocked, tell the user what's wrong and ask for guidance.
+
+  ## Progress Updates
+
+  For longer tasks, provide brief progress updates at reasonable intervals — a concise sentence recapping what you've done and what's next.
+`;
 const BUILTIN_TOOL_NAMES = new Set([
 	...FILESYSTEM_TOOL_NAMES,
+	...ASYNC_TASK_TOOL_NAMES,
 	"task",
 	"write_todos"
 ]);
@@ -6203,19 +6463,18 @@ function isAnthropicModel(model) {
 	return model.getName() === "ChatAnthropic";
 }
 /**
-* Create a Deep Agent with middleware-based architecture.
+* Create a Deep Agent.
+*
+* This is the main entry point for building a production-style agent with
+* deepagents. It gives you a strong default runtime (filesystem, tasks,
+* subagents, summarization) and lets you opt into skills, memory,
+* human-in-the-loop interrupts, async subagents, and custom middleware.
 *
-* Matches Python's create_deep_agent function, using middleware for all features:
-* - Todo management (todoListMiddleware)
-* - Filesystem tools (createFilesystemMiddleware)
-* - Subagent delegation (createSubAgentMiddleware)
-* - Conversation summarization (createSummarizationMiddleware) with backend offloading
-* - Prompt caching (anthropicPromptCachingMiddleware)
-* - Tool call patching (createPatchToolCallsMiddleware)
-* - Human-in-the-loop (humanInTheLoopMiddleware) - optional
+* The runtime is intentionally opinionated: defaults work out of the box, and
+* when you customize behavior, the middleware ordering stays deterministic.
 *
 * @param params Configuration parameters for the agent
-* @returns ReactAgent instance ready for invocation with properly inferred state types
+* @returns Deep Agent instance with inferred state/response types
 *
 * @example
 * ```typescript
@@ -6234,98 +6493,92 @@ function isAnthropicModel(model) {
 * ```
 */
 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;
+	const { model = new _langchain_anthropic.ChatAnthropic("claude-sonnet-4-6"), tools = [], systemPrompt, middleware: customMiddleware = [], subagents = [], responseFormat, contextSchema, checkpointer, store, backend = (config) => new StateBackend(config), interruptOn, name, memory, skills } = params;
 	const collidingTools = tools.map((t) => t.name).filter((n) => typeof n === "string" && BUILTIN_TOOL_NAMES.has(n));
 	if (collidingTools.length > 0) throw new ConfigurationError(`Tool name(s) [${collidingTools.join(", ")}] conflict with built-in tools. Rename your custom tools to avoid this.`, "TOOL_NAME_COLLISION");
 	const anthropicModel = isAnthropicModel(model);
-	const finalSystemPrompt = new langchain.SystemMessage({ content: systemPrompt ? typeof systemPrompt === "string" ? [{
-		type: "text",
-		text: `${systemPrompt}\n\n${BASE_PROMPT}`
-	}] : [{
-		type: "text",
-		text: BASE_PROMPT
-	}, ...typeof systemPrompt.content === "string" ? [{
-		type: "text",
-		text: systemPrompt.content
-	}] : systemPrompt.content] : [{
-		type: "text",
-		text: 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);
-	/**
-	* Skills middleware (created conditionally for runtime use)
-	*/
-	const skillsMiddlewareArray = skills != null && skills.length > 0 ? [createSkillsMiddleware({
-		backend: filesystemBackend,
-		sources: skills
-	})] : [];
-	/**
-	* Memory middleware (created conditionally for runtime use)
-	*/
-	const memoryMiddlewareArray = memory != null && memory.length > 0 ? [createMemoryMiddleware({
-		backend: filesystemBackend,
-		sources: memory,
-		addCacheControl: anthropicModel
-	})] : [];
-	/**
-	* Split the unified subagents array into sync and async subagents.
-	* AsyncSubAgents are identified by the presence of a `graphId` field.
-	*/
-	const syncSubAgents = subagents.filter((a) => !isAsyncSubAgent(a));
-	const asyncSubAgents = subagents.filter((a) => isAsyncSubAgent(a));
+	const cacheMiddleware = anthropicModel ? [(0, langchain.anthropicPromptCachingMiddleware)({
+		unsupportedModelBehavior: "ignore",
+		minMessagesToCache: 1
+	}), createCacheBreakpointMiddleware()] : [];
 	/**
 	* 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).
+	* Only the general-purpose subagent inherits the main agent's skills.
 	* If a custom subagent needs skills, it must specify its own `skills` array.
 	*/
-	const processedSubagents = syncSubAgents.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 ?? []
-		});
+	const normalizeSubagentSpec = (input) => {
+		const subagentMiddleware = [
+			(0, langchain.todoListMiddleware)(),
+			createFilesystemMiddleware({ backend }),
+			createSummarizationMiddleware({
+				backend,
+				model
+			}),
+			createPatchToolCallsMiddleware(),
+			...input.skills != null && input.skills.length > 0 ? [createSkillsMiddleware({
+				backend,
+				sources: input.skills
+			})] : [],
+			...input.middleware ?? [],
+			...cacheMiddleware
+		];
 		return {
-			...subagent,
-			middleware: [subagentSkillsMiddleware, ...subagent.middleware || []]
+			...input,
+			tools: input.tools ?? [],
+			middleware: subagentMiddleware
 		};
-	});
-	/**
-	* Middleware for custom subagents (does NOT include skills from main agent).
-	* Custom subagents must define their own `skills` property to get skills.
-	*
-	* Uses createSummarizationMiddleware (deepagents version) with backend support
-	* and auto-computed defaults from model profile, matching Python's create_deep_agent.
-	* When trigger is not provided, defaults are lazily computed:
-	*   - With model profile: fraction-based (trigger=0.85, keep=0.10)
-	*   - Without profile: fixed (trigger=170k tokens, keep=6 messages)
-	*/
-	const subagentMiddleware = [
+	};
+	const allSubagents = subagents;
+	const asyncSubAgents = allSubagents.filter((item) => isAsyncSubAgent(item));
+	const inlineSubagents = allSubagents.filter((item) => !isAsyncSubAgent(item)).map((item) => "runnable" in item ? item : normalizeSubagentSpec(item));
+	if (!inlineSubagents.some((item) => item.name === GENERAL_PURPOSE_SUBAGENT["name"])) {
+		const generalPurposeSpec = normalizeSubagentSpec({
+			...GENERAL_PURPOSE_SUBAGENT,
+			model,
+			skills,
+			tools
+		});
+		inlineSubagents.unshift(generalPurposeSpec);
+	}
+	const skillsMiddleware = skills != null && skills.length > 0 ? [createSkillsMiddleware({
+		backend,
+		sources: skills
+	})] : [];
+	const [todoMiddleware, fsMiddleware, subagentMiddleware, summarizationMiddleware, patchToolCallsMiddleware] = [
 		(0, langchain.todoListMiddleware)(),
-		createFilesystemMiddleware({ backend: filesystemBackend }),
+		createFilesystemMiddleware({ backend }),
+		createSubAgentMiddleware({
+			defaultModel: model,
+			defaultTools: tools,
+			defaultInterruptOn: interruptOn,
+			subagents: inlineSubagents,
+			generalPurposeAgent: false
+		}),
 		createSummarizationMiddleware({
 			model,
-			backend: filesystemBackend
+			backend
 		}),
 		createPatchToolCallsMiddleware()
 	];
+	const middleware = [
+		todoMiddleware,
+		...skillsMiddleware,
+		fsMiddleware,
+		subagentMiddleware,
+		summarizationMiddleware,
+		patchToolCallsMiddleware,
+		...asyncSubAgents.length > 0 ? [createAsyncSubAgentMiddleware({ asyncSubAgents })] : [],
+		...customMiddleware,
+		...cacheMiddleware,
+		...memory && memory.length > 0 ? [createMemoryMiddleware({
+			backend,
+			sources: memory,
+			addCacheControl: anthropicModel
+		})] : [],
+		...interruptOn ? [(0, langchain.humanInTheLoopMiddleware)({ interruptOn })] : []
+	];
 	/**
 	* Return as DeepAgent with proper DeepAgentTypeConfig
 	* - Response: InferStructuredResponse<TResponse> (unwraps ToolStrategy<T>/ProviderStrategy<T> → T)
@@ -6337,55 +6590,32 @@ function createDeepAgent(params = {}) {
 	*/
 	return (0, langchain.createAgent)({
 		model,
-		systemPrompt: finalSystemPrompt,
+		systemPrompt: typeof systemPrompt === "string" ? new langchain.SystemMessage({ contentBlocks: [{
+			type: "text",
+			text: systemPrompt
+		}, {
+			type: "text",
+			text: BASE_AGENT_PROMPT
+		}] }) : langchain.SystemMessage.isInstance(systemPrompt) ? new langchain.SystemMessage({ contentBlocks: [...systemPrompt.contentBlocks, {
+			type: "text",
+			text: BASE_AGENT_PROMPT
+		}] }) : new langchain.SystemMessage({ contentBlocks: [{
+			type: "text",
+			text: BASE_AGENT_PROMPT
+		}] }),
 		tools,
-		middleware: [
-			...[
-				(0, langchain.todoListMiddleware)(),
-				createFilesystemMiddleware({ backend: filesystemBackend }),
-				createSubAgentMiddleware({
-					defaultModel: model,
-					defaultTools: tools,
-					defaultMiddleware: [...subagentMiddleware, ...anthropicModel ? [(0, langchain.anthropicPromptCachingMiddleware)({
-						unsupportedModelBehavior: "ignore",
-						minMessagesToCache: 1
-					}), createCacheBreakpointMiddleware()] : []],
-					generalPurposeMiddleware: [
-						...subagentMiddleware,
-						...skillsMiddlewareArray,
-						...anthropicModel ? [(0, langchain.anthropicPromptCachingMiddleware)({
-							unsupportedModelBehavior: "ignore",
-							minMessagesToCache: 1
-						}), createCacheBreakpointMiddleware()] : []
-					],
-					defaultInterruptOn: interruptOn,
-					subagents: processedSubagents,
-					generalPurposeAgent: true
-				}),
-				createSummarizationMiddleware({
-					model,
-					backend: filesystemBackend
-				}),
-				createPatchToolCallsMiddleware()
-			],
-			...skillsMiddlewareArray,
-			...customMiddleware,
-			...anthropicModel ? [(0, langchain.anthropicPromptCachingMiddleware)({
-				unsupportedModelBehavior: "ignore",
-				minMessagesToCache: 1
-			}), createCacheBreakpointMiddleware()] : [],
-			...memoryMiddlewareArray,
-			...interruptOn ? [(0, langchain.humanInTheLoopMiddleware)({ interruptOn })] : [],
-			...asyncSubAgents && asyncSubAgents.length > 0 ? [createAsyncSubAgentMiddleware({ asyncSubAgents })] : []
-		],
-		...responseFormat != null && { responseFormat },
+		middleware,
+		...responseFormat !== null && { responseFormat },
 		contextSchema,
 		checkpointer,
 		store,
 		name
 	}).withConfig({
 		recursionLimit: 1e4,
-		metadata: { ls_integration: "deepagents" }
+		metadata: {
+			ls_integration: "deepagents",
+			lc_agent_name: name
+		}
 	});
 }
 //#endregion
@@ -6920,7 +7150,7 @@ exports.adaptSandboxProtocol = adaptSandboxProtocol;
 exports.computeSummarizationDefaults = computeSummarizationDefaults;
 exports.createAgentMemoryMiddleware = createAgentMemoryMiddleware;
 exports.createAsyncSubAgentMiddleware = createAsyncSubAgentMiddleware;
-exports.createCompletionNotifierMiddleware = createCompletionNotifierMiddleware;
+exports.createCompletionCallbackMiddleware = createCompletionCallbackMiddleware;
 exports.createDeepAgent = createDeepAgent;
 exports.createFilesystemMiddleware = createFilesystemMiddleware;
 exports.createMemoryMiddleware = createMemoryMiddleware;
@@ -6936,5 +7166,6 @@ exports.isSandboxBackend = isSandboxBackend;
 exports.isSandboxProtocol = isSandboxProtocol;
 exports.listSkills = listSkills;
 exports.parseSkillMetadata = parseSkillMetadata;
+exports.resolveBackend = resolveBackend;
 
 //# sourceMappingURL=index.cjs.map