deepagents 1.14.1 → 1.14.2

package/dist/{langsmith-Bhg_Q4ZO.cjs → langsmith-CjOWZAS2.cjs}

@@ -21,14 +21,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let langchain = require("langchain");
+let _langchain_core_errors = require("@langchain/core/errors");
 let _langchain_langgraph = require("@langchain/langgraph");
 let zod_v4 = require("zod/v4");
 let micromatch = require("micromatch");
 micromatch = __toESM(micromatch, 1);
+let node_crypto = require("node:crypto");
 let _langchain_core_messages = require("@langchain/core/messages");
 let zod = require("zod");
 zod = __toESM(zod, 1);
-let _langchain_core_errors = require("@langchain/core/errors");
 let langchain_chat_models_universal = require("langchain/chat_models/universal");
 let yaml = require("yaml");
 yaml = __toESM(yaml, 1);
@@ -657,9 +658,18 @@ function adaptBackendProtocol(backend) {
 			return result;
 		}
 	};
-	const routePrefixes = backend.routePrefixes;
-	if (Array.isArray(routePrefixes)) Object.defineProperty(adapted, "routePrefixes", {
-		value: routePrefixes,
+	const identityMarkers = [["routePrefixes", Array.isArray], ["backendKind", (value) => typeof value === "string"]];
+	for (const [key, isValid] of identityMarkers) {
+		const value = backend[key];
+		if (isValid(value)) Object.defineProperty(adapted, key, {
+			value,
+			enumerable: true,
+			configurable: true
+		});
+	}
+	const resolveBackendForPath = backend.resolveBackendForPath;
+	if (typeof resolveBackendForPath === "function") Object.defineProperty(adapted, "resolveBackendForPath", {
+		value: (path) => resolveBackendForPath.call(backend, path),
 		enumerable: true,
 		configurable: true
 	});
@@ -810,8 +820,14 @@ const PREGEL_READ_KEY = "__pregel_read";
 * for the middleware to apply via Command.
 */
 var StateBackend = class {
+	/** Class identity discriminant for {@link StateBackend.isInstance}. */
+	backendKind = "state";
 	runtime;
 	fileFormat;
+	/** Duck-typed so this survives the plain-object copies `adaptBackendProtocol` makes — a class check wouldn't. */
+	static isInstance(backend) {
+		return typeof backend === "object" && backend !== null && backend.backendKind === "state";
+	}
 	constructor(runtimeOrOptions, options) {
 		if (runtimeOrOptions != null && typeof runtimeOrOptions === "object" && "state" in runtimeOrOptions) {
 			this.runtime = runtimeOrOptions;
@@ -1111,6 +1127,466 @@ var StateBackend = class {
 	}
 };
 //#endregion
+//#region src/middleware/blobOffload.ts
+/**
+* Content-addressed offload of binary `read_file` and inline `HumanMessage`
+* blocks to the backend.
+*
+* Binary blocks are written to `/blobs/<sha256>` and replaced in state with a
+* `deepagents_blob` reference. Model requests are rehydrated from the backend
+* (or a per-run cache), so checkpoints never carry the base64 payload.
+*/
+/** Content block key holding the SHA-256 digest of an offloaded payload. */
+const BLOB_REF_KEY = "deepagents_blob";
+const MISSING_BLOB_TEXT = "[Binary content from an earlier read_file call is no longer available. Re-read the file if you still need it.]";
+const DIGEST_RE = /^[0-9a-f]{64}$/;
+const BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
+/** Whether `reference` is a well-formed digest string. */
+function isDigest(reference) {
+	return typeof reference === "string" && DIGEST_RE.test(reference);
+}
+function isValidBase64(value) {
+	return value.length > 0 && value.length % 4 === 0 && BASE64_RE.test(value);
+}
+function sha256Hex(bytes) {
+	return (0, node_crypto.createHash)("sha256").update(bytes).digest("hex");
+}
+const DEFAULT_BLOB_CACHE_BYTES = 268435456;
+/**
+* Content-addressed cache of base64 payloads, bounded by total payload size
+* (LRU-evicted past the bound). Safe to share across threads — every key is
+* a SHA-256 digest of its own value, so a hit is only reachable by a caller
+* who already has that exact reference, and an eviction just forces a
+* re-fetch from the backend, never a wrong result.
+*/
+var BlobCache = class extends Map {
+	maxBytes;
+	totalBytes = 0;
+	constructor(maxBytes = DEFAULT_BLOB_CACHE_BYTES) {
+		super();
+		this.maxBytes = maxBytes;
+	}
+	/** Returns the cached payload for `digest`, marking it most recently used. */
+	get(digest) {
+		const payload = super.get(digest);
+		if (payload === void 0) return void 0;
+		super.delete(digest);
+		super.set(digest, payload);
+		return payload;
+	}
+	/** Caches `payload`, evicting least-recently-used entries past the size bound. */
+	set(digest, payload) {
+		if (payload.length > this.maxBytes) return this;
+		const previous = super.get(digest);
+		if (previous !== void 0) {
+			this.totalBytes -= previous.length;
+			super.delete(digest);
+		}
+		super.set(digest, payload);
+		this.totalBytes += payload.length;
+		while (this.totalBytes > this.maxBytes) {
+			const oldestDigest = this.keys().next().value;
+			if (oldestDigest === void 0) break;
+			const oldest = super.get(oldestDigest);
+			super.delete(oldestDigest);
+			this.totalBytes -= oldest?.length ?? 0;
+		}
+		return this;
+	}
+};
+function blobPath(prefix, digest) {
+	return `${prefix}/${digest}`;
+}
+function contentBlocks(message) {
+	const content = message?.content;
+	return Array.isArray(content) ? content : null;
+}
+/** Map each inline base64 payload found in `messages` to its digest and decoded bytes. */
+function pendingBlobs(messages) {
+	const pending = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		const blocks = contentBlocks(message);
+		if (!blocks) continue;
+		for (const block of blocks) {
+			if (block == null || typeof block !== "object") continue;
+			const payload = block.data;
+			if (typeof payload !== "string" || pending.has(payload) || !isValidBase64(payload)) continue;
+			let raw;
+			try {
+				raw = new Uint8Array(Buffer.from(payload, "base64"));
+			} catch {
+				continue;
+			}
+			pending.set(payload, {
+				digest: sha256Hex(raw),
+				raw
+			});
+		}
+	}
+	return pending;
+}
+/** Replace payloads found in `digests` with blob references; returns `messages` unchanged if nothing matched. */
+function stubMessages(messages, digests) {
+	return messages.map((message) => {
+		const blocks = contentBlocks(message);
+		if (!blocks) return message;
+		let changed = false;
+		const newContent = blocks.map((block) => {
+			const digest = typeof block.data === "string" ? digests.get(block.data) : void 0;
+			if (digest === void 0) return block;
+			changed = true;
+			const { data: _data, ...rest } = block;
+			return {
+				...rest,
+				[BLOB_REF_KEY]: digest
+			};
+		});
+		if (!changed) return message;
+		return withContent(message, newContent);
+	});
+}
+/**
+* Upload inline binary payloads found in `messages` and return messages carrying blob
+* references instead. Payloads that fail to upload stay inline — offload is best-effort.
+*/
+async function offloadMessages(messages, backend, prefix, cache) {
+	const pending = pendingBlobs(messages);
+	if (pending.size === 0) return [...messages];
+	if (typeof backend.uploadFiles !== "function") {
+		console.warn("Backend does not support uploadFiles; binary read_file content stays inline");
+		return [...messages];
+	}
+	const entries = [...pending.entries()];
+	let responses;
+	try {
+		responses = await backend.uploadFiles(entries.map(([, { digest, raw }]) => [blobPath(prefix, digest), raw]));
+	} catch (error) {
+		console.warn("Failed to offload binary read_file content; keeping it inline", error);
+		return [...messages];
+	}
+	const digests = /* @__PURE__ */ new Map();
+	entries.forEach(([payload, { digest }], index) => {
+		if (responses[index]?.error == null) {
+			digests.set(payload, digest);
+			cache.set(digest, payload);
+		}
+	});
+	return stubMessages(messages, digests);
+}
+/** Apply `offloadMessages` to a tool result (a `ToolMessage`, or a `Command`-shaped update). */
+async function offloadToolResult(result, backend, prefix, cache) {
+	if (langchain.ToolMessage.isInstance(result)) return (await offloadMessages([result], backend, prefix, cache))[0];
+	const update = result?.update;
+	if (update && Array.isArray(update.messages)) {
+		const messages = await offloadMessages(update.messages, backend, prefix, cache);
+		return new _langchain_langgraph.Command({
+			...result,
+			update: {
+				...update,
+				messages
+			}
+		});
+	}
+	return result;
+}
+/** Return `HumanMessage`s with ids after the last `AIMessage`, preferring a version already queued in `pending`. */
+function humanCandidates({ stateMessages, pending }) {
+	let lastAiIndex = -1;
+	stateMessages.forEach((message, index) => {
+		if (langchain.AIMessage.isInstance(message)) lastAiIndex = index;
+	});
+	const queued = /* @__PURE__ */ new Map();
+	for (const message of pending) {
+		const id = message?.id;
+		if (typeof id === "string") queued.set(id, message);
+	}
+	const candidates = [];
+	for (const message of stateMessages.slice(lastAiIndex + 1)) {
+		if (!langchain.HumanMessage.isInstance(message) || typeof message.id !== "string") continue;
+		candidates.push(queued.get(message.id) ?? message);
+	}
+	return candidates;
+}
+function mergeReplacements({ pending, offloaded, candidates }) {
+	const replaced = offloaded.filter((next, index) => next !== candidates[index]);
+	const replacedIds = new Set(replaced.map((message) => message?.id));
+	return [...pending.filter((message) => !replacedIds.has(message?.id)), ...replaced];
+}
+/** Return `pending` plus stubbed replacements for `HumanMessage`s in state carrying inline media. */
+async function offloadHumanMessages({ stateMessages, pending }, backend, prefix, cache) {
+	const candidates = humanCandidates({
+		stateMessages,
+		pending
+	});
+	if (candidates.length === 0) return [...pending];
+	return mergeReplacements({
+		pending,
+		offloaded: await offloadMessages(candidates, backend, prefix, cache),
+		candidates
+	});
+}
+/** Collect every well-formed `deepagents_blob` digest referenced in `messages`, deduplicated. */
+function referencedDigests(messages) {
+	const digests = /* @__PURE__ */ new Set();
+	for (const message of messages) {
+		const blocks = contentBlocks(message);
+		if (!blocks) continue;
+		for (const block of blocks) {
+			const ref = block?.[BLOB_REF_KEY];
+			if (isDigest(ref)) digests.add(ref);
+		}
+	}
+	return [...digests];
+}
+function cachedPayloads(digests, cache) {
+	const payloads = /* @__PURE__ */ new Map();
+	const missing = [];
+	for (const digest of digests) {
+		const payload = cache.get(digest);
+		if (payload !== void 0) payloads.set(digest, payload);
+		else missing.push(digest);
+	}
+	return {
+		payloads,
+		missing
+	};
+}
+/** Verify each downloaded blob's integrity before trusting it — blobs live on an agent-writable backend. */
+function acceptDownloads(missing, responses, payloads, cache) {
+	missing.forEach((digest, index) => {
+		const response = responses[index];
+		if (!response || response.error != null || response.content == null) return;
+		if (sha256Hex(response.content) !== digest) return;
+		const payload = Buffer.from(response.content).toString("base64");
+		cache.set(digest, payload);
+		payloads.set(digest, payload);
+	});
+}
+function messageHasRefs(message) {
+	const blocks = contentBlocks(message);
+	return blocks != null && blocks.some((block) => block != null && typeof block === "object" && "deepagents_blob" in block);
+}
+function withContent(message, content) {
+	if (langchain.ToolMessage.isInstance(message)) return new langchain.ToolMessage({
+		content,
+		tool_call_id: message.tool_call_id,
+		name: message.name,
+		id: message.id,
+		artifact: message.artifact,
+		status: message.status,
+		additional_kwargs: message.additional_kwargs,
+		response_metadata: message.response_metadata,
+		metadata: message.metadata
+	});
+	if (langchain.HumanMessage.isInstance(message)) return new langchain.HumanMessage({
+		content,
+		id: message.id,
+		additional_kwargs: message.additional_kwargs,
+		response_metadata: message.response_metadata
+	});
+	if (langchain.AIMessage.isInstance(message)) return new langchain.AIMessage({
+		content,
+		id: message.id,
+		tool_calls: message.tool_calls,
+		invalid_tool_calls: message.invalid_tool_calls,
+		usage_metadata: message.usage_metadata,
+		additional_kwargs: message.additional_kwargs,
+		response_metadata: message.response_metadata
+	});
+	if (langchain.SystemMessage.isInstance(message)) return new langchain.SystemMessage({
+		content,
+		id: message.id,
+		additional_kwargs: message.additional_kwargs,
+		response_metadata: message.response_metadata
+	});
+	console.warn(`blobOffload: left a blob reference unresolved on an unsupported message type (${message?.constructor?.name})`);
+	return message;
+}
+/** Restore base64 payloads for blob references; a reference with no matching payload becomes a text notice. */
+function restorePayloads(messages, payloads) {
+	const hydrate = (block) => {
+		const ref = block[BLOB_REF_KEY];
+		if (ref === void 0) return block;
+		const payload = isDigest(ref) ? payloads.get(ref) : void 0;
+		if (payload === void 0) return {
+			type: "text",
+			text: MISSING_BLOB_TEXT
+		};
+		const { [BLOB_REF_KEY]: _ref, ...rest } = block;
+		return {
+			...rest,
+			data: payload
+		};
+	};
+	return messages.map((message) => {
+		if (!messageHasRefs(message)) return message;
+		return withContent(message, (contentBlocks(message) ?? []).map(hydrate));
+	});
+}
+/**
+* Restore base64 payloads for blob references ahead of a model call.
+*
+* Only the returned array is used for the request — callers must not persist
+* the result back into state, or the checkpoint-size benefit of offloading is
+* lost the next time state is saved.
+*/
+async function hydrateMessages(messages, backend, prefix, cache) {
+	if (!messages.some(messageHasRefs)) return [...messages];
+	const { payloads, missing } = cachedPayloads(referencedDigests(messages), cache);
+	if (missing.length > 0) if (typeof backend.downloadFiles !== "function") console.warn("Backend does not support downloadFiles; offloaded read_file content is unavailable");
+	else {
+		let responses = [];
+		try {
+			responses = await backend.downloadFiles(missing.map((digest) => blobPath(prefix, digest)));
+		} catch (error) {
+			console.warn("Failed to load offloaded read_file content", error);
+		}
+		acceptDownloads(missing, responses, payloads, cache);
+	}
+	return restorePayloads(messages, payloads);
+}
+//#endregion
+//#region src/middleware/unsupportedContent.ts
+const PDF_MIME_TYPE = "application/pdf";
+/** Content block types `read_file` may emit that require multimodal model support. */
+const MULTIMODAL_BLOCK_TYPES = /* @__PURE__ */ new Set([
+	"image",
+	"audio",
+	"video",
+	"file"
+]);
+const PROFILE_FIELD_BY_BLOCK_TYPE = {
+	image: "imageInputs",
+	audio: "audioInputs",
+	video: "videoInputs"
+};
+const TOOL_MESSAGE_FIELD_BY_BLOCK_TYPE = { image: "imageToolMessage" };
+function hasInlineData(block) {
+	return block.data != null || block.source_type === "base64";
+}
+function blockMimeType(block) {
+	const mimeType = block.mimeType ?? block.mime_type;
+	return typeof mimeType === "string" ? mimeType : void 0;
+}
+/**
+* Unlike the other block types, a missing `fileMimeTypes` defaults to
+* unsupported rather than supported: generic file support varies far more
+* across models than image/audio/video, so there's no safe assumption to
+* fall back on absent real profile data.
+*/
+function fileBlockSupported(block, profile, inToolMessage) {
+	if (!hasInlineData(block)) return true;
+	const mimeType = blockMimeType(block);
+	if (mimeType === PDF_MIME_TYPE) {
+		if (inToolMessage && profile.pdfToolMessage !== void 0) return profile.pdfToolMessage !== false;
+		return profile.pdfInputs !== false;
+	}
+	if (mimeType == null) return false;
+	const { fileMimeTypes } = profile;
+	return Array.isArray(fileMimeTypes) && fileMimeTypes.includes(mimeType);
+}
+/**
+* Whether the model accepts a multimodal block.
+*
+* Missing profile fields default to supported, since profile coverage is
+* incomplete — except `file` blocks, where a missing `fileMimeTypes`
+* defaults to unsupported (see `fileBlockSupported`).
+*/
+function multimodalBlockSupported(block, profile, inToolMessage) {
+	if (block.type === "file") return fileBlockSupported(block, profile, inToolMessage);
+	const field = PROFILE_FIELD_BY_BLOCK_TYPE[block.type];
+	if (field == null) return true;
+	if (inToolMessage) {
+		const toolField = TOOL_MESSAGE_FIELD_BY_BLOCK_TYPE[block.type];
+		if (toolField != null && profile[toolField] !== void 0) return profile[toolField] !== false;
+	}
+	return profile[field] !== false;
+}
+function placeholder(block, path) {
+	return {
+		type: "text",
+		text: `[read_file: ${path ?? "the requested file"} was not attached because this model does not support ${block.type} content (${blockMimeType(block) ?? "unknown"}).]`
+	};
+}
+function readFilePaths(messages) {
+	const paths = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (!_langchain_core_messages.AIMessage.isInstance(message)) continue;
+		for (const toolCall of message.tool_calls ?? []) {
+			const path = toolCall.args?.file_path;
+			if (toolCall.id != null && typeof path === "string") paths.set(toolCall.id, path);
+		}
+	}
+	return paths;
+}
+/**
+* Without this, a request carrying content the model can't accept (e.g. a
+* `.zip` file sent to a model without file support) fails with a
+* non-retryable 400, and since the content stays in history, every later
+* turn fails the same way. Only the request is changed; messages in state
+* are left untouched, so switching to a model that accepts the content
+* sends it again.
+*/
+function scrubUnsupportedMultimodalContent(messages, model) {
+	const rawProfile = model?.profile;
+	const profile = rawProfile != null && typeof rawProfile === "object" ? rawProfile : {};
+	let paths;
+	let changed = false;
+	const result = messages.map((message) => {
+		const isTool = _langchain_core_messages.ToolMessage.isInstance(message);
+		if (!isTool && !_langchain_core_messages.HumanMessage.isInstance(message)) return message;
+		let messageChanged = false;
+		const content = message.contentBlocks.map((block) => {
+			if (block == null || typeof block !== "object" || !MULTIMODAL_BLOCK_TYPES.has(block.type) || multimodalBlockSupported(block, profile, isTool)) return block;
+			messageChanged = true;
+			paths ??= readFilePaths(messages);
+			return placeholder(block, isTool ? paths.get(message.tool_call_id) : void 0);
+		});
+		if (!messageChanged) return message;
+		changed = true;
+		if (isTool) return new _langchain_core_messages.ToolMessage({
+			content,
+			tool_call_id: message.tool_call_id,
+			name: message.name,
+			id: message.id,
+			artifact: message.artifact,
+			status: message.status,
+			metadata: message.metadata,
+			additional_kwargs: message.additional_kwargs,
+			response_metadata: message.response_metadata
+		});
+		return new _langchain_core_messages.HumanMessage({
+			content,
+			name: message.name,
+			id: message.id,
+			additional_kwargs: message.additional_kwargs,
+			response_metadata: message.response_metadata
+		});
+	});
+	return changed ? result : messages;
+}
+/**
+* Support is read from `model.profile` (see
+* https://docs.langchain.com/oss/javascript/langchain/models#model-profiles).
+*
+* Place this middleware last in the agent's `middleware` list, so that if
+* some other middleware changes `request.model`, this one sees the model
+* that will actually receive the request.
+*/
+function createUnsupportedContentMiddleware() {
+	return (0, langchain.createMiddleware)({
+		name: "UnsupportedContentMiddleware",
+		wrapModelCall: async (request, handler) => {
+			const messages = scrubUnsupportedMultimodalContent(request.messages, request.model);
+			if (messages === request.messages) return handler(request);
+			return handler({
+				...request,
+				messages
+			});
+		}
+	});
+}
+//#endregion
 //#region src/permissions/enforce.ts
 /**
 * Validate permission rule paths at setup time. Throws if any path is
@@ -1201,6 +1677,10 @@ var CompositeBackend = class {
 	static isInstance(backend) {
 		return typeof backend === "object" && backend !== null && Array.isArray(backend.routePrefixes);
 	}
+	/** Returns the backend for `path`, with the matched prefix stripped from the returned path. */
+	resolveBackendForPath(path) {
+		return this.getBackendAndKey(path);
+	}
 	/**
 	* Determine which backend handles this key and strip prefix.
 	*
@@ -1805,6 +2285,8 @@ const GREP_TRUNCATION_NOTE = "Note: the search stopped early because it hit the
 * Set to null to disable the cap.
 */
 const DEFAULT_GREP_MAX_COUNT = 1e3;
+/** Path prefix offloaded binary content blobs are written under. */
+const BLOBS_PREFIX = "/blobs";
 /**
 * Message template for evicted tool results.
 */
@@ -2587,6 +3069,68 @@ function allPathsScopedToRoutes(permissions, backend) {
 		return path === normalizedRoute.slice(0, -1) || path.startsWith(normalizedRoute);
 	})));
 }
