deepagents 1.13.2 → 1.13.4-rc.0

package/dist/{langsmith-BBV5JlNW.js → langsmith-CkXiO0e9.js}

@@ -1,8 +1,8 @@
-import { AIMessage, HumanMessage, SystemMessage, ToolMessage, anthropicPromptCachingMiddleware, bedrockPromptCachingMiddleware, context, countTokensApproximately, createAgent, createMiddleware, humanInTheLoopMiddleware, todoListMiddleware, tool } from "langchain";
+import { AIMessage, HumanMessage, SystemMessage, ToolMessage, anthropicPromptCachingMiddleware, bedrockPromptCachingMiddleware, context, countTokensApproximately, createAgent, createMiddleware, humanInTheLoopMiddleware, omitPayload, todoListMiddleware, tool } from "langchain";
 import { Command, REMOVE_ALL_MESSAGES, ReducedValue, StateSchema, getConfig, getCurrentTaskInput, getStore, isCommand } from "@langchain/langgraph";
 import { z } from "zod/v4";
 import micromatch from "micromatch";
-import { AIMessage as AIMessage$1, HumanMessage as HumanMessage$1, RemoveMessage, ToolMessage as ToolMessage$1, getBufferString } from "@langchain/core/messages";
+import { AIMessage as AIMessage$1, HumanMessage as HumanMessage$1, RemoveMessage, SystemMessage as SystemMessage$1, ToolMessage as ToolMessage$1, getBufferString } from "@langchain/core/messages";
 import * as z$2 from "zod";
 import { z as z$1 } from "zod";
 import { ContextOverflowError } from "@langchain/core/errors";
