@librechat/agents 4.0.1 → 4.0.3

package/dist/cjs/tools/subagent/SubagentExecutor.cjs

@@ -7,19 +7,21 @@ const require_hitl = require("../../types/hitl.cjs");
 const require_types = require("../../hooks/types.cjs");
 const require_eagerEventExecution = require("../eagerEventExecution.cjs");
 const require_toolBatchReplay = require("../toolBatchReplay.cjs");
+const require_streamLimits = require("../../llm/streamLimits.cjs");
+const require_providerText = require("../../protection/providerText.cjs");
 const require_HookRegistry = require("../../hooks/HookRegistry.cjs");
 const require_executeHooks = require("../../hooks/executeHooks.cjs");
 require("../../hooks/index.cjs");
 const require_injected = require("../../messages/injected.cjs");
 const require_toolSessions = require("../../utils/toolSessions.cjs");
 const require_request = require("../../llm/request.cjs");
-const require_streamLimits = require("../../llm/streamLimits.cjs");
 const require_events = require("../../events.cjs");
 const require_run = require("../../utils/run.cjs");
 const require_SubagentExecutionRegistry = require("./SubagentExecutionRegistry.cjs");
+const require_hostArgs = require("./hostArgs.cjs");
+const require_diagnostics = require("./diagnostics.cjs");
 require("./runtimeLimits.cjs");
 const require_childGraphConfig = require("./childGraphConfig.cjs");
-const require_diagnostics = require("./diagnostics.cjs");
 let nanoid = require("nanoid");
 let _langchain_core_callbacks_base = require("@langchain/core/callbacks/base");
 let _langchain_core_messages = require("@langchain/core/messages");
@@ -32,9 +34,15 @@ const MAX_QUEUED_SUBAGENT_UPDATES = 64;
 const MAX_BACKGROUND_SUBAGENT_SEALS = 32;
 const SUBAGENT_UPDATE_HANDLER_TIMEOUT_MS = 5e3;
 const TEXT_DELTA_CONTENT_TYPE = `text_delta`;
-const SUBAGENT_RESOLUTION_ERROR_MESSAGE = "Subagent error: Unable to initialize the selected subagent.";
 const SUBAGENT_CONFIG_CHANGED_MESSAGE = "Subagent error: Subagent configuration changed since this execution was paused.";
 const SUBAGENT_INVOCATION_CHANGED_MESSAGE = "Subagent error: Subagent invocation changed for this execution.";
+function isSubagentResolutionControlFlow(error) {
+	try {
+		return error instanceof require_streamLimits.StreamLimitExceededError || error instanceof require_providerText.ProviderTextProtectionError || (0, _langchain_langgraph.isGraphInterrupt)(error);
+	} catch {
+		return false;
+	}
+}
 function seedChildGraphSessions(childGraph, agents) {
 	require_toolSessions.seedAgentInitialSessions(childGraph.sessions, agents);
 }
