deepagents 1.12.0 → 1.12.2

package/dist/{langsmith-CiiwzXI3.cjs → langsmith-D2d3Dwcc.cjs}

@@ -366,11 +366,32 @@ function validatePath$1(path) {
 	return normalized;
 }
 /**
+* Resolve the files under `path` for grep/glob search.
+*
+* If `path` exactly names a file that exists in `files`, only that file is
+* returned (exact match) — this lets grep/glob target a specific file
+* directly instead of only matching directories. Otherwise `path` is treated
+* as a directory and files are filtered by the normalized directory prefix.
+*
+* @returns Filtered files map, or null if `path` is invalid (e.g. whitespace-only).
+*/
+function filterFilesByPath(files, path) {
+	const exactPath = path ? path.startsWith("/") ? path : "/" + path : "/";
+	if (Object.prototype.hasOwnProperty.call(files, exactPath)) return { [exactPath]: files[exactPath] };
+	try {
+		const normalizedPath = validatePath$1(path);
+		return Object.fromEntries(Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath)));
+	} catch {
+		return null;
+	}
+}
+/**
 * Search files dict for paths matching glob pattern.
 *
 * @param files - Dictionary of file paths to FileData
 * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
-* @param path - Base path to search from
+* @param path - Base path to search from. If `path` names an exact file, only
+*               that file is considered.
 * @returns Newline-separated file paths, sorted by modification time (most recent first).
 *          Returns "No files found" if no matches.
 *
@@ -382,13 +403,9 @@ function validatePath$1(path) {
 * ```
 */
 function globSearchFiles(files, pattern, path = "/") {
-	let normalizedPath;
-	try {
-		normalizedPath = validatePath$1(path);
-	} catch {
-		return "No files found";
-	}
-	const filtered = Object.fromEntries(Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath)));
+	const filtered = filterFilesByPath(files, path);
+	if (filtered === null) return "No files found";
+	const normalizedPath = validatePath$1(path);
 	const effectivePattern = pattern;
 	const matches = [];
 	for (const [filePath, fileData] of Object.entries(filtered)) {
@@ -411,16 +428,12 @@ function globSearchFiles(files, pattern, path = "/") {
 * Return structured grep matches from an in-memory files mapping.
 *
 * Performs literal text search (not regex). Binary files are skipped.
+* If `path` names an exact file, only that file is considered.
 * Returns an empty array when no matches are found or on invalid input.
 */
 function grepMatchesFromFiles(files, pattern, path = null, glob = null) {
-	let normalizedPath;
-	try {
-		normalizedPath = validatePath$1(path);
-	} catch {
-		return [];
-	}
-	let filtered = Object.fromEntries(Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath)));
+	let filtered = filterFilesByPath(files, path);
+	if (filtered === null) return [];
 	if (glob) filtered = Object.fromEntries(Object.entries(filtered).filter(([fp]) => micromatch.default.isMatch(basename(fp), glob, {
 		dot: true,
 		nobrace: false
@@ -541,9 +554,12 @@ function adaptBackendProtocol(backend) {
 			if (typeof result === "string") return { content: result };
 			return result;
 		},
-		async grep(pattern, path, glob) {
-			const result = await ("grep" in backend ? backend.grep(pattern, path, glob) : backend.grepRaw(pattern, path, glob));
-			if (Array.isArray(result)) return { matches: result };
+		async grep(pattern, path, glob, maxCount) {
+			const result = await ("grep" in backend ? backend.grep(pattern, path, glob, maxCount) : backend.grepRaw(pattern, path, glob));
+			if (Array.isArray(result)) return applyGrepMaxCount({
+				result: { matches: result },
+				maxCount
+			});
 			if (typeof result === "string") return { error: result };
 			return result;
 		}
@@ -578,6 +594,21 @@ function adaptSandboxProtocol(sandbox) {
 //#endregion
 //#region src/backends/protocol.ts
 /**
+* Enforce a match cap after a backend grep has completed.
+*
+* When `maxCount` is set and the result exceeds it, the matches are sliced
+* to the cap and the result is flagged `truncated: true`.
+*/
+function applyGrepMaxCount(params) {
+	const { result, maxCount } = params;
+	if (maxCount == null || result.matches == null || result.matches.length <= maxCount) return result;
+	return {
+		error: result.error,
+		matches: result.matches.slice(0, maxCount),
+		truncated: true
+	};
+}
+/**
 * Type guard to check if a backend supports execution.
 *
 * @param backend - Backend instance to check
@@ -858,9 +889,12 @@ var StateBackend = class {
 	* Search file contents for a literal text pattern.
 	* Binary files are skipped.
 	*/
-	grep(pattern, path = "/", glob = null) {
+	grep(pattern, path = "/", glob = null, maxCount = null) {
 		const files = this.files;
-		return { matches: grepMatchesFromFiles(files, pattern, path, glob) };
+		return applyGrepMaxCount({
+			result: { matches: grepMatchesFromFiles(files, pattern, path, glob) },
+			maxCount
+		});
 	}
 	/**
 	* Structured glob matching returning FileInfo objects.
@@ -1102,7 +1136,7 @@ var CompositeBackend = class {
 			const results = [];
 			const defaultResult = await this.default.ls(path);
 			if (defaultResult.error) return defaultResult;
-			results.push(...defaultResult.files || []);
+			for (const fi of defaultResult.files || []) results.push(fi);
 			for (const [routePrefix] of this.sortedRoutes) results.push({
 				path: routePrefix,
 				is_dir: true,
@@ -1138,33 +1172,56 @@ var CompositeBackend = class {
 	}
 	/**
 	* Structured search results or error string for invalid input.
+	*
+	* @param maxCount - Optional total cap on returned matches across all routed
+	*                   backends. When the cap is reached, remaining routes are
+	*                   short-circuited and the result is flagged `truncated: true`.
 	*/
-	async grep(pattern, path = "/", glob = null) {
+	async grep(pattern, path = "/", glob = null, maxCount = null) {
 		const searchPath = path || "/";
 		for (const [routePrefix, backend] of this.sortedRoutes) if (this.isPathWithinRoute(searchPath, routePrefix)) {
 			const routeSearchPath = searchPath.substring(routePrefix.length - 1);
-			const raw = await backend.grep(pattern, routeSearchPath || "/", glob);
+			const raw = await backend.grep(pattern, routeSearchPath || "/", glob, maxCount);
 			if (raw.error) return raw;
-			return { matches: (raw.matches || []).map((m) => ({
-				...m,
-				path: routePrefix.slice(0, -1) + m.path
-			})) };
+			return applyGrepMaxCount({
+				result: {
+					matches: (raw.matches || []).map((m) => ({
+						...m,
+						path: routePrefix.slice(0, -1) + m.path
+					})),
+					truncated: raw.truncated
+				},
+				maxCount
+			});
 		}
 		const allMatches = [];
-		const rawDefault = await this.default.grep(pattern, searchPath, glob);
+		let truncated = false;
+		const rawDefault = await this.default.grep(pattern, searchPath, glob, maxCount);
 		if (rawDefault.error) return rawDefault;
-		allMatches.push(...rawDefault.matches || []);
+		for (const m of rawDefault.matches || []) allMatches.push(m);
+		truncated = truncated || rawDefault.truncated === true;
 		for (const [routePrefix, backend] of Object.entries(this.routes)) {
 			if (!this.isRouteUnderPath(routePrefix, searchPath)) continue;
-			const raw = await backend.grep(pattern, "/", glob);
+			const remaining = maxCount == null ? null : Math.max(maxCount - allMatches.length, 0);
+			if (remaining === 0) {
+				truncated = true;
+				break;
+			}
+			const raw = await backend.grep(pattern, "/", glob, remaining);
 			if (raw.error) return raw;
-			const matches = (raw.matches || []).map((m) => ({
+			for (const m of raw.matches || []) allMatches.push({
 				...m,
 				path: routePrefix.slice(0, -1) + m.path
-			}));
-			allMatches.push(...matches);
+			});
+			truncated = truncated || raw.truncated === true;
 		}
-		return { matches: allMatches };
+		return applyGrepMaxCount({
+			result: {
+				matches: allMatches,
+				truncated
+			},
+			maxCount
+		});
 	}
 	/**
 	* Structured glob matching returning FileInfo objects.
@@ -1175,26 +1232,33 @@ var CompositeBackend = class {
 			const searchPath = path.substring(routePrefix.length - 1);
 			const result = await backend.glob(pattern, searchPath || "/");
 			if (result.error) return result;
-			return { files: (result.files || []).map((fi) => ({
-				...fi,
-				path: routePrefix.slice(0, -1) + fi.path
-			})) };
+			return {
+				files: (result.files || []).map((fi) => ({
+					...fi,
+					path: routePrefix.slice(0, -1) + fi.path
+				})),
+				truncated: result.truncated
+			};
 		}
 		const defaultResult = await this.default.glob(pattern, path);
 		if (defaultResult.error) return defaultResult;
-		results.push(...defaultResult.files || []);
+		for (const fi of defaultResult.files || []) results.push(fi);
+		let truncated = defaultResult.truncated === true;
 		for (const [routePrefix, backend] of Object.entries(this.routes)) {
 			if (!this.isRouteUnderPath(routePrefix, path)) continue;
 			const result = await backend.glob(pattern, "/");
 			if (result.error) continue;
-			const files = (result.files || []).map((fi) => ({
+			for (const fi of result.files || []) results.push({
 				...fi,
 				path: routePrefix.slice(0, -1) + fi.path
-			}));
-			results.push(...files);
+			});
+			truncated = truncated || result.truncated === true;
 		}
 		results.sort((a, b) => a.path.localeCompare(b.path));
-		return { files: results };
+		return {
+			files: results,
+			truncated
+		};
 	}
 	/**
 	* Write content to a file, routing to appropriate backend.
@@ -1390,6 +1454,15 @@ 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.]`;
 /**
+* 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.";
+/**
+* Default cap on the number of matches the grep tool returns.
+* Set to null to disable the cap.
+*/
+const DEFAULT_GREP_MAX_COUNT = 1e3;
+/**
 * Message template for evicted tool results.
 */
 const TOO_LARGE_TOOL_MSG = langchain.context`
@@ -1878,13 +1951,14 @@ function createGlobTool(backend, options) {
 * Create grep tool using backend.
 */
 function createGrepTool(backend, options) {
-	const { customDescription, permissions, includeExecution } = options;
+	const { customDescription, permissions, includeExecution, grepMaxCount } = options;
 	return (0, langchain.tool)(async (input, runtime) => {
 		const permissionError = checkPermission(permissions, "read", input.path ?? "/");
 		if (permissionError !== void 0) return toolError(runtime, "grep", permissionError);
 		const resolvedBackend = await resolveBackend(backend, runtime);
 		const { pattern, path = "/", glob = null } = input;
-		const result = await resolvedBackend.grep(pattern, path, glob);
+		const maxCount = input.max_count ?? grepMaxCount;
+		const result = await resolvedBackend.grep(pattern, path, glob, maxCount);
 		if (result.error) return result.error;
 		const matches = filterByPermissions(result.matches ?? [], permissions, "read", (m) => m.path);
 		if (matches.length === 0) return `No matches found for pattern '${pattern}'`;
@@ -1898,15 +1972,17 @@ function createGrepTool(backend, options) {
 			lines.push(`  ${match.line}: ${match.text}`);
 		}
 		const truncated = truncateIfTooLong(lines);
-		if (Array.isArray(truncated)) return truncated.join("\n");
-		return truncated;
+		let content = Array.isArray(truncated) ? truncated.join("\n") : truncated;
+		if (result.truncated) content += `\n\n${GREP_TRUNCATION_NOTE}`;
+		return content;
 	}, {
 		name: "grep",
 		description: customDescription || getGrepToolDescription(includeExecution),
 		schema: zod_v4.z.object({
 			pattern: zod_v4.z.string().describe("Literal text pattern to search for (not regex)"),
 			path: zod_v4.z.string().optional().default("/").describe("Base path to search from (default: /)"),
-			glob: zod_v4.z.string().optional().nullable().default(null).describe("Optional glob pattern to filter files (e.g., '*.py')")
+			glob: zod_v4.z.string().optional().nullable().default(null).describe("Optional glob pattern to filter files (e.g., '*.py')"),
+			max_count: zod_v4.z.number().int().positive().optional().nullable().default(null).describe("Optional cap on the total number of matches returned across all files. Leave unset to use the configured default. When the cap is hit, results are truncated and a note says so; narrow the pattern or path to see the rest.")
 		})
 	});
 }
@@ -1975,7 +2051,7 @@ 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 } = 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 enabledFilesystemTools = normalizeFilesystemTools(filesystemTools);
 	const executeToolEnabled = enabledFilesystemTools == null || enabledFilesystemTools.has("execute");
 	if (permissions.length > 0) validatePermissionPaths(permissions);
@@ -2011,7 +2087,8 @@ function createFilesystemMiddleware(options = {}) {
 		grep: createGrepTool(backend, {
 			customDescription: customToolDescriptions?.grep,
 			permissions,
-			includeExecution: configuredToolNames.has("execute") && typeof backend !== "function" && isSandboxBackend(backend)
+			includeExecution: configuredToolNames.has("execute") && typeof backend !== "function" && isSandboxBackend(backend),
+			grepMaxCount
 		}),
 		execute: createExecuteTool(backend, {
 			customDescription: customToolDescriptions?.execute,
@@ -6373,7 +6450,7 @@ var StoreBackend = class {
 	* Search file contents for a literal text pattern.
 	* Binary files are skipped.
 	*/
-	async grep(pattern, path = "/", glob = null) {
+	async grep(pattern, path = "/", glob = null, maxCount = null) {
 		const store = this.getStore();
 		const namespace = this.getNamespace();
 		const items = await this.searchStorePaginated(store, namespace);
@@ -6383,7 +6460,10 @@ var StoreBackend = class {
 		} catch {
 			continue;
 		}
-		return { matches: grepMatchesFromFiles(files, pattern, path, glob) };
+		return applyGrepMaxCount({
+			result: { matches: grepMatchesFromFiles(files, pattern, path, glob) },
+			maxCount
+		});
 	}
 	/**
 	* Structured glob matching returning FileInfo objects.
@@ -6682,7 +6762,7 @@ var ContextHubBackend = class ContextHubBackend {
 			modified_at: now
 		} };
 	}
-	async grep(pattern, path = null, glob = null) {
+	async grep(pattern, path = null, glob = null, maxCount = null) {
 		let cache;
 		try {
 			cache = await this.ensureCache();
@@ -6705,7 +6785,10 @@ var ContextHubBackend = class ContextHubBackend {
 				});
 			}
 		}
-		return { matches };
+		return applyGrepMaxCount({
+			result: { matches },
+			maxCount
+		});
 	}
 	async glob(pattern, _path = "/") {
 		let cache;
@@ -7101,7 +7184,7 @@ var BaseSandbox = class {
 	* @param glob - Optional glob pattern to filter which files to search.
 	* @returns List of GrepMatch dicts containing path, line number, and matched text.
 	*/
-	async grep(pattern, path = "/", glob = null) {
+	async grep(pattern, path = "/", glob = null, maxCount = null) {
 		const command = buildGrepCommand(pattern, path, glob);
 		const output = (await this.execute(command)).output.trim();
 		if (!output) return { matches: [] };
@@ -7119,7 +7202,10 @@ var BaseSandbox = class {
 				});
 			}
 		}
-		return { matches };
+		return applyGrepMaxCount({
+			result: { matches },
+			maxCount
+		});
 	}
 	/**
 	* Structured glob matching returning FileInfo objects.
@@ -7618,6 +7704,12 @@ Object.defineProperty(exports, "adaptSandboxProtocol", {
 		return adaptSandboxProtocol;
 	}
 });
+Object.defineProperty(exports, "applyGrepMaxCount", {
+	enumerable: true,
+	get: function() {
+		return applyGrepMaxCount;
+	}
+});
 Object.defineProperty(exports, "checkEmptyContent", {
 	enumerable: true,
 	get: function() {
@@ -7781,4 +7873,4 @@ Object.defineProperty(exports, "serializeProfile", {
 	}
 });
 
-//# sourceMappingURL=langsmith-CiiwzXI3.cjs.map
+//# sourceMappingURL=langsmith-D2d3Dwcc.cjs.map