deepagents 1.14.1 → 1.14.2

package/dist/{langsmith-Bgi_Ta-k.js → langsmith--RbtjNdQ.js}

@@ -1,11 +1,12 @@
 import { AIMessage, HumanMessage, SystemMessage, ToolMessage, anthropicPromptCachingMiddleware, bedrockPromptCachingMiddleware, context, countTokensApproximately, createAgent, createMiddleware, humanInTheLoopMiddleware, todoListMiddleware, tool } from "langchain";
+import { ContextOverflowError } from "@langchain/core/errors";
 import { Command, REMOVE_ALL_MESSAGES, ReducedValue, StateSchema, getConfig, getCurrentTaskInput, getStore, isCommand } from "@langchain/langgraph";
 import { z } from "zod/v4";
 import micromatch from "micromatch";
+import { createHash } from "node:crypto";
 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";
 import { initChatModel } from "langchain/chat_models/universal";
 import yaml from "yaml";
 import { Client } from "@langchain/langgraph-sdk";
@@ -633,9 +634,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
 	});
@@ -786,8 +796,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;
@@ -1087,6 +1103,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 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 (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 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 (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 (!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 (ToolMessage.isInstance(message)) return new 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 (HumanMessage.isInstance(message)) return new HumanMessage({
+		content,
+		id: message.id,
+		additional_kwargs: message.additional_kwargs,
+		response_metadata: message.response_metadata
+	});
+	if (AIMessage.isInstance(message)) return new 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 (SystemMessage.isInstance(message)) return new 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 (!AIMessage$1.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 = ToolMessage$1.isInstance(message);
+		if (!isTool && !HumanMessage$1.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 ToolMessage$1({
+			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 HumanMessage$1({
+			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 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
@@ -1177,6 +1653,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.
 	*
@@ -1781,6 +2261,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.
 */
@@ -2563,6 +3045,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 (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 (AIMessage.isInstance(messages[i])) {
+		lastResponseIndex = i;
+		break;
+	}
+	let changed = false;
+	const result = messages.map((message, index) => {
+		if (index <= lastResponseIndex || !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 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.
@@ -2589,7 +3133,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);
@@ -2726,18 +3273,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 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 (ToolMessage.isInstance(result)) {
 				const processed = await processToolMessage(result, request.runtime, request.state, request.toolCall?.id);
 				if (processed.filesUpdate) return new Command({ update: {
@@ -3781,6 +4369,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(humanInTheLoopMiddleware({ interruptOn: spec.interruptOn }));
+	if (!middleware.some((m) => m.name === "UnsupportedContentMiddleware")) middleware.push(createUnsupportedContentMiddleware());
 	const selectedResponseFormat = options?.responseFormat ?? spec.responseFormat;
 	return createAgent({
 		model: spec.model,
@@ -6700,6 +7289,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) => ({
@@ -6762,6 +7352,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)
@@ -8879,6 +9470,6 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 	}
 };
 //#endregion
-export { performStringReplacement as $, createPatchToolCallsMiddleware as A, CompositeBackend as B, MAX_SKILL_DESCRIPTION_LENGTH as C, skillsMetadataValue as D, createSkillsMiddleware as E, createSubAgent as F, isSandboxProtocol as G, SandboxError as H, createSubAgentMiddleware as I, adaptSandboxProtocol as J, resolveBackend as K, computeSummarizationDefaults as L, DEFAULT_SUBAGENT_PROMPT as M, GENERAL_PURPOSE_SUBAGENT as N, createMemoryMiddleware as O, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as P, normalizeReadPagination as Q, createSummarizationMiddleware as R, createCompletionCallbackMiddleware as S, MAX_SKILL_NAME_LENGTH as T, applyGrepMaxCount as U, StateBackend as V, isSandboxBackend as W, getMimeType as X, checkEmptyContent as Y, isTextMimeType 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_GENERAL_PURPOSE_DESCRIPTION as j, filesValue as k, createDeepAgent as l, parseHarnessProfileConfig as m, BaseSandbox as n, BASE_AGENT_PROMPT as o, harnessProfileConfigSchema as p, adaptBackendProtocol 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, createFilesystemMiddleware as z };
+export { checkEmptyContent as $, createPatchToolCallsMiddleware as A, CompositeBackend as B, MAX_SKILL_DESCRIPTION_LENGTH as C, skillsMetadataValue as D, createSkillsMiddleware as E, createSubAgent as F, StateBackend as G, createUnsupportedContentMiddleware as H, createSubAgentMiddleware as I, isSandboxBackend as J, SandboxError as K, computeSummarizationDefaults as L, DEFAULT_SUBAGENT_PROMPT as M, GENERAL_PURPOSE_SUBAGENT as N, createMemoryMiddleware as O, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as P, adaptSandboxProtocol as Q, createSummarizationMiddleware as R, createCompletionCallbackMiddleware as S, MAX_SKILL_NAME_LENGTH as T, multimodalBlockSupported as U, MULTIMODAL_BLOCK_TYPES as V, scrubUnsupportedMultimodalContent as W, resolveBackend as X, isSandboxProtocol as Y, adaptBackendProtocol as Z, createHarnessProfile as _, ASYNC_TASK_SYSTEM_PROMPT as a, createAsyncSubAgentMiddleware as b, TASK_SYSTEM_PROMPT as c, registerHarnessProfile as d, getMimeType as et, generalPurposeSubagentConfigSchema as f, EMPTY_HARNESS_PROFILE as g, serializeProfile as h, StoreBackend as i, DEFAULT_GENERAL_PURPOSE_DESCRIPTION as j, filesValue as k, createDeepAgent as l, parseHarnessProfileConfig as m, BaseSandbox as n, normalizeReadPagination as nt, BASE_AGENT_PROMPT as o, harnessProfileConfigSchema as p, applyGrepMaxCount as q, ContextHubBackend as r, performStringReplacement as rt, EXECUTION_SYSTEM_PROMPT as s, LangSmithSandbox as t, isTextMimeType as tt, getHarnessProfile as u, REQUIRED_MIDDLEWARE_NAMES as v, MAX_SKILL_FILE_SIZE as w, isAsyncSubAgent as x, ConfigurationError as y, createFilesystemMiddleware as z };
 
-//# sourceMappingURL=langsmith-Bgi_Ta-k.js.map
+//# sourceMappingURL=langsmith--RbtjNdQ.js.map