@@ -188,13 +196,21 @@ function serializeToolOutput(settled) {
 function getSettlementFingerprint(output) {
 	return (0, crypto.createHash)("sha256").update(require_eagerEventExecution.stableStringify(output)).digest("hex");
 }
-function getBackgroundTaskFingerprint(description, subagentType, threadId) {
+function getBackgroundTaskFingerprint(description, subagentType, threadId, hostArgsDigest) {
 	return (0, crypto.createHash)("sha256").update(require_eagerEventExecution.stableStringify({
 		description,
 		subagentType,
-		...threadId == null || threadId === "" ? {} : { threadId }
+		...threadId == null || threadId === "" ? {} : { threadId },
+		...hostArgsDigest == null ? {} : { hostArgsDigest }
 	})).digest("hex");
 }
+function getHostArgsDigestFromArgs(config, args) {
+	if (config == null || !isObjectLike(args)) return;
+	const picked = require_hostArgs.pickSubagentHostArgInput(args, new Set(require_hostArgs.getSubagentHostArgSpecs(config).map(([name]) => name)));
+	if (!picked.ok) return;
+	const resolved = require_hostArgs.resolveSubagentHostArgs(config, picked.hostArgs);
+	return resolved.ok ? require_hostArgs.getSubagentHostArgsDigest(resolved.hostArgs) : void 0;
+}
 function getBackgroundTaskHookSessionId(sourceHookSessionId, taskId) {
 	return `${sourceHookSessionId}:subagent-task:${taskId}`;
 }
@@ -289,6 +305,7 @@ var SubagentExecutor = class SubagentExecutor {
 	executionContext;
 	langfuse;
 	tokenCounter;
+	providerTextProtection;
 	streamLimits;
 	humanInTheLoop;
 	checkpointer;
@@ -299,6 +316,7 @@ var SubagentExecutor = class SubagentExecutor {
 	usageSink;
 	taskConfig;
 	subagentContext;
+	onResolutionFailure;
 	executions;
 	replayCheckpointWorkflow;
 	resolveParentHandlerRegistry;
@@ -318,6 +336,7 @@ var SubagentExecutor = class SubagentExecutor {
 		this.langfuse = options.langfuse;
 		this.tokenCounter = options.tokenCounter;
 		this.streamLimits = options.streamLimits;
+		this.providerTextProtection = options.providerTextProtection;
 		this.humanInTheLoop = options.humanInTheLoop;
 		this.checkpointer = isCheckpointSaver(options.checkpointer) ? options.checkpointer : void 0;
 		this.executions = new require_SubagentExecutionRegistry.SubagentExecutionRegistry({
@@ -332,6 +351,7 @@ var SubagentExecutor = class SubagentExecutor {
 		this.usageSink = options.usageSink;
 		this.taskConfig = options.taskConfig;
 		this.subagentContext = options.subagentContext;
+		this.onResolutionFailure = options.onResolutionFailure;
 		const rawRegistry = options.parentHandlerRegistry;
 		if (typeof rawRegistry === "function") this.resolveParentHandlerRegistry = rawRegistry;
 		else if (rawRegistry != null) this.resolveParentHandlerRegistry = () => rawRegistry;
@@ -355,6 +375,13 @@ var SubagentExecutor = class SubagentExecutor {
 			status: "rejected",
 			message: `Unknown subagent type "${params.subagentType}".`
 		});
+		const hostArgResult = require_hostArgs.resolveSubagentHostArgs(executableConfig, params.hostArgs);
+		if (!hostArgResult.ok) return JSON.stringify({
+			status: "rejected",
+			tool: "subagent",
+			message: hostArgResult.message
+		});
+		const { hostArgs } = hostArgResult;
 		if (this.maxDepth <= 0) return JSON.stringify({
 			status: "rejected",
 			message: "Maximum subagent nesting depth exceeded."
@@ -390,13 +417,14 @@ var SubagentExecutor = class SubagentExecutor {
 			parentRunId: this.parentRunId,
 			...this.parentAgentId == null ? {} : { parentAgentId: this.parentAgentId },
 			parentToolCallId,
-			requestFingerprint: getBackgroundTaskFingerprint(params.description, params.subagentType, subagentThreadId),
+			requestFingerprint: getBackgroundTaskFingerprint(params.description, params.subagentType, subagentThreadId, require_hostArgs.getSubagentHostArgsDigest(hostArgs)),
 			...subagentThreadId == null || subagentThreadId === "" ? {} : { threadId: subagentThreadId },
 			input: params.description,
 			subagentKind: "kind" in executableConfig && executableConfig.kind === "graph" ? "graph" : "agent",
 			subagentType: params.subagentType,
 			run: (runtime, initialMessages) => this.executeDetached({
 				...params,
+				hostArgs,
 				...initialMessages == null ? {} : { initialMessages }
 			}, runtime, detachedHandlers, taskHookRegistry, detachedGraphFactory)
 		});
@@ -457,7 +485,9 @@ var SubagentExecutor = class SubagentExecutor {
 			tokenCounter: this.tokenCounter,
 			usageSink: this.usageSink,
 			subagentContext: this.subagentContext,
+			onResolutionFailure: this.onResolutionFailure,
 			streamLimits: this.streamLimits,
+			providerTextProtection: this.providerTextProtection,
 			humanInTheLoop: this.humanInTheLoop?.enabled === true || this.humanInTheLoop?.backgroundPausePolicy === "deny" ? {
 				enabled: false,
 				backgroundPausePolicy: "deny",
@@ -493,7 +523,10 @@ var SubagentExecutor = class SubagentExecutor {
 				deliveryAttempts += 1;
 				result = await executeAttempt();
 			}
-			if (result.error != null) throw new Error(result.error);
+			if (result.error != null) {
+				if (result.resolutionFailure != null) throw new require_diagnostics.SubagentResolutionError(result.resolutionFailure.phase, result.resolutionFailure.cause, result.resolutionFailure.hostArgument);
+				throw new Error(result.error);
+			}
 			if (this.humanInTheLoop?.enabled === true) {
 				const deniedTools = /* @__PURE__ */ new Set();
 				for (const message of result.messages) if (message instanceof _langchain_core_messages.ToolMessage && message.status === "error" && typeof message.content === "string" && message.content.startsWith("Blocked: Approval required for \"") && message.name != null) {
@@ -538,7 +571,8 @@ var SubagentExecutor = class SubagentExecutor {
 			parentToolCallId: context.parentToolCallId,
 			threadId: context.threadId,
 			signal: context.childSignal,
-			configurable: context.parentConfigurable == null ? void 0 : sanitizeResolverConfigurable(context.parentConfigurable)
+			configurable: context.parentConfigurable == null ? void 0 : sanitizeResolverConfigurable(context.parentConfigurable),
+			...context.hostArgs == null ? {} : { hostArgs: context.hostArgs }
 		}), context.childSignal).then((agentInputs) => ({
 			...config,
 			agentInputs
@@ -632,14 +666,15 @@ var SubagentExecutor = class SubagentExecutor {
 				approvalExecutionScope: require_SubagentExecutionRegistry.getSubagentApprovalExecutionScope(childRunId, resumeAttemptId)
 			});
 		}
-		const sourceCheckpoints = await this.getLatestCheckpointSnapshot(baseChildThreadId);
-		if (sourceCheckpoints.length === 0) throw new Error(`Cannot fork subagent checkpoint thread "${baseChildThreadId}" without a checkpoint ID.`);
 		const childRunId = persistedChildRunId ?? currentChildRunId;
 		const identity = {
 			childRunId,
 			childThreadId: branchChildThreadId,
 			approvalExecutionScope: require_SubagentExecutionRegistry.getSubagentApprovalExecutionScope(childRunId, resumeAttemptId)
 		};
+		execution.recordIdentityAttempt(identity);
+		const sourceCheckpoints = await this.getLatestCheckpointSnapshot(baseChildThreadId);
+		if (sourceCheckpoints.length === 0) throw new Error(`Cannot fork subagent checkpoint thread "${baseChildThreadId}" without a checkpoint ID.`);
 		const lease = this.executions.beginIdentityPreparation(execution, identity);
 		await this.prepareCheckpointFork(sourceCheckpoints, branchChildThreadId, lease);
 		return {
@@ -745,7 +780,7 @@ var SubagentExecutor = class SubagentExecutor {
 		if (this.checkpointer == null) return;
 		const executions = [];
 		for (const record of records) {
-			const { identity, binding, activeRun } = record.snapshot;
+			const { identity, binding, invocation, activeRun } = record.snapshot;
 			if (identity == null) continue;
 			const { parentToolCallId } = record.address;
 			const checkpoints = await this.getLatestCheckpointSnapshot(identity.childThreadId);
@@ -766,6 +801,7 @@ var SubagentExecutor = class SubagentExecutor {
 				childRunId: identity.childRunId,
 				...binding?.subagentType == null ? {} : { subagentType: binding.subagentType },
 				...binding?.configId == null ? {} : { configId: binding.configId },
+				...invocation?.hostArgsDigest == null ? {} : { hostArgsDigest: invocation.hostArgsDigest },
 				approvalExecutionScope: identity.approvalExecutionScope,
 				checkpoints,
 				graphState,
@@ -833,7 +869,8 @@ var SubagentExecutor = class SubagentExecutor {
 	}
 	async getSettledToolOutput(call, config) {
 		const parentToolCallId = call.id;
-		if (this.humanInTheLoop?.enabled !== true || this.checkpointer == null || parentToolCallId == null || parentToolCallId === "") return;
+		const checkpointer = this.checkpointer;
+		if (this.humanInTheLoop?.enabled !== true || checkpointer == null || parentToolCallId == null || parentToolCallId === "") return;
 		const parentConfigurable = config.configurable;
 		const threadId = parentConfigurable?.thread_id;
 		const execution = this.executions.open({
@@ -841,6 +878,25 @@ var SubagentExecutor = class SubagentExecutor {
 			parentToolCallId,
 			parentConfigurable
 		});
+		const signal = this.getReplaySignal(config);
+		try {
+			return await this.restoreSettledToolOutput(call, parentConfigurable, parentToolCallId, execution, checkpointer);
+		} catch (error) {
+			if (isSubagentResolutionControlFlow(error)) throw error;
+			const failure = this.createReplayResolutionError(call, config, execution, signal, error);
+			if (signal.aborted) throw failure;
+			return {
+				output: new _langchain_core_messages.ToolMessage({
+					content: failure.message,
+					name: call.name,
+					tool_call_id: parentToolCallId,
+					status: "error"
+				}),
+				additionalContexts: []
+			};
+		}
+	}
+	async restoreSettledToolOutput(call, parentConfigurable, parentToolCallId, execution, checkpointer) {
 		const { resumeExecution } = execution;
 		const inProcessSettledOutput = execution.settledOutput;
 		if (inProcessSettledOutput != null) {
@@ -862,7 +918,7 @@ var SubagentExecutor = class SubagentExecutor {
 		}
 		const { childThreadId } = await this.resolveChildExecutionIdentity(execution);
 		if (marker == null) {
-			messages = getCheckpointMessages((await this.checkpointer.getTuple({ configurable: { thread_id: childThreadId } }))?.checkpoint.channel_values.messages);
+			messages = getCheckpointMessages((await checkpointer.getTuple({ configurable: { thread_id: childThreadId } }))?.checkpoint.channel_values.messages);
 			marker = getSubagentCheckpointMarker(messages, parentToolCallId);
 			persistedSubagentType = getSubagentTypeFromArgs(marker?.settledOutput?.resolvedArgs);
 			if (persistedSubagentType != null) {
@@ -902,6 +958,8 @@ var SubagentExecutor = class SubagentExecutor {
 		const resolvedDescription = getSubagentDescriptionFromArgs(settled.resolvedArgs);
 		const boundInvocation = execution.invocation;
 		if (boundInvocation != null && resolvedDescription != null && resolvedDescription !== boundInvocation.description) return;
+		const resolvedHostArgsDigest = settled.resolvedArgs == null ? void 0 : getHostArgsDigestFromArgs(this.configs.get(resolvedSubagentType ?? execution.binding?.subagentType ?? ""), settled.resolvedArgs);
+		if (boundInvocation != null && settled.resolvedArgs != null && resolvedHostArgsDigest !== boundInvocation.hostArgsDigest) return;
 		const description = boundInvocation?.description ?? resolvedDescription ?? getSubagentDescriptionFromArgs(call.args) ?? "No task description provided";
 		const subagentType = resolvedSubagentType ?? execution.binding?.subagentType ?? getSubagentType(call);
 		const executableConfig = subagentType == null ? void 0 : this.configs.get(subagentType);
@@ -912,10 +970,12 @@ var SubagentExecutor = class SubagentExecutor {
 			return;
 		}
 		const persistedOutput = serializeToolOutput(settled);
+		const hostArgsDigest = settled.resolvedArgs == null ? getHostArgsDigestFromArgs(executableConfig, call.args) : resolvedHostArgsDigest;
 		const invocation = boundInvocation ?? {
 			description,
 			subagentType,
-			...configId == null ? {} : { configId }
+			...configId == null ? {} : { configId },
+			...hostArgsDigest == null ? {} : { hostArgsDigest }
 		};
 		try {
 			await execution.settle({
@@ -925,7 +985,14 @@ var SubagentExecutor = class SubagentExecutor {
 				subagentType,
 				...configId == null ? {} : { configId }
 			}, persistedOutput, async () => {
-				const { childRunId, childThreadId } = await this.resolveChildExecutionIdentity(execution);
+				let identity;
+				try {
+					identity = await this.resolveChildExecutionIdentity(execution);
+				} catch (error) {
+					if (isSubagentResolutionControlFlow(error)) throw error;
+					throw this.createReplayResolutionError(call, config, execution, this.getReplaySignal(config), error);
+				}
+				const { childRunId, childThreadId } = identity;
 				const activeChildRun = execution.activeRun;
 				if (activeChildRun != null) {
 					await this.persistChildCheckpointMarker(activeChildRun, parentToolCallId, persistedOutput);
@@ -964,6 +1031,10 @@ var SubagentExecutor = class SubagentExecutor {
 			const available = [...this.configs.keys()].join(", ");
 			return Promise.resolve(createSubagentFailure(`Error: Unknown subagent type "${params.subagentType}". Available types: ${available}`));
 		}
+		const hostArgResult = require_hostArgs.resolveSubagentHostArgs(executableConfig, params.hostArgs);
+		if (!hostArgResult.ok) return Promise.resolve(createSubagentFailure(hostArgResult.message));
+		const { hostArgs } = hostArgResult;
+		const hostArgsDigest = require_hostArgs.getSubagentHostArgsDigest(hostArgs);
 		if (this.maxDepth <= 0) return Promise.resolve(createSubagentFailure("Error: Maximum subagent nesting depth exceeded."));
 		if (require_childGraphConfig.isGraphSubagentConfig(executableConfig) && this.humanInTheLoop?.enabled === true) return Promise.resolve(createSubagentFailure("Error: Human-in-the-loop execution is not yet supported for graph subagents."));
 		if (this.humanInTheLoop?.enabled === true && (params.parentToolCallId == null || params.parentToolCallId === "")) return Promise.resolve(createSubagentFailure("Error: Resumable subagent execution requires a parent tool call ID."));
@@ -976,14 +1047,61 @@ var SubagentExecutor = class SubagentExecutor {
 			return execution.execute({
 				description: params.description,
 				subagentType: params.subagentType,
-				...executableConfig.configId == null ? {} : { configId: executableConfig.configId }
-			}, () => this.executeOnce(params, execution, executableConfig));
+				...executableConfig.configId == null ? {} : { configId: executableConfig.configId },
+				...hostArgsDigest == null ? {} : { hostArgsDigest }
+			}, () => this.executeOnce({
+				...params,
+				hostArgs
+			}, execution, executableConfig));
 		} catch (error) {
 			if (error instanceof require_SubagentExecutionRegistry.SubagentDefinitionBindingError) return Promise.resolve(createSubagentFailure(SUBAGENT_CONFIG_CHANGED_MESSAGE));
 			if (error instanceof require_SubagentExecutionRegistry.SubagentInvocationBindingError) return Promise.resolve(createSubagentFailure(SUBAGENT_INVOCATION_CHANGED_MESSAGE));
 			throw error;
 		}
 	}
+	getReplaySignal(config) {
+		const scope = config.configurable?.[require_streamLimits.RUN_BREAKER_SCOPE_CONFIG_KEY];
+		return this.composeChildSignal(scope?.controller ?? this.resolveBreakerController(), config.signal);
+	}
+	createReplayResolutionError(call, config, execution, signal, error) {
+		const selectedType = execution.binding?.subagentType ?? execution.resumeExecution?.subagentType ?? getSubagentType(call);
+		const threadId = config.configurable?.thread_id;
+		return new require_diagnostics.SubagentResolutionError("identity", this.createResolutionFailure("identity", {
+			subagentType: selectedType == null ? "unknown" : this.configs.get(selectedType)?.type ?? "unknown",
+			description: "No task description provided",
+			parentToolCallId: call.id,
+			threadId: typeof threadId === "string" ? threadId : void 0
+		}, execution, signal, error).resolutionFailure?.cause ?? "unknown");
+	}
+	createResolutionFailure(phase, params, execution, signal, error) {
+		const identity = execution.identity ?? execution.attemptedIdentity;
+		const resumeExecution = this.humanInTheLoop?.enabled === true && this.checkpointer != null ? execution.resumeExecution : void 0;
+		const detail = require_diagnostics.logSubagentResolutionFailure(phase, params.subagentType, signal, error, {
+			parentRunId: this.parentRunId,
+			parentAgentId: this.parentAgentId,
+			parentToolCallId: params.parentToolCallId,
+			threadId: params.threadId,
+			childRunId: identity?.childRunId ?? resumeExecution?.childRunId ?? execution.address.currentChildRunId,
+			childThreadId: identity?.childThreadId ?? (resumeExecution == null ? execution.address.baseChildThreadId : execution.address.branchChildThreadId),
+			taskId: params.taskRuntime?.taskId
+		}, this.onResolutionFailure, params.hostArgs);
+		const hostArgument = phase === "config" ? require_diagnostics.getSubagentHostArgumentFailure(error, params.hostArgs) : void 0;
+		if (hostArgument != null) return {
+			...createSubagentFailure(require_diagnostics.getSubagentHostArgumentFailureMessage(hostArgument)),
+			resolutionFailure: {
+				phase,
+				cause: detail.cause,
+				hostArgument
+			}
+		};
+		return {
+			...createSubagentFailure(detail.message),
+			resolutionFailure: {
+				phase,
+				cause: detail.cause
+			}
+		};
+	}
 	async executeOnce(params, execution, executableConfig) {
 		const { description, subagentType, threadId, parentToolCallId } = params;
 		const childBreaker = params.breaker ?? this.resolveBreakerController();
@@ -994,14 +1112,17 @@ var SubagentExecutor = class SubagentExecutor {
 			this.executions.remove(execution);
 			return createSubagentFailure(SUBAGENT_CONFIG_CHANGED_MESSAGE);
 		}
+		if (resumeExecution != null && resumeExecution.hostArgsDigest !== require_hostArgs.getSubagentHostArgsDigest(params.hostArgs)) {
+			this.executions.remove(execution);
+			return createSubagentFailure(SUBAGENT_INVOCATION_CHANGED_MESSAGE);
+		}
 		let identity;
 		try {
 			identity = await this.resolveChildExecutionIdentity(execution);
 			execution.assertUsable(childSignal);
 		} catch (error) {
-			if (error instanceof require_streamLimits.StreamLimitExceededError) throw error;
-			require_diagnostics.logSubagentResolutionFailure("identity", executableConfig.type, childSignal, error);
-			return createSubagentFailure(SUBAGENT_RESOLUTION_ERROR_MESSAGE);
+			if (isSubagentResolutionControlFlow(error)) throw error;
+			return this.createResolutionFailure("identity", params, execution, childSignal, error);
 		}
 		const { childRunId, childThreadId, approvalExecutionScope } = identity;
 		if (!this.bindExecutionDefinition(execution, {
@@ -1015,13 +1136,13 @@ var SubagentExecutor = class SubagentExecutor {
 				childSignal,
 				threadId,
 				parentToolCallId,
-				parentConfigurable: params.parentConfigurable
+				parentConfigurable: params.parentConfigurable,
+				hostArgs: params.hostArgs
 			});
 			execution.assertUsable(childSignal);
 		} catch (error) {
-			if (error instanceof require_streamLimits.StreamLimitExceededError) throw error;
-			require_diagnostics.logSubagentResolutionFailure("config", executableConfig.type, childSignal, error);
-			return createSubagentFailure(SUBAGENT_RESOLUTION_ERROR_MESSAGE);
+			if (isSubagentResolutionControlFlow(error)) throw error;
+			return this.createResolutionFailure("config", params, execution, childSignal, error);
 		}
 		const parentRegistry = this.getParentHandlerRegistry();
 		const forwardingEnabled = parentRegistry != null;
@@ -1095,9 +1216,11 @@ var SubagentExecutor = class SubagentExecutor {
 			langfuse: this.langfuse,
 			tokenCounter: this.tokenCounter,
 			streamLimits: this.streamLimits,
+			providerTextProtection: this.providerTextProtection,
 			subagentScope: true,
 			subagentExecutionContext: childExecutionContext,
 			subagentContext: this.subagentContext,
+			onSubagentResolutionFailure: this.onResolutionFailure,
 			...resumeExecution?.graphState.fadingTier == null ? {} : { fadingTier: resumeExecution.graphState.fadingTier },
 			...resumeExecution?.graphState.fadingTiers == null ? {} : { fadingTiers: resumeExecution.graphState.fadingTiers },
 			subagentUsageSink,
@@ -1316,7 +1439,7 @@ var SubagentExecutor = class SubagentExecutor {
 					parent_tool_call_id: parentToolCallId
 				}, resumeManifest));
 			}
-			if (error instanceof require_streamLimits.StreamLimitExceededError) childBreaker.abort(error);
+			if (error instanceof require_streamLimits.StreamLimitExceededError || error instanceof require_providerText.ProviderTextProtectionError) childBreaker.abort(error);
 			const errorMessage = truncateErrorMessage(error);
 			await this.closeChildRunSteps(childGraph, abortedBeforeError ? "cancelled" : "failed", childTerminalAt);
 			if (forwarding) {
@@ -1335,7 +1458,7 @@ var SubagentExecutor = class SubagentExecutor {
 			}
 			this.clearChildGraph(childGraph);
 			execution.markFailed();
-			if (error instanceof require_streamLimits.StreamLimitExceededError) throw error;
+			if (error instanceof require_streamLimits.StreamLimitExceededError || error instanceof require_providerText.ProviderTextProtectionError) throw error;
 			return createSubagentFailure(`Subagent error: ${errorMessage}`, errorMessage);
 		}
 		const childTerminalAt = Date.now();