deepagents 1.9.1 → 1.10.0

package/dist/index.cjs

@@ -25,30 +25,30 @@ let langchain = require("langchain");
 let _langchain_langgraph = require("@langchain/langgraph");
 let zod_v4 = require("zod/v4");
 let micromatch = require("micromatch");
-micromatch = __toESM(micromatch);
+micromatch = __toESM(micromatch, 1);
 let path = require("path");
-path = __toESM(path);
+path = __toESM(path, 1);
 let _langchain_core_messages = require("@langchain/core/messages");
 let zod = require("zod");
-zod = __toESM(zod);
+zod = __toESM(zod, 1);
 let yaml = require("yaml");
-yaml = __toESM(yaml);
+yaml = __toESM(yaml, 1);
 let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
 let _langchain_core_errors = require("@langchain/core/errors");
 let langchain_chat_models_universal = require("langchain/chat_models/universal");
 let node_fs_promises = require("node:fs/promises");
-node_fs_promises = __toESM(node_fs_promises);
+node_fs_promises = __toESM(node_fs_promises, 1);
 let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
+node_fs = __toESM(node_fs, 1);
 let node_path = require("node:path");
-node_path = __toESM(node_path);
+node_path = __toESM(node_path, 1);
 let node_child_process = require("node:child_process");
-node_child_process = __toESM(node_child_process);
+node_child_process = __toESM(node_child_process, 1);
 let fast_glob = require("fast-glob");
-fast_glob = __toESM(fast_glob);
+fast_glob = __toESM(fast_glob, 1);
 let langsmith_experimental_sandbox = require("langsmith/experimental/sandbox");
 let node_os = require("node:os");