@@ -2574,6 +2574,7 @@ function createFilesystemMiddleware(options = {}) {
 	}
 	return createMiddleware({
 		name: "FilesystemMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		stateSchema: FilesystemStateSchema,
 		tools: allTools,
 		async beforeAgent(state) {
@@ -3313,6 +3314,7 @@ function createSummarizationMiddleware(options) {
 	}
 	return createMiddleware({
 		name: "SummarizationMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		stateSchema: SummarizationStateSchema,
 		async wrapModelCall(request, handler) {
 			const effectiveMessages = getEffectiveMessages(request.messages ?? [], request.state);
@@ -3358,6 +3360,83 @@ function createSummarizationMiddleware(options) {
 	});
 }
 //#endregion
+//#region src/middleware/utils.ts
+/**
+* Utility functions for middleware.
+*
+* This module provides shared helpers used across middleware implementations.
+*/
+/**
+* Merge custom middleware into an assembled stack by `.name`.
+*
+* Matching custom middleware replaces the existing entry in place. New
+* middleware is appended after the base stack in caller-provided order.
+*/
+function mergeMiddleware$1(base, custom) {
+	const merged = new Map(base.map((middleware) => [middleware.name, middleware]));
+	for (const middleware of custom) merged.set(middleware.name, middleware);
+	return [...merged.values()];
+}
+function middlewareNames(middleware) {
+	return new Set(middleware.map((entry) => entry.name));
+}
+function matchingMiddleware(middleware, names) {
+	return middleware.filter((entry) => names.has(entry.name));
+}
+/**
+* Merge custom middleware into default and tail middleware segments.
+*
+* Same-name custom entries replace matching defaults in either segment. Novel
+* custom entries are inserted between the default and tail segments unless
+* `appendNew` is false.
+*/
+function mergeMiddlewareStack(defaultMiddleware, customMiddleware, tailMiddleware = [], options = {}) {
+	const defaultMiddlewareNames = middlewareNames(defaultMiddleware);
+	const tailMiddlewareNames = middlewareNames(tailMiddleware);
+	const knownMiddlewareNames = /* @__PURE__ */ new Set([...defaultMiddlewareNames, ...tailMiddlewareNames]);
+	const novelMiddleware = options.appendNew === false ? [] : customMiddleware.filter((entry) => !knownMiddlewareNames.has(entry.name));
+	return [
+		...mergeMiddleware$1(defaultMiddleware, matchingMiddleware(customMiddleware, defaultMiddlewareNames)),
+		...novelMiddleware,
+		...mergeMiddleware$1(tailMiddleware, matchingMiddleware(customMiddleware, tailMiddlewareNames))
+	];
+}
+/**
+* Append text to a system message.
+*
+* Creates a new SystemMessage with the text appended to the existing content.
+* If the original message has content, the new text is separated by two newlines.
+*
+* @param systemMessage - Existing system message or null/undefined.
+* @param text - Text to add to the system message.
+* @returns New SystemMessage with the text appended.
+*
+* @example
+* ```typescript
+* const original = new SystemMessage({ content: "You are a helpful assistant." });
+* const updated = appendToSystemMessage(original, "Always be concise.");
+* // Result: SystemMessage with content "You are a helpful assistant.\n\nAlways be concise."
+* ```
+*/
+function appendToSystemMessage(systemMessage, text) {
+	if (!systemMessage) return new SystemMessage$1({ content: text });
+	const existingContent = systemMessage.content;
+	if (typeof existingContent === "string") {
+		const newContent = existingContent ? `${existingContent}\n\n${text}` : text;
+		return new SystemMessage$1({ content: newContent });
+	}
+	if (Array.isArray(existingContent)) {
+		const newContent = [...existingContent];
+		const textToAdd = newContent.length > 0 ? `\n\n${text}` : text;
+		newContent.push({
+			type: "text",
+			text: textToAdd
+		});
+		return new SystemMessage$1({ content: newContent });
+	}
+	return new SystemMessage$1({ content: text });
+}
+//#endregion
 //#region src/middleware/subagents.ts
 /**
 * Config key used by task-tool callers to request dynamic response format.
@@ -3371,6 +3450,8 @@ const SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY = "__deepagents_subagent_response_form
 * Provides a minimal base prompt that can be extended by specific subagent configurations.
 */
 const DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
+const FORKED_CONTEXT_KEY = "_deepagentsForkedContext";
+const FORK_RECURSION_REFUSAL = "You are a subagent and cannot delegate to another subagent. Complete this task yourself instead of calling this tool again.";
 /**
 * State keys excluded when passing state to subagents and when returning
 * updates from subagents. Summarization keys are excluded because their
@@ -3383,6 +3464,18 @@ const EXCLUDED_STATE_KEYS = [
 	"skillsMetadata",
 	"memoryContents",
 	"_summarizationEvent",
+	"_summarizationSessionId",
+	FORKED_CONTEXT_KEY
+];
+/**
+* State keys excluded when inheriting state into a declarative fork.
+* Narrower than `EXCLUDED_STATE_KEYS`: a fork's mirrored middleware needs
+* the parent's private channels (skills metadata, memory contents, etc.)
+* to rebuild an equivalent prompt.
+*/
+const FORK_EXCLUDED_STATE_KEYS = [
+	"structuredResponse",
+	"_summarizationEvent",
 	"_summarizationSessionId"
 ];
 /**
@@ -3392,25 +3485,37 @@ 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 context`
-    Launch an ephemeral subagent to handle a complex, multi-step task in an isolated context window.
+    Launch an ephemeral subagent to handle a complex, multi-step task.
 
     Available agent types and the tools they have access to:
     ${subagentDescriptions.join("\n")}
 
     Specify subagent_type to select the agent. Usage notes:
     - Launch multiple agents concurrently when their tasks are independent, using a single message with multiple tool calls.
-    - Each invocation is stateless: the agent sees only the prompt you give it and returns a single final report. Put full detail in the prompt and state exactly what it should return.
+    - Each invocation is stateless by default: the agent sees only the prompt you give it and returns a single final report. Put full detail in the prompt and state exactly what it should return — unless an agent type below says it inherits your conversation instead.
     - The agent's report is not shown to the user; relay a summary yourself.
-    - Tell the agent whether to create content, analyze, or only research, since it cannot see the user's intent.
+    - Tell the agent whether to create content, analyze, or only research, since it can't necessarily see the user's intent unless it inherits your conversation, as noted per agent type below.
     - If an agent's description says to use it proactively, do so without waiting to be asked.
     - When only general-purpose is available, use it for any complex, context-heavy task; it has the same capabilities as the main agent.
   `;
 }
+const FORKED_SUBAGENT_TOOL_NOTE = " (inherits your full conversation and system prompt — no need to restate context here)";
+const COMPILED_FORKED_SUBAGENT_TOOL_NOTE = " (inherits your conversation history — its system prompt is fixed in its own runnable)";
+/** Render one subagent's listing line for the task tool description. */
+function describeSubagentForTool(name, description, forked, compiled = false) {
+	return `- ${name}: ${description}${forked ? compiled ? COMPILED_FORKED_SUBAGENT_TOOL_NOTE : FORKED_SUBAGENT_TOOL_NOTE : ""}`;
+}
+const FORK_TASK_PREAMBLE = "[The messages above are a prior conversation you are continuing as the subagent that was just invoked. Any mention in them of delegating to a subagent already happened — you are that subagent, not the one being asked to delegate further. If you try to delegate to another subagent yourself, it will be refused — complete this task directly. Use the specific facts, figures, and identifiers already established in that conversation when completing the task below — do not answer generically when exact details are already available above. Your actual task is below.]\n\n";
+/**
+* Whether a declarative subagent spec has `mode: "fork"` set.
+*
+* A plain boolean, not a type predicate: `SubAgent` covers both `"fork"` and
+* `"isolated"`, so there's no distinct type left to narrow to.
+*/
 function isForkedSubAgent(value) {
 	if (typeof value !== "object" || value == null) return false;
 	if (!("mode" in value)) return false;
-	if (value.mode !== "fork") return false;
-	return true;
+	return value.mode === "fork";
 }
 /**
 * Base specification for the general-purpose subagent.
@@ -3453,15 +3558,26 @@ const GENERAL_PURPOSE_SUBAGENT = {
 	name: "general-purpose",
 	description: DEFAULT_GENERAL_PURPOSE_DESCRIPTION,
 	systemPrompt: DEFAULT_SUBAGENT_PROMPT,
-	mode: "handoff"
+	mode: "isolated"
 };
+function filterState(state, excludedKeys) {
+	const filtered = {};
+	for (const [key, value] of Object.entries(state)) if (!excludedKeys.includes(key)) filtered[key] = value;
+	return filtered;
+}
 /**
 * Filter state to exclude certain keys when passing to subagents
 */
 function filterStateForSubagent(state) {
-	const filtered = {};
-	for (const [key, value] of Object.entries(state)) if (!EXCLUDED_STATE_KEYS.includes(key)) filtered[key] = value;
-	return filtered;
+	return filterState(state, EXCLUDED_STATE_KEYS);
+}
+/**
+* Filter state to exclude only the keys a declarative fork must not resume
+* (structured response, summarization event/session) — see
+* `FORK_EXCLUDED_STATE_KEYS`.
+*/
+function filterStateForFork(state) {
+	return filterState(state, FORK_EXCLUDED_STATE_KEYS);
 }
 /**
 * Invalid tool message block types
@@ -3505,6 +3621,16 @@ function stripInFlightAIMessage(messages) {
 	const last = messages.at(-1);
 	return AIMessage$1.isInstance(last) && (last.tool_calls?.length ?? 0) > 0 ? messages.slice(0, -1) : messages;
 }
+const ForkedContextStateSchema = z.object({ [FORKED_CONTEXT_KEY]: z.boolean().optional() });
+function createForkTaskToolMiddleware(taskTool) {
+	return createMiddleware({
+		name: "forkTaskToolMiddleware",
+		tracePolicy: { processInputs: omitPayload },
+		stateSchema: ForkedContextStateSchema,
+		tools: [taskTool],
+		beforeAgent: () => ({ [FORKED_CONTEXT_KEY]: true })
+	});
+}
 /**
 * Create a runnable agent from a declarative `SubAgent` spec.
 *
@@ -3534,6 +3660,17 @@ function createSubAgent(spec, options) {
 	});
 }
 /**
+* Resolve a fork's system prompt: the parent's inherited prompt, with the
+* fork's own systemPrompt (if any) appended as an addendum rather than
+* replacing it.
+*/
+function resolveForkSystemPrompt(parentSystemPrompt, forkAddendum) {
+	if (!forkAddendum) return parentSystemPrompt ?? "";
+	const addendumText = typeof forkAddendum === "string" ? forkAddendum : forkAddendum.text;
+	if (SystemMessage.isInstance(parentSystemPrompt)) return appendToSystemMessage(parentSystemPrompt, addendumText);
+	return parentSystemPrompt ? `${parentSystemPrompt}\n\n${addendumText}` : addendumText;
+}
+/**
 * Create subagent instances from specifications.
 *
 * Returns compiled agents, raw specs keyed by name (for on-demand
@@ -3541,13 +3678,18 @@ function createSubAgent(spec, options) {
 * of names that should fork the parent's conversation.
 */
 function getSubagents(options) {
-	const { defaultModel, defaultTools, defaultMiddleware, generalPurposeMiddleware: gpMiddleware, defaultInterruptOn, subagents, generalPurposeAgent, parentSystemPrompt = null } = options;
+	const { defaultModel, defaultTools, defaultMiddleware, generalPurposeMiddleware: gpMiddleware, defaultInterruptOn, subagents, generalPurposeAgent, parentSystemPrompt = null, mirroredTaskTool } = options;
 	const defaultSubagentMiddleware = defaultMiddleware || [];
 	const generalPurposeMiddlewareBase = gpMiddleware || defaultSubagentMiddleware;
 	const agents = {};
 	const specsByName = {};
 	const subagentDescriptions = [];
 	const forkModeNames = /* @__PURE__ */ new Set();
+	const seenNames = new Set(generalPurposeAgent ? ["general-purpose"] : []);
+	for (const agentParams of subagents) {
+		if (seenNames.has(agentParams.name)) throw new Error(`Duplicate subagent name '${agentParams.name}'; each subagent must have a unique name.`);
+		seenNames.add(agentParams.name);
+	}
 	if (generalPurposeAgent) {
 		const generalPurposeMiddleware = [...generalPurposeMiddlewareBase];
 		if (defaultInterruptOn) generalPurposeMiddleware.push(humanInTheLoopMiddleware({ interruptOn: defaultInterruptOn }));
@@ -3561,24 +3703,34 @@ function getSubagents(options) {
 		};
 		agents["general-purpose"] = createSubAgent(gpSpec);
 		specsByName["general-purpose"] = gpSpec;
-		subagentDescriptions.push(`- general-purpose: ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION}`);
+		subagentDescriptions.push(describeSubagentForTool("general-purpose", DEFAULT_GENERAL_PURPOSE_DESCRIPTION, false));
 	}
 	for (const agentParams of subagents) {
 		const rawMode = agentParams.mode;
-		if (rawMode != null && rawMode !== "handoff" && rawMode !== "fork") throw new Error(`SubAgent '${agentParams.name}' has invalid mode '${rawMode}' — must be "handoff" or "fork".`);
-		subagentDescriptions.push(`- ${agentParams.name}: ${agentParams.description}`);
+		if (rawMode != null && rawMode !== "isolated" && rawMode !== "fork" && rawMode !== "handoff") throw new Error(`SubAgent '${agentParams.name}' has invalid mode '${rawMode}' — must be "isolated" or "fork".`);
+		const forked = isForkedSubAgent(agentParams);
+		const compiled = "runnable" in agentParams;
+		subagentDescriptions.push(describeSubagentForTool(agentParams.name, agentParams.description, forked, compiled));
 		if ("runnable" in agentParams) {
 			agents[agentParams.name] = agentParams.runnable;
 			specsByName[agentParams.name] = agentParams;
-			if (isForkedSubAgent(agentParams)) forkModeNames.add(agentParams.name);
-		} else if (isForkedSubAgent(agentParams)) {
+			if (forked) forkModeNames.add(agentParams.name);
+			continue;
+		}
+		const subagentMiddleware = [...defaultSubagentMiddleware, ...agentParams.middleware ?? []];
+		if (forked) {
+			const rawSkills = agentParams.skills;
+			if (Array.isArray(rawSkills) && rawSkills.length > 0) throw new Error(`SubAgent '${agentParams.name}' cannot set skills under mode: "fork"; the parent's skills are inherited instead.`);
+			const resolvedSystemPrompt = resolveForkSystemPrompt(parentSystemPrompt, agentParams.systemPrompt);
+			const fsIndex = subagentMiddleware.findIndex((m) => m.name === "FilesystemMiddleware");
+			subagentMiddleware.splice(fsIndex + 1, 0, createForkTaskToolMiddleware(mirroredTaskTool));
 			const resolvedSpec = {
 				...agentParams,
-				systemPrompt: parentSystemPrompt ?? "",
+				systemPrompt: resolvedSystemPrompt,
 				mode: void 0,
 				model: agentParams.model ?? defaultModel,
 				tools: agentParams.tools ?? defaultTools,
-				middleware: [...defaultSubagentMiddleware, ...agentParams.middleware ?? []],
+				middleware: subagentMiddleware,
 				interruptOn: agentParams.interruptOn ?? defaultInterruptOn ?? void 0
 			};
 			agents[agentParams.name] = createSubAgent(resolvedSpec);
@@ -3587,10 +3739,10 @@ function getSubagents(options) {
 		} else {
 			const resolvedSpec = {
 				...agentParams,
-				mode: "handoff",
+				mode: "isolated",
 				model: agentParams.model ?? defaultModel,
 				tools: agentParams.tools ?? defaultTools,
-				middleware: [...defaultSubagentMiddleware, ...agentParams.middleware ?? []],
+				middleware: subagentMiddleware,
 				interruptOn: agentParams.interruptOn ?? defaultInterruptOn ?? void 0
 			};
 			agents[agentParams.name] = createSubAgent(resolvedSpec);
@@ -3609,16 +3761,12 @@ function getSubagents(options) {
 */
 function createTaskTool(options) {
 	const { defaultModel, defaultTools, defaultMiddleware, generalPurposeMiddleware, defaultInterruptOn, subagents, generalPurposeAgent, taskDescription, parentSystemPrompt = null } = options;
-	const { agents: subagentGraphs, specsByName, descriptions: subagentDescriptions, forkModeNames } = getSubagents({
-		defaultModel,
-		defaultTools,
-		defaultMiddleware,
-		generalPurposeMiddleware,
-		defaultInterruptOn,
-		subagents,
-		generalPurposeAgent,
-		parentSystemPrompt
-	});
+	const subagentNames = [...generalPurposeAgent ? ["general-purpose"] : [], ...subagents.map((spec) => spec.name)];
+	const subagentDescriptions = [...generalPurposeAgent ? [describeSubagentForTool("general-purpose", DEFAULT_GENERAL_PURPOSE_DESCRIPTION, false)] : [], ...subagents.map((spec) => describeSubagentForTool(spec.name, spec.description, isForkedSubAgent(spec), "runnable" in spec))];
+	const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
+	let subagentGraphs = {};
+	let specsByName = {};
+	let forkModeNames = /* @__PURE__ */ new Set();
 	function selectSubagent(subagentType, config) {
 		const spec = specsByName[subagentType];
 		const responseFormat = config.configurable?.[SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY];
@@ -3626,18 +3774,19 @@ function createTaskTool(options) {
 		if ("runnable" in spec || responseFormat == null) return subagentGraphs[subagentType];
 		return createSubAgent(spec, { responseFormat });
 	}
-	const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-	return tool(async (input, config) => {
+	async function runTask(input, config) {
 		const { description, subagent_type } = input;
+		const currentState = getCurrentTaskInput();
+		if (currentState[FORKED_CONTEXT_KEY]) return FORK_RECURSION_REFUSAL;
 		if (!(subagent_type in subagentGraphs)) {
 			const allowedTypes = Object.keys(subagentGraphs).map((k) => `\`${k}\``).join(", ");
 			throw new Error(`Error: invoked agent of type ${subagent_type}, the only allowed types are ${allowedTypes}`);
 		}
 		const shouldFork = forkModeNames.has(subagent_type);
 		const subagent = selectSubagent(subagent_type, config);
-		const currentState = getCurrentTaskInput();
-		const subagentState = filterStateForSubagent(currentState);
-		if (shouldFork) subagentState.messages = [...getEffectiveMessages(stripInFlightAIMessage(currentState.messages ?? []), currentState), new HumanMessage$1({ content: description })];
+		const spec = specsByName[subagent_type];
+		const subagentState = shouldFork && !("runnable" in spec) ? filterStateForFork(currentState) : filterStateForSubagent(currentState);
+		if (shouldFork) subagentState.messages = [...getEffectiveMessages(stripInFlightAIMessage(currentState.messages ?? []), currentState), new HumanMessage$1({ content: FORK_TASK_PREAMBLE + description })];
 		else subagentState.messages = [new HumanMessage$1({ content: description })];
 		subagentState._summarizationSessionId = `session_${crypto.randomUUID().substring(0, 8)}`;
 		const subagentConfig = {
@@ -3664,14 +3813,35 @@ function createTaskTool(options) {
 			return content;
 		}
 		return returnCommandWithStateUpdate(result, config.toolCall.id);
-	}, {
+	}
+	const taskToolSchema = z.object({
+		description: z.string().describe("The task to execute with the selected agent"),
+		subagent_type: z.string().describe(`Name of the agent to use. Available: ${subagentNames.join(", ")}`)
+	});
+	const taskTool = tool(runTask, {
 		name: "task",
 		description: finalTaskDescription,
-		schema: z.object({
-			description: z.string().describe("The task to execute with the selected agent"),
-			subagent_type: z.string().describe(`Name of the agent to use. Available: ${Object.keys(subagentGraphs).join(", ")}`)
+		schema: taskToolSchema
+	});
+	const { agents, specsByName: resolvedSpecsByName, forkModeNames: resolvedForkModeNames } = getSubagents({
+		defaultModel,
+		defaultTools,
+		defaultMiddleware,
+		generalPurposeMiddleware,
+		defaultInterruptOn,
+		subagents,
+		generalPurposeAgent,
+		parentSystemPrompt,
+		mirroredTaskTool: tool(runTask, {
+			name: "task",
+			description: finalTaskDescription,
+			schema: taskToolSchema
 		})
 	});
+	subagentGraphs = agents;
+	specsByName = resolvedSpecsByName;
+	forkModeNames = resolvedForkModeNames;
+	return taskTool;
 }
 /**
 * Create subagent middleware with task tool
@@ -3691,6 +3861,7 @@ function createSubAgentMiddleware(options) {
 	});
 	return createMiddleware({
 		name: "subAgentMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		tools: [taskTool],
 		wrapModelCall: async (request, handler) => {
 			if (systemPrompt !== null) return handler({
@@ -3795,6 +3966,7 @@ function patchDanglingToolCalls(messages) {
 function createPatchToolCallsMiddleware() {
 	return createMiddleware({
 		name: "patchToolCallsMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		beforeAgent: async (state) => {
 			const messages = state.messages;
 			if (!messages || messages.length === 0) return;
@@ -4156,6 +4328,7 @@ function createMemoryMiddleware(options) {
 	const { backend, sources, addCacheControl = false } = options;
 	return createMiddleware({
 		name: "MemoryMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		stateSchema: MemoryStateSchema,
 		async beforeAgent(state) {
 			if ("memoryContents" in state && state.memoryContents != null) return;
@@ -4640,6 +4813,7 @@ function createSkillsMiddleware(options) {
 	let loadedSkills = [];
 	return createMiddleware({
 		name: "SkillsMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		stateSchema: SkillsStateSchema,
 		async beforeAgent(state) {
 			const stateHasSkills = "skillsMetadata" in state && Array.isArray(state.skillsMetadata) && state.skillsMetadata.length > 0;
@@ -4673,43 +4847,6 @@ function createSkillsMiddleware(options) {
 	});
 }
 //#endregion
-//#region src/middleware/utils.ts
-/**
-* Merge custom middleware into an assembled stack by `.name`.
-*
-* Matching custom middleware replaces the existing entry in place. New
-* middleware is appended after the base stack in caller-provided order.
-*/
-function mergeMiddleware$1(base, custom) {
-	const merged = new Map(base.map((middleware) => [middleware.name, middleware]));
-	for (const middleware of custom) merged.set(middleware.name, middleware);
-	return [...merged.values()];
-}
-function middlewareNames(middleware) {
-	return new Set(middleware.map((entry) => entry.name));
-}
-function matchingMiddleware(middleware, names) {
-	return middleware.filter((entry) => names.has(entry.name));
-}
-/**
-* Merge custom middleware into default and tail middleware segments.
-*
-* Same-name custom entries replace matching defaults in either segment. Novel
-* custom entries are inserted between the default and tail segments unless
-* `appendNew` is false.
-*/
-function mergeMiddlewareStack(defaultMiddleware, customMiddleware, tailMiddleware = [], options = {}) {
-	const defaultMiddlewareNames = middlewareNames(defaultMiddleware);
-	const tailMiddlewareNames = middlewareNames(tailMiddleware);
-	const knownMiddlewareNames = /* @__PURE__ */ new Set([...defaultMiddlewareNames, ...tailMiddlewareNames]);
-	const novelMiddleware = options.appendNew === false ? [] : customMiddleware.filter((entry) => !knownMiddlewareNames.has(entry.name));
-	return [
-		...mergeMiddleware$1(defaultMiddleware, matchingMiddleware(customMiddleware, defaultMiddlewareNames)),
-		...novelMiddleware,
-		...mergeMiddleware$1(tailMiddleware, matchingMiddleware(customMiddleware, tailMiddlewareNames))
-	];
-}
-//#endregion
 //#region src/middleware/completion_callback.ts
 /**
 * Callback middleware for async subagents.
@@ -4921,6 +5058,7 @@ function createCompletionCallbackMiddleware(options) {
 	}
 	return createMiddleware({
 		name: "CompletionCallbackMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		stateSchema: CompletionCallbackStateSchema,
 		/**
 		* After-agent hook: fires when the subagent completes successfully.
@@ -5462,6 +5600,7 @@ function createAsyncSubAgentMiddleware(options) {
 	const fullSystemPrompt = systemPrompt ? `${systemPrompt}\n\nAvailable async subagent types:\n${agentsDescription}` : null;
 	return createMiddleware({
 		name: "asyncSubAgentMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		stateSchema: AsyncTaskStateSchema,
 		tools,
 		wrapModelCall: async (request, handler) => {
@@ -5544,6 +5683,7 @@ var ConfigurationError = class ConfigurationError extends Error {
 function createCacheBreakpointMiddleware() {
 	return createMiddleware({
 		name: "CacheBreakpointMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		wrapModelCall(request, handler) {
 			if (!isAnthropicModel(request.model)) return handler(request);
 			const existingContent = request.systemMessage.content;
@@ -5578,6 +5718,7 @@ function hasToolName(tool) {
 function createToolExclusionMiddleware(excludedTools) {
 	return createMiddleware({
 		name: "_ToolExclusionMiddleware",
+		tracePolicy: { processInputs: omitPayload },
 		wrapModelCall(request, handler) {
 			return handler({
 				...request,
@@ -6338,8 +6479,18 @@ function createDeepAgent(params = {}) {
 		providerHint: getModelProvider(model),
 		identifierHint: getModelIdentifier(model)
 	});
-	const filesystemTools = FILESYSTEM_TOOL_NAMES.filter((toolName) => !harnessProfile.excludedTools.has(toolName));
-	const profileFilesystemTools = filesystemTools.length === FILESYSTEM_TOOL_NAMES.length ? void 0 : filesystemTools.includes("read_file") ? filesystemTools : ["read_file", ...filesystemTools];
+	const computeProfileFilesystemTools = (profile) => {
+		const filesystemTools = FILESYSTEM_TOOL_NAMES.filter((toolName) => !profile.excludedTools.has(toolName));
+		return filesystemTools.length === FILESYSTEM_TOOL_NAMES.length ? void 0 : filesystemTools.includes("read_file") ? filesystemTools : ["read_file", ...filesystemTools];
+	};
+	const profileFilesystemTools = computeProfileFilesystemTools(harnessProfile);
+	const resolveSubagentProfile = (subagentModel) => {
+		if (subagentModel == null || subagentModel === model) return harnessProfile;
+		return typeof subagentModel === "string" ? resolveHarnessProfile({ spec: subagentModel }) : resolveHarnessProfile({
+			providerHint: getModelProvider(subagentModel),
+			identifierHint: getModelIdentifier(subagentModel)
+		});
+	};
 	const toolOverrides = harnessProfile.toolDescriptionOverrides;
 	const effectiveTools = Object.keys(toolOverrides).length > 0 ? tools.map((t) => t.name in toolOverrides ? Object.assign(Object.create(Object.getPrototypeOf(t)), t, { description: toolOverrides[t.name] }) : t) : tools;
 	const anthropicModel = isAnthropicModel(model);
@@ -6375,44 +6526,50 @@ function createDeepAgent(params = {}) {
 	* 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 createSubagentDefaultMiddleware = (input) => {
+	const createSubagentDefaultMiddleware = (input, subagentProfile, forked) => {
 		const effectivePermissions = input.permissions ?? permissions;
 		return [
 			createFilesystemMiddleware({
 				backend,
 				permissions: effectivePermissions,
-				tools: profileFilesystemTools
+				tools: computeProfileFilesystemTools(subagentProfile)
 			}),
 			createSummarizationMiddleware({ backend }),
 			createPatchToolCallsMiddleware(),
-			...input.skills != null && input.skills.length > 0 ? [createSkillsMiddleware({
+			...!forked && input.skills != null && input.skills.length > 0 ? [createSkillsMiddleware({
 				backend,
 				sources: input.skills
 			})] : []
 		];
 	};
-	const buildSubagentMiddleware = (input, isForkable) => {
-		let subagentMiddleware = mergeMiddlewareStack(createSubagentDefaultMiddleware(input), input.middleware ?? [], [
-			...resolveMiddleware(harnessProfile.extraMiddleware),
+	const buildSubagentMiddleware = (input) => {
+		const subagentProfile = resolveSubagentProfile(input.model);
+		const forked = isForkedSubAgent(input);
+		const subagentDefaultMiddleware = createSubagentDefaultMiddleware(input, subagentProfile, forked);
+		if (forked && skills != null && skills.length > 0) subagentDefaultMiddleware.unshift(createSkillsMiddleware({
+			backend,
+			sources: skills
+		}));
+		let subagentMiddleware = mergeMiddlewareStack(subagentDefaultMiddleware, forked && customMiddleware.length > 0 ? mergeMiddleware$1(customMiddleware, input.middleware ?? []) : input.middleware ?? [], [
+			...resolveMiddleware(subagentProfile.extraMiddleware),
 			...cacheMiddleware,
-			...isForkable ? memoryMiddleware : []
+			...forked && memory != null && memory.length > 0 ? [createMemoryMiddleware({
+				backend,
+				sources: memory,
+				addCacheControl: anthropicModel
+			})] : []
 		]);
-		if (harnessProfile.excludedMiddleware.size > 0) subagentMiddleware = subagentMiddleware.filter((middleware) => !harnessProfile.excludedMiddleware.has(middleware.name));
+		if (subagentProfile.excludedMiddleware.size > 0) subagentMiddleware = subagentMiddleware.filter((middleware) => !subagentProfile.excludedMiddleware.has(middleware.name));
+		if (subagentProfile.excludedTools.size > 0) subagentMiddleware.push(createToolExclusionMiddleware(subagentProfile.excludedTools));
 		return subagentMiddleware;
 	};
 	const normalizeSubagentSpec = (input) => ({
 		...input,
-		tools: input.tools ?? [],
-		middleware: buildSubagentMiddleware(input, false)
-	});
-	const normalizeForkedSubagentSpec = (input) => ({
-		...input,
-		tools: input.tools ?? [],
-		middleware: buildSubagentMiddleware(input, true)
+		middleware: buildSubagentMiddleware(input)
 	});
 	const allSubagents = subagents;
 	const asyncSubAgents = allSubagents.filter((item) => isAsyncSubAgent(item));
-	const inlineSubagents = allSubagents.filter((item) => !isAsyncSubAgent(item)).map((item) => "runnable" in item ? item : isForkedSubAgent(item) ? normalizeForkedSubagentSpec(item) : normalizeSubagentSpec(item));
+	const inlineSubagents = allSubagents.filter((item) => !isAsyncSubAgent(item)).map((item) => "runnable" in item ? item : normalizeSubagentSpec(item));
 	const gpConfig = harnessProfile.generalPurposeSubagent;
 	if (!(gpConfig?.enabled === false) && !inlineSubagents.some((item) => item.name === GENERAL_PURPOSE_SUBAGENT["name"])) {
 		const gpSystemPrompt = gpConfig?.systemPrompt ?? applyProfilePrompt(harnessProfile, GENERAL_PURPOSE_SUBAGENT.systemPrompt);
@@ -8585,4 +8742,4 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 //#endregion
 export { DEFAULT_GENERAL_PURPOSE_DESCRIPTION as A, StateBackend as B, MAX_SKILL_DESCRIPTION_LENGTH as C, createMemoryMiddleware as D, createSkillsMiddleware as E, createSubAgentMiddleware as F, resolveBackend as G, applyGrepMaxCount as H, computeSummarizationDefaults as I, checkEmptyContent as J, adaptBackendProtocol as K, createSummarizationMiddleware as L, GENERAL_PURPOSE_SUBAGENT as M, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as N, filesValue as O, createSubAgent as P, performStringReplacement as Q, createFilesystemMiddleware as R, createCompletionCallbackMiddleware as S, MAX_SKILL_NAME_LENGTH as T, isSandboxBackend as U, SandboxError as V, isSandboxProtocol as W, isTextMimeType as X, getMimeType as Y, normalizeReadPagination as Z, createHarnessProfile as _, ASYNC_TASK_SYSTEM_PROMPT as a, createAsyncSubAgentMiddleware as b, TASK_SYSTEM_PROMPT as c, registerHarnessProfile as d, generalPurposeSubagentConfigSchema as f, EMPTY_HARNESS_PROFILE as g, serializeProfile as h, StoreBackend as i, DEFAULT_SUBAGENT_PROMPT as j, createPatchToolCallsMiddleware as k, createDeepAgent as l, parseHarnessProfileConfig as m, BaseSandbox as n, BASE_AGENT_PROMPT as o, harnessProfileConfigSchema as p, adaptSandboxProtocol as q, ContextHubBackend as r, EXECUTION_SYSTEM_PROMPT as s, LangSmithSandbox as t, getHarnessProfile as u, REQUIRED_MIDDLEWARE_NAMES as v, MAX_SKILL_FILE_SIZE as w, isAsyncSubAgent as x, ConfigurationError as y, CompositeBackend as z };
 
-//# sourceMappingURL=langsmith-BBV5JlNW.js.map
+//# sourceMappingURL=langsmith-CkXiO0e9.js.map