deepagents 1.13.4 → 1.13.5

package/dist/{langsmith-BAO_h4J6.js → langsmith-CY7MawjU.js}

@@ -206,6 +206,21 @@ function formatContentWithLineNumbers(content, startLine = 1) {
 	return formatContentWithLineNumbersAndBoundaries(content, startLine).text;
 }
 /**
+* Join file content into the unmodified source body of a `read_file` result.
+*
+* Source lines are emitted unchanged, with no numbering. A status header
+* carries the line-range metadata separately, so nothing here needs to
+* encode line numbers or escape anything.
+*/
+function formatSourceBlock(content) {
+	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;
+	return lines.join("\n");
+}
+/**
 * Check if content is empty and return warning message.
 *
 * @param content - Content to check
@@ -1539,7 +1554,6 @@ var CompositeBackend = class {
 * - Pluggable backends (StateBackend, StoreBackend, FilesystemBackend, CompositeBackend)
 * - Tool result eviction for large outputs
 */
-const INT_FORMATTER = new Intl.NumberFormat("en-US");
 /**
 * Normalizes tool input so that models sending `path` instead of `file_path`
 * still work. If the input has `path` but not `file_path`, copies `path` into
@@ -1609,29 +1623,100 @@ 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.
+* Describe the window a read returned, as status header fields.
 *
 * 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.
+* file was read. The middleware owns presentation: it renders the source
+* unmodified and turns optional metadata into a terse header. Keeping the
+* fields optional preserves compatibility with custom backends that predate
+* this contract — `prepareReadWindow` derives a range for those instead.
 *
-* `nextOffset` is the signal that the read is partial. A result at EOF omits it,
-* so complete reads retain their previous output shape.
+* Returns the `lines A-B[ of T]` field, followed by `next offset N` when the
+* window stopped short of the end of the file.
 */