+/** Whether `path` resolves to a `StateBackend`, recursing through composite routing. */
+function routesToStateBackend(backend, path) {
+	if (CompositeBackend.isInstance(backend)) {
+		const [routed, routedPath] = backend.resolveBackendForPath(path);
+		return routesToStateBackend(routed, routedPath);
+	}
+	return StateBackend.isInstance(backend);
+}
+/**
+* Whether `response` is the `{ structuredResponse, messages }` shape a
+* provider-strategy structured-output call can return instead of a plain
+* `AIMessage`. The agent framework only recognizes this shape at the
+* outermost `wrapModelCall` return value — returning a `Command` instead
+* discards `structuredResponse` with no way to carry it through the Command.
+*/
+function hasStructuredResponse(response) {
+	return typeof response === "object" && response !== null && "structuredResponse" in response && "messages" in response;
+}
+const REJECTED_FILE_CONTENT_TEXT = "Unsupported content. The file may be invalid, too large, or of an unsupported mime-type.";
+/**
+* No LangChain error class captures "the provider rejected this request"
+* generically, so this checks the raw HTTP status providers' client SDKs set
+* on their errors instead. `ContextOverflowError` is excluded because it's a
+* different, already-handled problem, and retrying it with stripped file
+* content wouldn't fix an oversized prompt.
+*/
+function isRejectedRequestError(error) {
+	if (_langchain_core_errors.ContextOverflowError.isInstance(error)) return false;
+	return typeof error === "object" && error !== null && "status" in error && error.status === 400;
+}
+/**
+* Only messages carrying multimodal blocks after the last `AIMessage` are
+* candidates for replacement, since anything earlier was already accepted by
+* the model in a prior turn. Returns `messages` unchanged if nothing
+* matched, so the caller can tell there was nothing to blame for the
+* rejection.
+*/
+function replaceRejectedFileContent(messages) {
+	let lastResponseIndex = -1;
+	for (let i = messages.length - 1; i >= 0; i--) if (langchain.AIMessage.isInstance(messages[i])) {
+		lastResponseIndex = i;
+		break;
+	}
+	let changed = false;
+	const result = messages.map((message, index) => {
+		if (index <= lastResponseIndex || !langchain.ToolMessage.isInstance(message) || message.name !== "read_file") return message;
+		if (!message.contentBlocks.some((block) => MULTIMODAL_BLOCK_TYPES.has(block.type))) return message;
+		changed = true;
+		return new langchain.ToolMessage({
+			content: REJECTED_FILE_CONTENT_TEXT,
+			tool_call_id: message.tool_call_id,
+			name: message.name,
+			id: message.id,
+			artifact: message.artifact,
+			status: message.status,
+			metadata: message.metadata,
+			additional_kwargs: message.additional_kwargs,
+			response_metadata: message.response_metadata
+		});
+	});
+	return changed ? result : messages;
+}
 /**
 * Create middleware that provides built-in filesystem tools and optional custom
 * prompt guidance.
@@ -2613,7 +3157,10 @@ function allPathsScopedToRoutes(permissions, backend) {
 * ```
 */
 function createFilesystemMiddleware(options = {}) {
-	const { backend = (runtime) => new StateBackend(runtime), systemPrompt: customSystemPrompt = null, customToolDescriptions = null, toolTokenLimitBeforeEvict = 2e4, humanMessageTokenLimitBeforeEvict = 5e4, permissions = [], tools: filesystemTools = null, grepMaxCount = DEFAULT_GREP_MAX_COUNT } = options;
+	const { backend = (runtime) => new StateBackend(runtime), systemPrompt: customSystemPrompt = null, customToolDescriptions = null, toolTokenLimitBeforeEvict = 2e4, humanMessageTokenLimitBeforeEvict = 5e4, permissions = [], tools: filesystemTools = null, grepMaxCount = DEFAULT_GREP_MAX_COUNT, offloadBinaryContent = false } = options;
+	const backendIsStateBackend = StateBackend.isInstance(backend);
+	if (offloadBinaryContent && backendIsStateBackend) console.warn("offloadBinaryContent has no effect: the backend is a StateBackend, which keeps files as part of checkpointed state.");
+	const blobCache = offloadBinaryContent && !backendIsStateBackend ? new BlobCache() : null;
 	const enabledFilesystemTools = normalizeFilesystemTools(filesystemTools);
 	const executeToolEnabled = enabledFilesystemTools == null || enabledFilesystemTools.has("execute");
 	if (permissions.length > 0) validatePermissionPaths(permissions);
@@ -2750,18 +3297,59 @@ function createFilesystemMiddleware(options = {}) {
 					return msg;
 				});
 			}
