deepagents 1.13.1 → 1.13.3

package/dist/{langsmith-Ck9t7AGW.cjs → langsmith-Ynj9VKxb.cjs}

@@ -47,6 +47,22 @@ const EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty conten
 const MAX_LINE_LENGTH = 5e3;
 const TOOL_RESULT_TOKEN_LIMIT = 2e4;
 const TRUNCATION_GUIDANCE = "... [results truncated, try being more specific with your parameters]";
+/**
+* Normalize model- or caller-supplied text pagination bounds.
+*
+* Every backend must slice content and calculate pagination metadata from the
+* same normalized values. Otherwise a fractional or negative argument could
+* return one window while advertising a different `nextOffset`.
+*
+* Binary reads do not use this helper because their backend contract ignores
+* line-based offset and limit values.
+*/
+function normalizeReadPagination(offset, limit) {
+	return {
+		offset: Number.isFinite(offset) ? Math.max(0, Math.floor(offset)) : 0,
+		limit: Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0
+	};
+}
 const MIME_TYPES = {
 	".png": "image/png",
 	".jpg": "image/jpeg",
@@ -158,40 +174,60 @@ function sanitizeToolCallId(toolCallId) {
 	return toolCallId.replace(/\./g, "_").replace(/\//g, "_").replace(/\\/g, "_");
 }
 /**
-* Format file content with line numbers (cat -n style).
-*
-* Chunks lines longer than MAX_LINE_LENGTH with continuation markers (e.g., 5.1, 5.2).
+* Format file content with line numbers and structured source-line boundaries.
 *
-* @param content - File content as string or list of lines
-* @param startLine - Starting line number (default: 1)
-* @returns Formatted content with line numbers and continuation markers
+* The boundaries let downstream size limiting truncate only after complete
+* source lines without reparsing the rendered gutter. This keeps presentation
+* details (padding, tab separators, and continuation labels) encapsulated in
+* the formatter that creates them.
 */
-function formatContentWithLineNumbers(content, startLine = 1) {
+function formatContentWithLineNumbersAndBoundaries(content, startLine = 1) {
 	let lines;
 	if (typeof content === "string") {
 		lines = content.split("\n");
 		if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
 	} else lines = content;
 	const resultLines = [];
+	const sourceLineBoundaries = [];
+	let renderedLength = 0;
+	const appendRow = (row, sourceLine, completesSourceLine) => {
+		if (resultLines.length > 0) renderedLength += 1;
+		resultLines.push(row);
+		renderedLength += row.length;
+		if (completesSourceLine) sourceLineBoundaries.push({
+			sourceLine,
+			endOffset: renderedLength
+		});
+	};
 	for (let i = 0; i < lines.length; i++) {
 		const line = lines[i];
 		const lineNum = i + startLine;
-		if (line.length <= 5e3) resultLines.push(`${lineNum.toString().padStart(6)}\t${line}`);
-		else {
-			const numChunks = Math.ceil(line.length / MAX_LINE_LENGTH);
-			for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
-				const start = chunkIdx * MAX_LINE_LENGTH;
-				const end = Math.min(start + MAX_LINE_LENGTH, line.length);
-				const chunk = line.substring(start, end);
-				if (chunkIdx === 0) resultLines.push(`${lineNum.toString().padStart(6)}\t${chunk}`);
-				else {
-					const continuationMarker = `${lineNum}.${chunkIdx}`;
-					resultLines.push(`${continuationMarker.padStart(6)}\t${chunk}`);
-				}
-			}
+		if (line.length <= 5e3) {
+			appendRow(`${lineNum.toString().padStart(6)}\t${line}`, lineNum, true);
+			continue;
+		}
+		const numChunks = Math.ceil(line.length / MAX_LINE_LENGTH);
+		for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+			const start = chunkIdx * MAX_LINE_LENGTH;
+			const end = Math.min(start + MAX_LINE_LENGTH, line.length);
+			const chunk = line.substring(start, end);
+			appendRow(`${(chunkIdx === 0 ? `${lineNum}` : `${lineNum}.${chunkIdx}`).padStart(6)}\t${chunk}`, lineNum, chunkIdx === numChunks - 1);
 		}
 	}
-	return resultLines.join("\n");
+	return {
+		text: resultLines.join("\n"),
+		sourceLineBoundaries
+	};
+}
+/**
+* Format file content with line numbers (cat -n style).
+*
+* Lines longer than `MAX_LINE_LENGTH` are split into continuation rows such as
+* `5.1` and `5.2`. Use `formatContentWithLineNumbersAndBoundaries` when a
+* caller also needs safe source-line truncation points.
+*/
+function formatContentWithLineNumbers(content, startLine = 1) {
+	return formatContentWithLineNumbersAndBoundaries(content, startLine).text;
 }
 /**
 * Check if content is empty and return warning message.
@@ -865,10 +901,23 @@ var StateBackend = class {
 			mimeType: fileDataV2.mimeType
 		};
 		if (typeof fileDataV2.content !== "string") return { error: `File '${filePath}' has binary content but text MIME type` };
-		return {
-			content: fileDataV2.content.split("\n").slice(offset, offset + limit).join("\n"),
+		const { offset: normalizedOffset, limit: normalizedLimit } = normalizeReadPagination(offset, limit);
+		const lines = fileDataV2.content.split("\n");
+		const totalLines = lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+		const selected = lines.slice(normalizedOffset, normalizedOffset + normalizedLimit);
+		if (selected.length === 0 || normalizedOffset >= totalLines || normalizedLimit === 0) return {
+			content: selected.join("\n"),
 			mimeType: fileDataV2.mimeType
 		};
+		const endOffset = Math.min(normalizedOffset + selected.length, totalLines);
+		return {
+			content: selected.join("\n"),
+			mimeType: fileDataV2.mimeType,
+			totalLines,
+			startLine: normalizedOffset + 1,
+			endLine: endOffset,
+			nextOffset: endOffset < totalLines ? endOffset : void 0
+		};
 	}
 	/**
 	* Read file content as raw FileData.
@@ -1584,6 +1633,73 @@ const READ_FILE_TRUNCATION_MSG = `
 
 [Output was truncated due to size limits. The file content is very large. Consider reformatting the file to make it easier to navigate. For example, if this is JSON, use execute(command='jq . {file_path}') to pretty-print it with line breaks. For other formats, you can use appropriate formatting tools to split long lines.]`;
 /**
+* Render backend pagination metadata as guidance for the model.
+*
+* Backends own source-level pagination because only they know how much of the
+* file was read. The middleware owns presentation: it line-numbers the text
+* and turns optional metadata into a human-readable footer. Keeping the fields
+* optional preserves compatibility with custom backends that predate this
+* contract; those reads simply receive no pagination footer.
+*
+* `nextOffset` is the signal that the read is partial. A result at EOF omits it,
+* so complete reads retain their previous output shape.
+*/
+function remainingLinesNotice(readResult) {
+	const { startLine, endLine, nextOffset, totalLines } = readResult;
+	if (startLine === void 0 || endLine === void 0 || nextOffset === void 0 || !Number.isSafeInteger(startLine) || !Number.isSafeInteger(endLine) || !Number.isSafeInteger(nextOffset) || startLine < 1 || endLine < startLine || nextOffset !== endLine || totalLines !== void 0 && (!Number.isSafeInteger(totalLines) || totalLines < endLine)) return "";
+	const readCount = endLine - startLine + 1;
+	const readUnit = readCount === 1 ? "line" : "lines";
+	if (totalLines === void 0) return `\n\n[Read ${readCount} ${readUnit} (lines ${startLine}-${endLine}). More lines remain from offset ${nextOffset}.]`;
+	if (endLine >= totalLines) return "";
+	const remaining = totalLines - endLine;
+	return `\n\n[Read ${readCount} ${readUnit} (lines ${startLine}-${endLine} of ${totalLines} total). ${remaining} ${remaining === 1 ? "line" : "lines"} remaining from offset ${nextOffset}.]`;
+}
+/**
+* Fit a line-numbered read into the middleware's output budget without
+* publishing a resume offset that skips content the model did not see.
+*
+* There are two independent forms of limiting:
+*
+* 1. The backend paginates the source file with `offset` and `limit`.
+* 2. The middleware may further shorten that page to fit its token budget.
+*
+* If the backend returned lines 1-100 but the middleware only displayed lines
+* 1-30, forwarding the backend's original `nextOffset: 100` would silently skip
+* lines 31-100 on the next read. This function therefore truncates only after a
+* complete source line and rebuilds the remaining-lines notice using the last
+* line actually displayed.
+*
+* Long source lines may occupy several formatted rows (`12`, `12.1`, ...). The
+* formatter records a structured boundary only after the final chunk, so this
+* function does not need to inspect or understand the gutter representation.
+* If no complete source line can fit beside the truncation message, the function
+* falls back to character truncation and omits pagination guidance rather than
+* advertising an unsafe offset.
+*/
+function truncatePaginatedRead(formatted, filePath, readResult, tokenLimit) {
+	const content = formatted.text;
+	const notice = remainingLinesNotice(readResult);
+	if (!tokenLimit || content.length + notice.length < 4 * tokenLimit) return content + notice;
+	const truncationMsg = READ_FILE_TRUNCATION_MSG.replace("{file_path}", filePath);
+	const threshold = 4 * tokenLimit;
+	if (readResult.startLine !== void 0 && readResult.endLine !== void 0) {
+		const finalSourceLine = readResult.endLine;
+		const boundaries = formatted.sourceLineBoundaries.filter((boundary) => boundary.sourceLine <= finalSourceLine);
+		for (let index = boundaries.length - 1; index >= 0; index -= 1) {
+			const boundary = boundaries[index];
+			const adjustedNotice = remainingLinesNotice({
+				totalLines: readResult.totalLines,
+				startLine: readResult.startLine,
+				endLine: boundary.sourceLine,
+				nextOffset: boundary.sourceLine
+			});
+			if (boundary.endOffset + truncationMsg.length + adjustedNotice.length <= threshold) return content.slice(0, boundary.endOffset) + truncationMsg + adjustedNotice;
+		}
+	}
+	const maxContentLength = Math.max(0, threshold - truncationMsg.length);
+	return content.substring(0, maxContentLength) + truncationMsg;
+}
+/**
 * Note appended to grep results that were cut short by the match-count cap.
 */
 const GREP_TRUNCATION_NOTE = "Note: the search stopped early because it hit the maximum match count. The matches above are valid but incomplete. Narrow the search (a more specific pattern or a narrower path), or raise max_count, to see the rest.";
@@ -2085,7 +2201,8 @@ function createReadFileTool(backend, options) {
 		const permissionError = checkPermission(permissions, "read", input.file_path);
 		if (permissionError !== void 0) return toolError(runtime, "read_file", permissionError);
 		const resolvedBackend = await resolveBackend(backend, runtime);
-		const { file_path, offset = 0, limit = 100 } = input;
+		const { file_path, offset: requestedOffset = 0, limit: requestedLimit = 100 } = input;
+		const { offset, limit } = normalizeReadPagination(requestedOffset, requestedLimit);
 		const readResult = await resolvedBackend.read(file_path, offset, limit);
 		if (readResult.error) return [{
 			type: "text",
@@ -2133,16 +2250,21 @@ function createReadFileTool(backend, options) {
 		}
 		let content = typeof readResult.content === "string" ? readResult.content : "";
 		const lines = content.split("\n");
-		if (lines.length > limit) content = lines.slice(0, limit).join("\n");
-		let formatted = formatContentWithLineNumbers(content, offset + 1);
-		if (toolTokenLimitBeforeEvict && formatted.length >= 4 * toolTokenLimitBeforeEvict) {
-			const truncationMsg = READ_FILE_TRUNCATION_MSG.replace("{file_path}", file_path);
-			const maxContentLength = 4 * toolTokenLimitBeforeEvict - truncationMsg.length;
-			formatted = formatted.substring(0, maxContentLength) + truncationMsg;
+		let paginationResult = readResult;
+		if (lines.length > limit) {
+			content = lines.slice(0, limit).join("\n");
+			if (limit > 0 && readResult.startLine !== void 0 && readResult.endLine !== void 0) {
+				const endLine = Math.min(readResult.startLine + limit - 1, readResult.endLine, readResult.totalLines ?? Number.POSITIVE_INFINITY);
+				paginationResult = {
+					...readResult,
+					endLine,
+					nextOffset: endLine
+				};
+			}
 		}
 		return [{
 			type: "text",
-			text: formatted
+			text: truncatePaginatedRead(formatContentWithLineNumbersAndBoundaries(content, paginationResult.startLine ?? offset + 1), file_path, paginationResult, toolTokenLimitBeforeEvict)
 		}];
 	}, {
 		name: "read_file",
@@ -3260,6 +3382,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 _langchain_core_messages.SystemMessage({ content: text });
+	const existingContent = systemMessage.content;
+	if (typeof existingContent === "string") {
+		const newContent = existingContent ? `${existingContent}\n\n${text}` : text;
+		return new _langchain_core_messages.SystemMessage({ 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 _langchain_core_messages.SystemMessage({ content: newContent });
+	}
+	return new _langchain_core_messages.SystemMessage({ content: text });
+}
+//#endregion
 //#region src/middleware/subagents.ts
 /**
 * Config key used by task-tool callers to request dynamic response format.
@@ -3273,6 +3472,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
@@ -3285,6 +3486,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"
 ];
 /**
@@ -3294,25 +3507,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 langchain.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.
@@ -3355,15 +3580,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
@@ -3407,6 +3643,15 @@ function stripInFlightAIMessage(messages) {
 	const last = messages.at(-1);
 	return _langchain_core_messages.AIMessage.isInstance(last) && (last.tool_calls?.length ?? 0) > 0 ? messages.slice(0, -1) : messages;
 }
+const ForkedContextStateSchema = zod_v4.z.object({ [FORKED_CONTEXT_KEY]: zod_v4.z.boolean().optional() });
+function createForkTaskToolMiddleware(taskTool) {
+	return (0, langchain.createMiddleware)({
+		name: "forkTaskToolMiddleware",
+		stateSchema: ForkedContextStateSchema,
+		tools: [taskTool],
+		beforeAgent: () => ({ [FORKED_CONTEXT_KEY]: true })
+	});
+}
 /**
 * Create a runnable agent from a declarative `SubAgent` spec.
 *
@@ -3436,6 +3681,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 (langchain.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
@@ -3443,13 +3699,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((0, langchain.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn }));
@@ -3463,24 +3724,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);
@@ -3489,10 +3760,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);
@@ -3511,16 +3782,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];
@@ -3528,18 +3795,19 @@ function createTaskTool(options) {
 		if ("runnable" in spec || responseFormat == null) return subagentGraphs[subagentType];
 		return createSubAgent(spec, { responseFormat });
 	}
-	const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-	return (0, langchain.tool)(async (input, config) => {
+	async function runTask(input, config) {
 		const { description, subagent_type } = input;
+		const currentState = (0, _langchain_langgraph.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 = (0, _langchain_langgraph.getCurrentTaskInput)();
-		const subagentState = filterStateForSubagent(currentState);
-		if (shouldFork) subagentState.messages = [...getEffectiveMessages(stripInFlightAIMessage(currentState.messages ?? []), currentState), new _langchain_core_messages.HumanMessage({ 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 _langchain_core_messages.HumanMessage({ content: FORK_TASK_PREAMBLE + description })];
 		else subagentState.messages = [new _langchain_core_messages.HumanMessage({ content: description })];
 		subagentState._summarizationSessionId = `session_${crypto.randomUUID().substring(0, 8)}`;
 		const subagentConfig = {
@@ -3566,14 +3834,35 @@ function createTaskTool(options) {
 			return content;
 		}
 		return returnCommandWithStateUpdate(result, config.toolCall.id);
-	}, {
+	}
+	const taskToolSchema = zod_v4.z.object({
+		description: zod_v4.z.string().describe("The task to execute with the selected agent"),
+		subagent_type: zod_v4.z.string().describe(`Name of the agent to use. Available: ${subagentNames.join(", ")}`)
+	});
+	const taskTool = (0, langchain.tool)(runTask, {
 		name: "task",
 		description: finalTaskDescription,
-		schema: zod_v4.z.object({
-			description: zod_v4.z.string().describe("The task to execute with the selected agent"),
-			subagent_type: zod_v4.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: (0, langchain.tool)(runTask, {
+			name: "task",
+			description: finalTaskDescription,
+			schema: taskToolSchema
 		})
 	});
+	subagentGraphs = agents;
+	specsByName = resolvedSpecsByName;
+	forkModeNames = resolvedForkModeNames;
+	return taskTool;
 }
 /**
 * Create subagent middleware with task tool
@@ -4575,48 +4864,6 @@ function createSkillsMiddleware(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))
-	];
-}
-//#endregion
 //#region src/middleware/completion_callback.ts
 /**
 * Callback middleware for async subagents.
@@ -5476,8 +5723,9 @@ function hasToolName(tool) {
 	return tool !== null && typeof tool === "object" && "name" in tool && typeof tool.name === "string";
 }
 /**
-* Create middleware that removes excluded tools after all tool-injecting
-* middleware has had a chance to add tools to the request.
+* Create middleware that hides excluded tools from the model and rejects calls
+* to them. Exclusions calibrate the agent per model; they are not a security
+* boundary.
 *
 * @internal
 */
@@ -5489,6 +5737,16 @@ function createToolExclusionMiddleware(excludedTools) {
 				...request,
 				tools: request.tools?.filter((tool) => !hasToolName(tool) || !excludedTools.has(tool.name))
 			});
+		},
+		wrapToolCall(request, handler) {
+			const { name, id } = request.toolCall;
+			if (!excludedTools.has(name)) return handler(request);
+			return new _langchain_core_messages.ToolMessage({
+				content: `Error: ${name} is not available.`,
+				tool_call_id: id ?? "",
+				name,
+				status: "error"
+			});
 		}
 	});
 }
@@ -6234,8 +6492,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);
@@ -6271,44 +6539,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);
@@ -6800,10 +7074,23 @@ var StoreBackend = class {
 				mimeType: fileDataV2.mimeType
 			};
 			if (typeof fileDataV2.content !== "string") return { error: `File '${filePath}' has binary content but text MIME type` };