-node_os = __toESM(node_os);
+node_os = __toESM(node_os, 1);
 //#region src/backends/utils.ts
 /**
 * Shared utility functions for memory backend implementations.
@@ -2470,6 +2470,13 @@ function createPatchToolCallsMiddleware() {
 			if (!needsPatch) return;
 			return { messages: [new _langchain_core_messages.RemoveMessage({ id: _langchain_langgraph.REMOVE_ALL_MESSAGES }), ...patchedMessages] };
 		},
+		/**
+		* Also patch in wrapModelCall as a safety net.
+		* This handles edge cases where:
+		* - HITL rejects a tool call during graph resume
+		* - The state update from beforeAgent might not be applied in time
+		* - The model would otherwise receive dangling tool_call_ids
+		*/
 		wrapModelCall: async (request, handler) => {
 			const messages = request.messages;
 			if (!messages || messages.length === 0) return handler(request);
@@ -2571,6 +2578,10 @@ const filesValue = new _langchain_langgraph.ReducedValue(zod.z.record(zod.z.stri
 * State schema for memory middleware.
 */
 const MemoryStateSchema = new _langchain_langgraph.StateSchema({
+	/**
+	* Dict mapping source paths to their loaded content.
+	* Marked as private so it's not included in the final agent state.
+	*/
 	memoryContents: zod.z.record(zod.z.string(), zod.z.string()).optional(),
 	files: filesValue
 });
@@ -3286,7 +3297,9 @@ const CALLBACK_THREAD_ID_KEY = "callbackThreadId";
 * and read by `CompletionCallbackMiddleware` when sending callback
 * notifications.
 */
-const CompletionCallbackStateSchema = zod.object({ [CALLBACK_THREAD_ID_KEY]: zod.string().optional() });
+const CompletionCallbackStateSchema = zod.object({ 
+/** The callback thread ID. Used to address the notification. */
+[CALLBACK_THREAD_ID_KEY]: zod.string().optional() });
 /**
 * Build headers for the callback LangGraph server.
 *
@@ -3404,12 +3417,25 @@ function createCompletionCallbackMiddleware(options) {
 	return (0, langchain.createMiddleware)({
 		name: "CompletionCallbackMiddleware",
 		stateSchema: CompletionCallbackStateSchema,
+		/**
+		* After-agent hook: fires when the subagent completes successfully.
+		*
+		* Extracts the last message as a summary and sends it to the callback
+		* thread.
+		*/
 		async afterAgent(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));
 		},
+		/**
+		* Wrap model calls to catch errors and notify the callback thread.
+		*
+		* If a model call raises an exception, a generic error message is
+		* reported to the callback thread before re-raising. The actual error
+		* details are not leaked to the callback agent.
+		*/
 		async wrapModelCall(request, handler) {
 			try {
 				return await handler(request);
@@ -3543,15 +3569,22 @@ Summary:`;
 * list on subsequent calls.
 */
 const SummarizationEventSchema = zod.z.object({
+	/**
+	* The index in the state messages list where summarization occurred.
+	* Messages before this index have been summarized. */
 	cutoffIndex: zod.z.number(),
+	/** The HumanMessage containing the summary. */
 	summaryMessage: zod.z.instanceof(langchain.HumanMessage),
+	/** Path where the conversation history was offloaded, or null if offload failed. */
 	filePath: zod.z.string().nullable()
 });
 /**
 * State schema for summarization middleware.
 */
 const SummarizationStateSchema = zod.z.object({
+	/** Session ID for history file naming */
 	_summarizationSessionId: zod.z.string().optional(),
+	/** Most recent summarization event (private state, not visible to agent) */
 	_summarizationEvent: SummarizationEventSchema.optional()
 });
 /**
@@ -6661,6 +6694,271 @@ function createCacheBreakpointMiddleware() {
 	});
 }
 //#endregion
+//#region src/stream.ts
+/**
+* Deep Agent streaming support (experimental).
+*
+* Provides:
+* - `DeepAgentRunStream` — type overlay that adds `.subagents` to the
+*   `AgentRunStream` shape
+* - `createSubagentTransformer` — a `__native` transformer whose
+*   projection (`subagents`) lands directly on the `GraphRunStream`
+*   instance via langgraph-core's native transformer support
+*
+* See protocol proposal §15 (In-Process Streaming Interface) and §16
+* (Native Stream Transformers).
+*/
+function hasPrefix(ns, prefix) {
+	if (prefix.length > ns.length) return false;
+	for (let i = 0; i < prefix.length; i += 1) if (ns[i] !== prefix[i]) return false;
+	return true;
+}
+/**
+* Native transformer that correlates `task` tool calls into
+* {@link SubagentRunStream} objects and routes child-namespace
+* `tools` and `messages` events into per-subagent channels.
+*
+* Marked `__native: true` — the `subagents` projection key lands
+* directly on the `GraphRunStream` instance as `run.subagents`.
+*/
+function createSubagentTransformer(path) {
+	return () => {
+		const subagentsLog = _langchain_langgraph.StreamChannel.local();
+		const pendingByCallId = /* @__PURE__ */ new Map();
+		const pendingByNamespaceSegment = /* @__PURE__ */ new Map();
+		const latestValuesByNamespaceSegment = /* @__PURE__ */ new Map();
+		const subagentsByName = /* @__PURE__ */ new Map();
+		/** Maps tools-node namespace segment to subagent name. */
+		const toolsNodeToName = /* @__PURE__ */ new Map();
+		const childToolCalls = /* @__PURE__ */ new Map();
+		/** Active ChatModelStreamImpl per subagent (keyed by subagent name). */
+		const activeMessages = /* @__PURE__ */ new Map();
+		function deletePendingSubagent(pending) {
+			pendingByCallId.delete(pending.callId);
+			for (const [segment, entry] of pendingByNamespaceSegment) if (entry === pending) {
+				pendingByNamespaceSegment.delete(segment);
+				latestValuesByNamespaceSegment.delete(segment);
+			}
+		}
+		function subagentSegment(ns) {
+			return ns.length === path.length + 1 ? ns[path.length] : void 0;
+		}
+		function getOrCreateSubagentLogs(name) {
+			let logs = subagentsByName.get(name);
+			if (!logs) {
+				logs = {
+					messagesLog: _langchain_langgraph.StreamChannel.local(),
+					toolCallsLog: _langchain_langgraph.StreamChannel.local(),
+					nestedSubagentsLog: _langchain_langgraph.StreamChannel.local()
+				};
+				subagentsByName.set(name, logs);
+			}
+			return logs;
+		}
+		return {
+			__native: true,
+			init: () => ({ subagents: subagentsLog }),
+			process(event) {
+				if (!hasPrefix(event.params.namespace, path)) return true;
+				const ns = event.params.namespace;
+				const depth = ns.length - path.length;
+				if (depth <= 1 && event.method === "tools") {
+					const data = event.params.data;
+					const toolCallId = data.tool_call_id;
+					const toolName = data.tool_name;
+					if (toolName === "task" && data.event === "tool-started") {
+						const rawInput = data.input;
+						const input = typeof rawInput === "string" ? JSON.parse(rawInput) : rawInput ?? {};
+						const subagentName = input.subagent_type ?? "unknown";
+						const taskDescription = input.description ?? "";
+						let resolveTaskInput;
+						let resolveOutput;
+						let rejectOutput;
+						const taskInput = new Promise((res) => {
+							resolveTaskInput = res;
+						});
+						const output = new Promise((res, rej) => {
+							resolveOutput = res;
+							rejectOutput = rej;
+						});
+						const pending = {
+							name: subagentName,
+							callId: toolCallId,
+							resolveTaskInput,
+							resolveOutput,
+							rejectOutput
+						};
+						if (toolCallId) pendingByCallId.set(toolCallId, pending);
+						resolveTaskInput(taskDescription);
+						if (depth === 1) {
+							toolsNodeToName.set(ns[path.length], subagentName);
+							pendingByNamespaceSegment.set(ns[path.length], pending);
+						}
+						if (toolCallId) {
+							const taskSegment = `tools:${toolCallId}`;
+							toolsNodeToName.set(taskSegment, subagentName);
+							pendingByNamespaceSegment.set(taskSegment, pending);
+						}
+						const logs = getOrCreateSubagentLogs(subagentName);
+						subagentsLog.push({
+							name: subagentName,
+							taskInput,
+							output,
+							messages: logs.messagesLog,
+							toolCalls: logs.toolCallsLog,
+							subagents: logs.nestedSubagentsLog
+						});
+					}
+					if (toolName === "task" && toolCallId) {
+						const pending = pendingByCallId.get(toolCallId);
+						if (pending) {
+							if (data.event === "tool-finished") {
+								pending.resolveOutput(data.output);
+								deletePendingSubagent(pending);
+							} else if (data.event === "tool-error") {
+								const message = data.message ?? "unknown error";
+								pending.rejectOutput(new Error(message));
+								deletePendingSubagent(pending);
+							}
+						}
+					}
+				}
+				const segment = subagentSegment(ns);
+				const pending = segment ? pendingByNamespaceSegment.get(segment) : void 0;
+				if (pending) {
+					if (event.method === "values") latestValuesByNamespaceSegment.set(segment, event.params.data);
+					else if (event.method === "lifecycle") {
+						const data = event.params.data;
+						if (data.event === "completed" || data.event === "interrupted") {
+							pending.resolveOutput(latestValuesByNamespaceSegment.get(segment));
+							deletePendingSubagent(pending);
+						} else if (data.event === "failed") {
+							pending.rejectOutput(/* @__PURE__ */ new Error(`Subagent ${pending.name} failed`));
+							deletePendingSubagent(pending);
+						}
+					}
+				}
+				if (depth >= 2) {
+					const parentSegment = ns[path.length];
+					const subagentName = toolsNodeToName.get(parentSegment);
+					const logs = subagentName ? subagentsByName.get(subagentName) : void 0;
+					if (logs && subagentName) {
+						if (event.method === "tools") {
+							const data = event.params.data;
+							const toolCallId = data.tool_call_id;
+							const toolName = data.tool_name;
+							if (data.event === "tool-started") {
+								let resolveOutput;
+								let rejectOutput;
+								let resolveStatus;
+								let resolveError;
+								const output = new Promise((res, rej) => {
+									resolveOutput = res;
+									rejectOutput = rej;
+								});
+								const status = new Promise((res) => {
+									resolveStatus = res;
+								});
+								const error = new Promise((res) => {
+									resolveError = res;
+								});
+								childToolCalls.set(toolCallId, {
+									resolveOutput,
+									rejectOutput,
+									resolveStatus,
+									resolveError
+								});
+								const rawInput = data.input;
+								const parsedInput = typeof rawInput === "string" ? JSON.parse(rawInput) : rawInput;
+								logs.toolCallsLog.push({
+									name: toolName ?? "unknown",
+									callId: toolCallId,
+									input: parsedInput,
+									output,
+									status,
+									error
+								});
+							}
+							const pending = toolCallId ? childToolCalls.get(toolCallId) : void 0;
+							if (pending) {
+								if (data.event === "tool-finished") {
+									pending.resolveOutput(data.output);
+									pending.resolveStatus("finished");
+									pending.resolveError(void 0);
+									childToolCalls.delete(toolCallId);
+								} else if (data.event === "tool-error") {
+									const message = data.message ?? "unknown error";
+									pending.rejectOutput(new Error(message));
+									pending.resolveStatus("error");
+									pending.resolveError(message);
+									childToolCalls.delete(toolCallId);
+								}
+							}
+						}
+						if (event.method === "messages") {
+							const data = event.params.data;
+							if (data.event === "message-start") {
+								const eventsLog = _langchain_langgraph.StreamChannel.local();
+								const stream = new _langchain_langgraph.ChatModelStreamImpl(eventsLog);
+								eventsLog.push(data);
+								activeMessages.set(subagentName, {
+									stream,
+									eventsLog
+								});
+								logs.messagesLog.push(stream);
+							} else if (data.event === "message-finish") {
+								const active = activeMessages.get(subagentName);
+								if (active) {
+									active.eventsLog.push(data);
+									active.eventsLog.close();
+									activeMessages.delete(subagentName);
+								}
+							} else activeMessages.get(subagentName)?.eventsLog.push(data);
+						}
+					}
+				}
+				return true;
+			},
+			finalize() {
+				for (const pending of pendingByCallId.values()) pending.resolveOutput(void 0);
+				pendingByCallId.clear();
+				for (const pending of childToolCalls.values()) {
+					pending.resolveOutput(void 0);
+					pending.resolveStatus("finished");
+					pending.resolveError(void 0);
+				}
+				childToolCalls.clear();
+				for (const active of activeMessages.values()) active.eventsLog.fail(/* @__PURE__ */ new Error("run finalized before message completed"));
+				activeMessages.clear();
+				subagentsLog.close();
+				for (const logs of subagentsByName.values()) {
+					logs.toolCallsLog.close();
+					logs.messagesLog.close();
+					logs.nestedSubagentsLog.close();
+				}
+			},
+			fail(err) {
+				for (const pending of pendingByCallId.values()) pending.rejectOutput(err);
+				pendingByCallId.clear();
+				for (const pending of childToolCalls.values()) {
+					pending.rejectOutput(err);
+					pending.resolveStatus("error");
+					pending.resolveError(err instanceof Error ? err.message : String(err));
+				}
+				childToolCalls.clear();
+				for (const active of activeMessages.values()) active.eventsLog.fail(err);
+				activeMessages.clear();
+				subagentsLog.fail(err);
+				for (const logs of subagentsByName.values()) {
+					logs.toolCallsLog.fail(err);
+					logs.messagesLog.fail(err);
+					logs.nestedSubagentsLog.fail(err);
+				}
+			}
+		};
+	};
+}
+//#endregion
 //#region src/agent.ts
 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.
@@ -6746,7 +7044,7 @@ function isAnthropicModel(model) {
 * ```
 */
 function createDeepAgent(params = {}) {
-	const { model = "anthropic:claude-sonnet-4-6", tools = [], systemPrompt, middleware: customMiddleware = [], subagents = [], responseFormat, contextSchema, checkpointer, store, backend = (config) => new StateBackend(config), interruptOn, name, memory, skills, permissions = [] } = params;
+	const { model = "anthropic:claude-sonnet-4-6", tools = [], systemPrompt, middleware: customMiddleware = [], subagents = [], responseFormat, contextSchema, checkpointer, store, backend = (config) => new StateBackend(config), interruptOn, name, memory, skills, permissions = [], streamTransformers = [] } = 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);
@@ -6841,6 +7139,7 @@ function createDeepAgent(params = {}) {
 	* - Middleware: AllMiddleware (built-in + custom + subagent middleware for state inference)
 	* - Tools: TTools
 	* - Subagents: TSubagents (for type-safe streaming)
+	* - StreamTransformers: TStreamTransformers
 	*/
 	return (0, langchain.createAgent)({
 		model,
@@ -6863,7 +7162,8 @@ function createDeepAgent(params = {}) {
 		contextSchema,
 		checkpointer,
 		store,
-		name
+		name,
+		streamTransformers: [createSubagentTransformer([]), ...streamTransformers]
 	}).withConfig({
 		recursionLimit: 1e4,
 		metadata: {
@@ -7003,7 +7303,9 @@ function createSettings(options = {}) {
 * State schema for agent memory middleware.
 */
 const AgentMemoryStateSchema = zod.z.object({
+	/** Personal preferences from ~/.deepagents/{agent}/ (applies everywhere) */
 	userMemory: zod.z.string().optional(),
+	/** Project-specific context (loaded from project root) */
 	projectMemory: zod.z.string().optional()
 });
 /**
@@ -7412,6 +7714,7 @@ exports.createPatchToolCallsMiddleware = createPatchToolCallsMiddleware;
 exports.createSettings = createSettings;
 exports.createSkillsMiddleware = createSkillsMiddleware;
 exports.createSubAgentMiddleware = createSubAgentMiddleware;
+exports.createSubagentTransformer = createSubagentTransformer;
 exports.createSummarizationMiddleware = createSummarizationMiddleware;
 exports.filesValue = filesValue;
 exports.findProjectRoot = findProjectRoot;