deepagents 1.13.0 → 1.13.2

package/dist/{langsmith-Ck9t7AGW.cjs → langsmith-DL32swQ3.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",
@@ -5476,8 +5598,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 +5612,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"
+			});
 		}
 	});
 }
@@ -6800,10 +6933,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 +7215,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 +7707,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 +8050,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 +8064,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 +8167,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 +8894,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 +8931,4 @@ Object.defineProperty(exports, "serializeProfile", {
 	}
 });
 
-//# sourceMappingURL=langsmith-Ck9t7AGW.cjs.map
+//# sourceMappingURL=langsmith-DL32swQ3.cjs.map