-			return {
-				content: fileDataV2.content.split("\n").slice(offset, offset + limit).join("\n"),
+			const { offset: normalizedOffset, limit: normalizedLimit } = normalizeReadPagination(offset, limit);
+			const lines = fileDataV2.content.split("\n");
+			const totalLines = lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+			const selected = lines.slice(normalizedOffset, normalizedOffset + normalizedLimit);
+			if (selected.length === 0 || normalizedOffset >= totalLines || normalizedLimit === 0) return {
+				content: selected.join("\n"),
 				mimeType: fileDataV2.mimeType
 			};
+			const endOffset = Math.min(normalizedOffset + selected.length, totalLines);
+			return {
+				content: selected.join("\n"),
+				mimeType: fileDataV2.mimeType,
+				totalLines,
+				startLine: normalizedOffset + 1,
+				endLine: endOffset,
+				nextOffset: endOffset < totalLines ? endOffset : void 0
+			};
 		} catch (e) {
 			return { error: e.message };
 		}
@@ -7069,12 +7356,20 @@ function splitLinesKeepEnds(content) {
 	return lines;
 }
 function sliceReadContent(content, offset, limit) {
-	if (!content || content.trim() === "") return { content };
+	if (!content) return { content };
 	const lines = splitLinesKeepEnds(content.replace(/\r\n/g, "\n").replace(/\r/g, "\n"));
 	const startIndex = offset;
 	const endIndex = Math.min(startIndex + limit, lines.length);
 	if (startIndex >= lines.length) return { error: `Line offset ${offset} exceeds file length (${lines.length} lines)` };
-	return { content: lines.slice(startIndex, endIndex).join("") };
+	const selected = lines.slice(startIndex, endIndex);
+	if (selected.length === 0 || offset < 0 || limit <= 0) return { content: selected.join("") };
+	return {
+		content: selected.join(""),
+		totalLines: lines.length,
+		startLine: startIndex + 1,
+		endLine: endIndex,
+		nextOffset: endIndex < lines.length ? endIndex : void 0
+	};
 }
 function isLangSmithNotFoundError(error) {
 	if (typeof error !== "object" || error === null) return false;
@@ -7553,9 +7848,11 @@ var ContextHubBackend = class ContextHubBackend {
 		}
 		const content = cache[hubPath];
 		if (content === void 0) return { error: `File '${filePath}' not found` };
-		const sliced = sliceReadContent(content, offset, limit);
+		const { offset: normalizedOffset, limit: normalizedLimit } = normalizeReadPagination(offset, limit);
+		const sliced = sliceReadContent(content, normalizedOffset, normalizedLimit);
 		if (sliced.error) return { error: sliced.error };
 		return {
+			...sliced,
 			content: sliced.content ?? "",
 			mimeType: TEXT_MIME_TYPE
 		};
@@ -7894,6 +8191,7 @@ function buildFindCommand(searchPath) {
 	const findBase = `find -L ${quotedPath} ${`\\( -path /proc -o -path /sys -o -path /dev -o -path /run -o -path ${quotedPath}/proc -o -path ${quotedPath}/sys -o -path ${quotedPath}/dev -o -path ${quotedPath}/run \\) -prune`} -o -not -path ${quotedPath}`;
 	return `{ ${`if find /dev/null -maxdepth 0 -printf '' 2>/dev/null; then ${findBase} -printf '%s\\t%T@\\t%y\\t%p\\n' 2>/dev/null; elif stat -c %s /dev/null >/dev/null 2>&1; then ${findBase} -exec sh -c '${STAT_C_SCRIPT}' _ {} +; else ${findBase} -exec stat -f '%z\t%m\t%Sp\t%N' {} + 2>/dev/null; fi || true`}; } | head -n 50001`;
 }
+const READ_METADATA_PREFIX = "__DEEPAGENTS_READ_METADATA__";
 /**
 * Pure POSIX shell command for reading files with line numbers.
 * Uses awk for line numbering with offset/limit — works on any Linux including Alpine.
@@ -7907,9 +8205,32 @@ function buildReadCommand(filePath, offset, limit) {
 	return [
 		`if [ ! -f ${quotedPath} ]; then echo "Error: File not found"; exit 1; fi`,
 		`if [ ! -s ${quotedPath} ]; then echo "System reminder: File exists but has empty contents"; exit 0; fi`,
-		`awk 'NR >= ${start} && NR <= ${end} { printf "%6d\\t%s\\n", NR, $0 }' ${quotedPath}`
+		`awk 'NR >= ${start} && NR <= ${end} { printf "%6d\\t%s\\n", NR, $0 } END { printf "${READ_METADATA_PREFIX}\\t%d\\n", NR }' ${quotedPath}`
 	].join("; ");
 }
+function parseReadOutput(output, offset, limit) {
+	const rows = output.split("\n");
+	let metadataIndex = -1;
+	for (let index = rows.length - 1; index >= 0; index -= 1) if (rows[index].startsWith(`${READ_METADATA_PREFIX}\t`)) {
+		metadataIndex = index;
+		break;
+	}
+	if (metadataIndex === -1) return { content: output };
+	const totalLines = Number(rows[metadataIndex].slice(29));
+	if (!Number.isSafeInteger(totalLines) || totalLines < 0) return { content: output };
+	const contentRows = rows.slice(0, metadataIndex);
+	const content = contentRows.length > 0 ? `${contentRows.join("\n")}\n` : "";
+	const startOffset = Math.floor(offset);
+	const endOffset = Math.min(startOffset + Math.floor(limit), totalLines);
+	if (startOffset >= totalLines || endOffset <= startOffset) return { content };
+	return {
+		content,
+		totalLines,
+		startLine: startOffset + 1,
+		endLine: endOffset,
+		nextOffset: endOffset < totalLines ? endOffset : void 0
+	};
+}
 /**
 * Build a grep command for literal (fixed-string) search.
 * Uses grep -rHnF for recursive, with-filename, with-line-number, fixed-string search.
@@ -7987,15 +8308,17 @@ var BaseSandbox = class {
 				mimeType
 			};
 		}
-		if (limit === 0) return {
+		const { offset: normalizedOffset, limit: normalizedLimit } = normalizeReadPagination(offset, limit);
+		if (normalizedLimit === 0) return {
 			content: "",
 			mimeType
 		};
-		const command = buildReadCommand(filePath, offset, limit);
+		const command = buildReadCommand(filePath, normalizedOffset, normalizedLimit);
 		const result = await this.execute(command);
 		if (result.exitCode !== 0) return { error: `File '${filePath}' not found` };
+		const parsed = parseReadOutput(result.output, normalizedOffset, normalizedLimit);
 		return {
-			content: result.output,
+			...result.truncated ? { content: parsed.content } : parsed,
 			mimeType
 		};
 	}
@@ -8712,6 +9035,12 @@ Object.defineProperty(exports, "isTextMimeType", {
 		return isTextMimeType;
 	}
 });
+Object.defineProperty(exports, "normalizeReadPagination", {
+	enumerable: true,
+	get: function() {
+		return normalizeReadPagination;
+	}
+});
 Object.defineProperty(exports, "parseHarnessProfileConfig", {
 	enumerable: true,
 	get: function() {
@@ -8743,4 +9072,4 @@ Object.defineProperty(exports, "serializeProfile", {
 	}
 });
 
-//# sourceMappingURL=langsmith-Ck9t7AGW.cjs.map
+//# sourceMappingURL=langsmith-Ynj9VKxb.cjs.map