-			return handler({
+			let offloadedHuman = [];
+			if (blobCache && !routesToStateBackend(resolvedBackend, `${BLOBS_PREFIX}/`)) {
+				offloadedHuman = await offloadHumanMessages({
+					stateMessages: request.state.messages ?? [],
+					pending: []
+				}, resolvedBackend, BLOBS_PREFIX, blobCache);
+				messages = await hydrateMessages(messages, resolvedBackend, BLOBS_PREFIX, blobCache);
+			}
+			const finalRequest = {
 				...request,
 				tools,
 				messages,
 				systemMessage: newSystemMessage
-			});
+			};
+			const foldOffload = (response, extra = []) => {
+				if (offloadedHuman.length === 0 && extra.length === 0) return response;
+				if (hasStructuredResponse(response)) return {
+					...response,
+					messages: [
+						...extra,
+						...offloadedHuman,
+						...response.messages
+					]
+				};
+				return new _langchain_langgraph.Command({ update: { messages: extra.length === 0 ? offloadedHuman : [
+					...extra,
+					...offloadedHuman,
+					response
+				] } });
+			};
+			try {
+				return foldOffload(await handler(finalRequest));
+			} catch (error) {
+				if (!isRejectedRequestError(error)) throw error;
+				const replaced = replaceRejectedFileContent(finalRequest.messages);
+				if (replaced === finalRequest.messages) throw error;
+				return foldOffload(await handler({
+					...finalRequest,
+					messages: replaced
+				}), replaced.filter((msg, i) => msg !== finalRequest.messages[i]));
+			}
 		},
 		wrapToolCall: async (request, handler) => {
-			if (!toolTokenLimitBeforeEvict) return handler(request);
 			const toolName = request.toolCall?.name;
-			if (toolName && TOOLS_EXCLUDED_FROM_EVICTION.includes(toolName)) return handler(request);
-			const result = await handler(request);
+			let result = await handler(request);
+			if (blobCache && toolName === "read_file") {
+				const resolvedBackend = await resolveBackend(backend, {
+					...request.runtime,
+					state: request.state
+				});
+				if (!routesToStateBackend(resolvedBackend, `${BLOBS_PREFIX}/`)) result = await offloadToolResult(result, resolvedBackend, BLOBS_PREFIX, /* @__PURE__ */ new Map());
+			}
+			if (!toolTokenLimitBeforeEvict || toolName && TOOLS_EXCLUDED_FROM_EVICTION.includes(toolName)) return result;
 			if (langchain.ToolMessage.isInstance(result)) {
 				const processed = await processToolMessage(result, request.runtime, request.state, request.toolCall?.id);
 				if (processed.filesUpdate) return new _langchain_langgraph.Command({ update: {
@@ -3805,6 +4393,7 @@ function createSubAgent(spec, options) {
 	if (!spec.tools) throw new Error(`SubAgent '${spec.name}' must specify 'tools'`);
 	const middleware = [...spec.middleware ?? []];
 	if (spec.interruptOn) middleware.push((0, langchain.humanInTheLoopMiddleware)({ interruptOn: spec.interruptOn }));
+	if (!middleware.some((m) => m.name === "UnsupportedContentMiddleware")) middleware.push(createUnsupportedContentMiddleware());
 	const selectedResponseFormat = options?.responseFormat ?? spec.responseFormat;
 	return (0, langchain.createAgent)({
 		model: spec.model,
@@ -6724,6 +7313,7 @@ function createDeepAgent(params = {}) {
 		]);
 		if (subagentProfile.excludedMiddleware.size > 0) subagentMiddleware = subagentMiddleware.filter((middleware) => !subagentProfile.excludedMiddleware.has(middleware.name));
 		if (subagentProfile.excludedTools.size > 0) subagentMiddleware.push(createToolExclusionMiddleware(subagentProfile.excludedTools));
+		if (!subagentProfile.excludedMiddleware.has("UnsupportedContentMiddleware") && !subagentMiddleware.some((middleware) => middleware.name === "UnsupportedContentMiddleware")) subagentMiddleware.push(createUnsupportedContentMiddleware());
 		return subagentMiddleware;
 	};
 	const normalizeSubagentSpec = (input) => ({
@@ -6786,6 +7376,7 @@ function createDeepAgent(params = {}) {
 		middleware = middleware.filter((entry) => !excluded.has(entry.name));
 	}
 	if (harnessProfile.excludedTools.size > 0) middleware.push(createToolExclusionMiddleware(harnessProfile.excludedTools));
+	if (!harnessProfile.excludedMiddleware.has("UnsupportedContentMiddleware") && !middleware.some((m) => m.name === "UnsupportedContentMiddleware")) middleware.push(createUnsupportedContentMiddleware());
 	/**
 	* Return as DeepAgent with proper DeepAgentTypeConfig
 	* - Response: InferStructuredResponse<TResponse> (unwraps ToolStrategy<T>/ProviderStrategy<T> → T)
@@ -8993,6 +9584,12 @@ Object.defineProperty(exports, "MAX_SKILL_NAME_LENGTH", {
 		return MAX_SKILL_NAME_LENGTH;
 	}
 });
+Object.defineProperty(exports, "MULTIMODAL_BLOCK_TYPES", {
+	enumerable: true,
+	get: function() {
+		return MULTIMODAL_BLOCK_TYPES;
+	}
+});
 Object.defineProperty(exports, "REQUIRED_MIDDLEWARE_NAMES", {
 	enumerable: true,
 	get: function() {
@@ -9131,6 +9728,12 @@ Object.defineProperty(exports, "createSummarizationMiddleware", {
 		return createSummarizationMiddleware;
 	}
 });
+Object.defineProperty(exports, "createUnsupportedContentMiddleware", {
+	enumerable: true,
+	get: function() {
+		return createUnsupportedContentMiddleware;
+	}
+});
 Object.defineProperty(exports, "filesValue", {
 	enumerable: true,
 	get: function() {
@@ -9185,6 +9788,12 @@ Object.defineProperty(exports, "isTextMimeType", {
 		return isTextMimeType;
 	}
 });
+Object.defineProperty(exports, "multimodalBlockSupported", {
+	enumerable: true,
+	get: function() {
+		return multimodalBlockSupported;
+	}
+});
 Object.defineProperty(exports, "normalizeReadPagination", {
 	enumerable: true,
 	get: function() {
@@ -9215,6 +9824,12 @@ Object.defineProperty(exports, "resolveBackend", {
 		return resolveBackend;
 	}
 });
+Object.defineProperty(exports, "scrubUnsupportedMultimodalContent", {
+	enumerable: true,
+	get: function() {
+		return scrubUnsupportedMultimodalContent;
+	}
+});
 Object.defineProperty(exports, "serializeProfile", {
 	enumerable: true,
 	get: function() {
@@ -9228,4 +9843,4 @@ Object.defineProperty(exports, "skillsMetadataValue", {
 	}
 });
 
-//# sourceMappingURL=langsmith-Bhg_Q4ZO.cjs.map
+//# sourceMappingURL=langsmith-CjOWZAS2.cjs.map