-function remainingLinesNotice(readResult) {
+function describeReadWindow(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}.]`;
+	if (startLine === void 0 || endLine === void 0 || !Number.isSafeInteger(startLine) || !Number.isSafeInteger(endLine) || startLine < 1 || endLine < startLine || totalLines !== void 0 && (!Number.isSafeInteger(totalLines) || totalLines < endLine)) return [];
+	let span = `lines ${startLine}-${endLine}`;
+	if (totalLines !== void 0) span += ` of ${totalLines}`;
+	const fields = [span];
+	if (nextOffset !== void 0 && (totalLines === void 0 || endLine < totalLines)) fields.push(`next offset ${nextOffset}`);
+	return fields;
+}
+/** Render the status header that sits above a text `read_file` result. */
+function readHeader(fields) {
+	return `@@ ${fields.join(" | ")} @@`;
+}
+/** Notice disclosing that a negative `offset` was reinterpreted as the start of the file, or `undefined` for a non-negative offset. */
+function clampedOffsetNotice(offset) {
+	if (offset >= 0) return;
+	return `[Requested offset ${offset} is before the start of the file; read from line 1 instead.]`;
+}
+/**
+* Compose a read result from its notices, status header, and source body.
+*
+* Notices sit above the header, so every line below it is unmodified file
+* content and consumers (including `stripLineNumbers` in the quickjs
+* provider) can tell the two apart by position.
+*/
+function assembleRead(body, options) {
+	const { fields, notices = [] } = options;
+	return [
+		...notices,
+		readHeader(fields),
+		body
+	].join("\n");
+}
+/** Derives a header range from `offset` when the backend left `startLine`/`endLine` unset. */
+function prepareReadWindow(readResult, content, offset) {
+	const body = formatSourceBlock(content);
+	if (readResult.startLine !== void 0 && readResult.endLine !== void 0) return {
+		readResult,
+		body
+	};
+	const startLine = offset + 1;
+	const endLine = startLine + body.split("\n").length - 1;
+	return {
+		readResult: {
+			...readResult,
+			startLine,
+			endLine
+		},
+		body
+	};
+}
+/**
+* Assemble a read cut inside a single source line too long to fit.
+*
+* No offset reaches the remainder of such a line, so the header reports how
+* much of it is shown in place of a resume point.
+*/
+function midlineTruncatedRead(body, readResult, threshold, notices) {
+	const newlineIdx = body.indexOf("\n");
+	const oversized = newlineIdx === -1 ? body.length : newlineIdx;
+	const clipped = {
+		totalLines: readResult.totalLines,
+		startLine: readResult.startLine,
+		endLine: readResult.startLine,
+		nextOffset: void 0
+	};
+	const fieldsFor = (shown) => [
+		...describeReadWindow(clipped),
+		"truncated mid-line",
+		`${shown} of ${oversized} chars`
+	];
+	const reserved = assembleRead("", {
+		fields: fieldsFor(oversized),
+		notices
+	}).length;
+	const shown = Math.max(0, Math.min(oversized, threshold - reserved));
+	return assembleRead(body.slice(0, shown), {
+		fields: fieldsFor(shown),
+		notices
+	});
 }
 /**
-* Fit a line-numbered read into the middleware's output budget without
+* Fit a paginated 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:
@@ -1642,38 +1727,50 @@ function remainingLinesNotice(readResult) {
 * 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);
+* complete source line and rebuilds the header from the last line actually
+* displayed. If no complete source line fits alongside the truncation
+* message, it falls back to `midlineTruncatedRead`, which reports exactly how
+* much of the oversized line is shown rather than guessing at a resume point.
+*/
+function truncatePaginatedRead(body, readResult, options) {
+	const { filePath, tokenLimit, notices = [] } = options;
+	const result = assembleRead(body, {
+		fields: describeReadWindow(readResult),
+		notices
+	});
+	if (!tokenLimit || result.length < 4 * tokenLimit) return result;
+	const truncationMsg = READ_FILE_TRUNCATION_MSG.replace("{file_path}", filePath).trim();
 	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);
+		const rows = body.split("\n");
+		let position = 0;
+		const boundaries = [];
+		for (let index = 0; index < rows.length; index += 1) {
+			const sourceLine = readResult.startLine + index;
+			if (sourceLine > readResult.endLine) break;
+			position += rows[index].length;
+			boundaries.push({
+				endOffset: position,
+				endLine: sourceLine
+			});
+			position += 1;
+		}
 		for (let index = boundaries.length - 1; index >= 0; index -= 1) {
-			const boundary = boundaries[index];
-			const adjustedNotice = remainingLinesNotice({
+			const { endOffset, endLine } = boundaries[index];
+			const adjustedResult = {
 				totalLines: readResult.totalLines,
 				startLine: readResult.startLine,
-				endLine: boundary.sourceLine,
-				nextOffset: boundary.sourceLine
+				endLine,
+				nextOffset: endLine
+			};
+			const candidate = assembleRead(body.slice(0, endOffset), {
+				fields: [...describeReadWindow(adjustedResult), "truncated due to size"],
+				notices: [...notices, truncationMsg]
 			});
-			if (boundary.endOffset + truncationMsg.length + adjustedNotice.length <= threshold) return content.slice(0, boundary.endOffset) + truncationMsg + adjustedNotice;
+			if (candidate.length <= threshold) return candidate;
 		}
 	}
-	const maxContentLength = Math.max(0, threshold - truncationMsg.length);
-	return content.substring(0, maxContentLength) + truncationMsg;
+	return midlineTruncatedRead(body, readResult, threshold, [...notices, truncationMsg]);
 }
 /**
 * Note appended to grep results that were cut short by the match-count cap.
@@ -2069,8 +2166,7 @@ const READ_FILE_TOOL_DESCRIPTION = context`
 
   Usage:
   - By default, it reads up to ${100} lines starting from the beginning of the file. Use \`offset\`/\`limit\` to page through large files instead of reading them whole.
-  - Results are returned with line numbers starting at \`offset\` + 1 (1 by default), then two spaces, then the source line. Never include these line-number prefixes when editing.
-  - Lines over ${INT_FORMATTER.format(MAX_LINE_LENGTH)} characters are split with continuation markers (e.g. 5.1, 5.2); \`limit\` counts source lines, so continuation rows do not consume the budget.
+  - A status header, \`@@ field | field | ... @@\`, sits above the file content, and every line after it is unmodified file content. When content is truncated, there may be an explanation before the header. Never include the header when editing.
   - Speculatively batch multiple \`read_file\` calls in one response when several files may be useful.
   - An empty file returns a system-reminder warning in place of contents.
   - Large tool results may be offloaded to a file; the tool message gives the path. Read that path here, paging with \`offset\`/\`limit\`.
@@ -2090,7 +2186,7 @@ const EDIT_FILE_TOOL_DESCRIPTION = context`
 
   Usage:
   - You must read the file before editing; this tool errors otherwise.
-  - Preserve the exact indentation from the read output, and never include line-number prefixes in old_string or new_string.
+  - Preserve the exact source indentation from the read output, and never include the read status header in old_string or new_string.
   - Prefer editing an existing file over creating a new one.
   - Only use emojis if the user explicitly requests it.
 `;
@@ -2225,6 +2321,10 @@ function createReadFileTool(backend, options) {
 			}];
 		}
 		let content = typeof readResult.content === "string" ? readResult.content : "";
+		if (content === "System reminder: File exists but has empty contents") return [{
+			type: "text",
+			text: content
+		}];
 		const lines = content.split("\n");
 		let paginationResult = readResult;
 		if (lines.length > limit) {
@@ -2238,9 +2338,15 @@ function createReadFileTool(backend, options) {
 				};
 			}
 		}
+		const { readResult: preparedResult, body } = prepareReadWindow(paginationResult, content, offset);
+		const clampNotice = clampedOffsetNotice(requestedOffset);
 		return [{
 			type: "text",
-			text: truncatePaginatedRead(formatContentWithLineNumbersAndBoundaries(content, paginationResult.startLine ?? offset + 1), file_path, paginationResult, toolTokenLimitBeforeEvict)
+			text: truncatePaginatedRead(body, preparedResult, {
+				filePath: file_path,
+				tokenLimit: toolTokenLimitBeforeEvict,
+				notices: clampNotice ? [clampNotice] : []
+			})
 		}];
 	}, {
 		name: "read_file",
@@ -4827,17 +4933,11 @@ function validateModulePath(raw) {
 */
 function createSkillsMiddleware(options) {
 	const { backend, sources } = options;
-	let loadedSkills = [];
 	return createMiddleware({
 		name: "SkillsMiddleware",
 		stateSchema: SkillsStateSchema,
 		async beforeAgent(state) {
-			const stateHasSkills = "skillsMetadata" in state && Array.isArray(state.skillsMetadata) && state.skillsMetadata.length > 0;
-			if (loadedSkills.length > 0) return stateHasSkills ? void 0 : { skillsMetadata: loadedSkills };
-			if (stateHasSkills) {
-				loadedSkills = state.skillsMetadata;
-				return;
-			}
+			if ("skillsMetadata" in state && Array.isArray(state.skillsMetadata) && state.skillsMetadata.length > 0) return;
 			const resolvedBackend = await resolveBackend(backend, { state });
 			const allSkills = /* @__PURE__ */ new Map();
 			for (const sourcePath of sources) try {
@@ -4846,11 +4946,10 @@ function createSkillsMiddleware(options) {
 			} catch (error) {
 				console.debug(`[BackendSkillsMiddleware] Failed to load skills from ${sourcePath}:`, error);
 			}
-			loadedSkills = Array.from(allSkills.values());
-			return { skillsMetadata: loadedSkills };
+			return { skillsMetadata: Array.from(allSkills.values()) };
 		},
 		wrapModelCall(request, handler) {
-			const skillsMetadata = loadedSkills.length > 0 ? loadedSkills : request.state?.skillsMetadata || [];
+			const skillsMetadata = request.state?.skillsMetadata || [];
 			const skillsLocations = formatSkillsLocations(sources);
 			const skillsList = formatSkillsList(skillsMetadata, sources);
 			const skillsSection = SKILLS_SYSTEM_PROMPT.replace("{skills_locations}", skillsLocations).replace("{skills_list}", skillsList);
@@ -8754,4 +8853,4 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 //#endregion
 export { DEFAULT_GENERAL_PURPOSE_DESCRIPTION as A, StateBackend as B, MAX_SKILL_DESCRIPTION_LENGTH as C, createMemoryMiddleware as D, createSkillsMiddleware as E, createSubAgentMiddleware as F, resolveBackend as G, applyGrepMaxCount as H, computeSummarizationDefaults as I, checkEmptyContent as J, adaptBackendProtocol as K, createSummarizationMiddleware as L, GENERAL_PURPOSE_SUBAGENT as M, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as N, filesValue as O, createSubAgent as P, performStringReplacement as Q, createFilesystemMiddleware as R, createCompletionCallbackMiddleware as S, MAX_SKILL_NAME_LENGTH as T, isSandboxBackend as U, SandboxError as V, isSandboxProtocol as W, isTextMimeType as X, getMimeType as Y, normalizeReadPagination 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_SUBAGENT_PROMPT as j, createPatchToolCallsMiddleware as k, createDeepAgent as l, parseHarnessProfileConfig as m, BaseSandbox as n, BASE_AGENT_PROMPT as o, harnessProfileConfigSchema as p, adaptSandboxProtocol 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, CompositeBackend as z };
 
-//# sourceMappingURL=langsmith-BAO_h4J6.js.map
+//# sourceMappingURL=langsmith-CY7MawjU.js.map