zidane 7.2.4 → 8.0.4

package/dist/tools-_DnT3AGM.js

@@ -0,0 +1,578 @@
+import { d as isAbortLikeError, u as errorMessage } from "./errors-DKiMrOKq.js";
+import { n as shellQuote } from "./shell-quote-BmnhZmdM.js";
+import { toolPrompts } from "./tools/prompts.js";
+import { i as parseGitLsFiles, r as GIT_LS_FILES_COMMAND } from "./contexts-d7UolYot.js";
+import { Buffer } from "node:buffer";
+//#region src/tools/glob.ts
+/**
+* Glob-pattern file matching.
+*
+* Delegates matching to {@link ExecutionContext.listFiles} with `{ glob:
+* true }`. This keeps filesystem semantics inside the execution context
+* (process / docker / sandbox) instead of reaching around it from the tool.
+*
+* Results are capped at 1000 entries to keep model input bounded. The
+* cap applies after the directory filter, so dirs don't consume the
+* file budget.
+*
+* Patterns are deliberately NOT confined to the workspace: like
+* `read_file`, `../`-prefixed patterns may match outside the cwd — the
+* execution context is the sandbox boundary, not this tool.
+*
+* By default, contexts that can cheaply provide metadata return
+* `<path>\t<size>\t<mtime>` rows. Contexts without cheap metadata support return
+* paths only. Pass `metadata: false` to request plain newline-separated paths.
+*/
+const DEFAULT_LIMIT = 1e3;
+/** Backstop so a pathological walk can never hang the agent's turn. */
+const GLOB_TIMEOUT_MS = 2e4;
+function entryPath(entry) {
+	return typeof entry === "string" ? entry : entry.path;
+}
+function entryMetadata(entry) {
+	return typeof entry === "string" ? void 0 : entry;
+}
+function renderEntry(entry, wantMetadata) {
+	const path = entryPath(entry);
+	const meta = entryMetadata(entry);
+	if (!wantMetadata || typeof meta?.size !== "number" || typeof meta.mtimeMs !== "number") return path;
+	return `${path}\t${meta.size}\t${new Date(meta.mtimeMs).toISOString()}`;
+}
+const glob = {
+	isConcurrencySafe: true,
+	spec: {
+		name: "glob",
+		description: toolPrompts.glob,
+		inputSchema: {
+			type: "object",
+			properties: {
+				pattern: {
+					type: "string",
+					description: "Glob pattern (e.g. \"src/**/*.ts\", \"*.md\", \"test/**/fixtures/*\")."
+				},
+				limit: {
+					type: "number",
+					description: `Maximum number of matches to return. Default: ${DEFAULT_LIMIT}.`
+				},
+				metadata: {
+					type: "boolean",
+					description: "Append size (bytes) and mtime (ISO) per row, tab-separated. Default: true. In-process only; non-process execution contexts always return paths."
+				},
+				gitignore: {
+					type: "boolean",
+					description: "Skip files git ignores (.gitignore, .git/info/exclude, global excludes). Default: true. Set false to include ignored files like node_modules. Honored where git is available; a no-op otherwise."
+				}
+			},
+			required: ["pattern"]
+		}
+	},
+	async execute({ pattern, limit, metadata, gitignore }, ctx) {
+		const pat = pattern;
+		const max = typeof limit === "number" && limit > 0 ? limit : DEFAULT_LIMIT;
+		const wantMetadata = metadata !== false;
+		try {
+			if (ctx.execution.capabilities.glob !== true) throw new Error(`The active execution context (${ctx.execution.type}) does not support glob matching.`);
+			const controller = new AbortController();
+			const onAbort = () => controller.abort();
+			ctx.signal.addEventListener("abort", onAbort, { once: true });
+			let timer;
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(() => {
+					controller.abort();
+					resolve("timeout");
+				}, GLOB_TIMEOUT_MS);
+			});
+			try {
+				const outcome = await Promise.race([ctx.execution.listFiles(ctx.handle, pat, {
+					glob: true,
+					limit: max,
+					metadata: wantMetadata,
+					gitignore,
+					signal: controller.signal
+				}), timeout]);
+				if (outcome === "timeout") return `Glob timed out after ${GLOB_TIMEOUT_MS}ms: narrow the pattern (anchor a literal prefix like \`src/**\`) or scope it to a subdirectory.`;
+				if (outcome.length === 0) return "(no matches)";
+				return outcome.map((entry) => renderEntry(entry, wantMetadata)).join("\n");
+			} finally {
+				clearTimeout(timer);
+				ctx.signal.removeEventListener("abort", onAbort);
+			}
+		} catch (err) {
+			return `Glob error: ${errorMessage(err)}`;
+		}
+	}
+};
+//#endregion
+//#region src/tools/grep.ts
+/**
+* Search file contents by regex.
+*
+* Wraps ripgrep (`rg`) when available; when it's not, falls back to a
+* regex search that enumerates files via the execution context's shell
+* (`find` over `exec`) and reads them via `ctx.execution.readFile`. Both
+* legs go through the {@link ToolContext.execution} seam, so the search
+* runs wherever the context's files actually live — in-process, a
+* container, or a remote sandbox — without the tool ever touching the host
+* filesystem directly.
+*
+* The tool surface mirrors Claude Code's `Grep` so models authored against the
+* Anthropic tool surface need no relearning. Output modes:
+*   - `files_with_matches` (default) — newline-separated paths.
+*   - `content` — `path:line:match` (line numbers on by default).
+*   - `count` — `path:N` per matching file.
+*
+* Results are capped via `head_limit` (default 250) to keep model input
+* bounded; `offset` lets the caller page through. Pagination operates on
+* OUTPUT LINES, not match groups — in content mode, context lines and `--`
+* separators consume the budget too (documented in the schema).
+*
+* A line cap is not enough on its own: ripgrep is line-oriented, so a minified
+* / single-line file collapses to ONE match line that is the entire file, and
+* `head_limit` would happily return megabytes — enough to blow the model's
+* context window. Output is therefore ALSO byte-bounded: each line is clipped
+* to `MAX_LINE_BYTES` and the total to `OUTPUT_BYTE_CAP`, mirroring the byte
+* discipline `read_file` already enforces.
+*
+* `path` is deliberately NOT confined to the workspace: like `read_file`,
+* absolute paths and `../` traversal are allowed — the execution context is
+* the sandbox boundary, not this tool.
+*/
+const DEFAULT_HEAD_LIMIT = 250;
+/**
+* Per-line byte cap. ripgrep reports a match as the whole matching LINE, so a
+* minified / single-line file (one line = the entire file) would otherwise be
+* returned in full. Clip each line so a single line can't dump unbounded bytes
+* into the model context.
+*/
+const MAX_LINE_BYTES = 2e3;
+/**
+* OOM guard for the no-ripgrep fallback: it reads each candidate WHOLE
+* into memory (the execution interface has no streaming read), so one
+* multi-GB artifact would take the process down. Enforced twice — the
+* `find` walk excludes oversized files via the portable `-size`
+* predicate (POSIX `c` suffix, GNU + BSD), and the read loop probes
+* process-local sizes to cover the single-file fast path that bypasses
+* the walk. A documented divergence from the ripgrep path, which
+* streams and searches such files fine.
+*/
+const FALLBACK_MAX_FILE_BYTES = 16777216;
+/** Total output byte cap, mirroring read_file's `DEFAULT_BYTE_CAP`. */
+const OUTPUT_BYTE_CAP = 262144;
+const DEFAULT_OUTPUT_MODE = "files_with_matches";
+const grep = {
+	isConcurrencySafe: true,
+	spec: {
+		name: "grep",
+		description: toolPrompts.grep,
+		inputSchema: {
+			type: "object",
+			properties: {
+				"pattern": {
+					type: "string",
+					description: "Regex (PCRE-flavored via ripgrep, JS regex via fallback)."
+				},
+				"patterns": {
+					type: "array",
+					items: { type: "string" },
+					description: "More regexes; a line matches if it matches `pattern` OR any of these (like `rg -e a -e b`)."
+				},
+				"exclude": {
+					type: "string",
+					description: "Drop output lines matching this regex (applied to the whole output line, like piping through `grep -v`)."
+				},
+				"fixed_strings": {
+					type: "boolean",
+					description: "Treat patterns as literal strings, not regexes (`-F`)."
+				},
+				"-w": {
+					type: "boolean",
+					description: "Match whole words only."
+				},
+				"path": {
+					type: "string",
+					description: "File or directory to search. Default: \".\". May be absolute or outside the workspace (no confinement; consistent with read_file)."
+				},
+				"paths": {
+					type: "array",
+					items: { type: "string" },
+					description: "Several files or directories to search in one call (combined with `path` when both are set)."
+				},
+				"glob": {
+					type: "string",
+					description: "Restrict to files matching this glob, e.g. \"**/*.ts\"."
+				},
+				"type": {
+					type: "string",
+					description: "rg file type filter, e.g. \"ts\", \"py\", \"rust\". Ignored by the fallback."
+				},
+				"output_mode": {
+					type: "string",
+					enum: [
+						"content",
+						"files_with_matches",
+						"count"
+					],
+					description: "Default: \"files_with_matches\"."
+				},
+				"-i": {
+					type: "boolean",
+					description: "Case-insensitive match."
+				},
+				"-n": {
+					type: "boolean",
+					description: "Show line numbers (content mode). Default: true."
+				},
+				"-A": {
+					type: "integer",
+					description: "Lines of trailing context (content mode)."
+				},
+				"-B": {
+					type: "integer",
+					description: "Lines of leading context (content mode)."
+				},
+				"-C": {
+					type: "integer",
+					description: "Lines of surrounding context (content mode). Overridden by -A/-B if set."
+				},
+				"multiline": {
+					type: "boolean",
+					description: "Allow patterns to match across line boundaries."
+				},
+				"gitignore": {
+					type: "boolean",
+					description: "Skip files git ignores (.gitignore, .git/info/exclude, global excludes). Default: true. Set false to also search ignored files like node_modules."
+				},
+				"head_limit": {
+					type: "integer",
+					description: `Cap output lines. Default: 250. Set 0 for unlimited lines. In content mode, context lines (-A/-B/-C) and "--" separators count toward the cap, so the number of matches shown may be lower. Output is independently byte-bounded: each line is clipped to ${MAX_LINE_BYTES} bytes and the total to ${OUTPUT_BYTE_CAP} bytes, so long (e.g. minified) lines never overflow the context window.`
+				},
+				"offset": {
+					type: "integer",
+					description: "Skip first N output lines. Default: 0."
+				}
+			},
+			required: ["pattern"]
+		}
+	},
+	async execute(rawInput, ctx) {
+		const input = rawInput;
+		const invalid = validateInput(input);
+		if (invalid) return `grep error: ${invalid}`;
+		try {
+			if (await isRipgrepAvailable(ctx)) return await runViaRipgrep(input, ctx);
+			return await runFallback(input, ctx);
+		} catch (err) {
+			if (isAbortLikeError(err)) throw err;
+			return `grep error: ${errorMessage(err)}`;
+		}
+	}
+};
+/**
+* Probe ripgrep availability **per call**. The probe is intentionally not
+* cached: caching at module scope would leak across execution contexts (an
+* orchestrator running an in-process agent and a docker agent in the same
+* Node process must be able to differ on whether `rg` exists), and caching
+* per handle adds bookkeeping for negligible savings — `rg --version` is
+* ~5 ms, and grep is invoked at most a few times per turn.
+*/
+async function isRipgrepAvailable(ctx) {
+	return (await ctx.execution.exec(ctx.handle, "rg --version", { signal: ctx.signal })).exitCode === 0;
+}
+/**
+* Every regex the call matches on: `pattern` plus non-empty `patterns`. An
+* empty `pattern` next to non-empty `patterns` is dropped: it would match
+* every line.
+*/
+function allPatterns(input) {
+	const extra = Array.isArray(input.patterns) ? input.patterns.filter((p) => typeof p === "string" && p.length > 0) : [];
+	if (input.pattern === "" && extra.length > 0) return extra;
+	return [input.pattern, ...extra];
+}
+/** Search roots: `path` and `paths` combined, defaulting to `.`. */
+function searchRoots(input) {
+	const roots = [...typeof input.path === "string" && input.path.length > 0 ? [input.path] : [], ...Array.isArray(input.paths) ? input.paths.filter((p) => typeof p === "string" && p.length > 0) : []];
+	return roots.length > 0 ? [...new Set(roots)] : ["."];
+}
+function validateInput(input) {
+	if (typeof input.pattern !== "string") return "`pattern` must be a string.";
+	if (input.patterns !== void 0 && (!Array.isArray(input.patterns) || input.patterns.some((p) => typeof p !== "string"))) return "`patterns` must be an array of strings.";
+	if (input.paths !== void 0 && (!Array.isArray(input.paths) || input.paths.some((p) => typeof p !== "string"))) return "`paths` must be an array of strings.";
+	if (input.exclude !== void 0) {
+		if (typeof input.exclude !== "string") return "`exclude` must be a string.";
+		try {
+			new RegExp(input.exclude);
+		} catch (err) {
+			return `invalid exclude regex: ${errorMessage(err)}`;
+		}
+	}
+}
+async function runViaRipgrep(input, ctx) {
+	const args = ["rg"];
+	const mode = input.output_mode ?? DEFAULT_OUTPUT_MODE;
+	if (mode === "files_with_matches") args.push("--files-with-matches");
+	else if (mode === "count") args.push("--count");
+	else args.push(input["-n"] ?? true ? "--line-number" : "--no-line-number");
+	if (input["-i"]) args.push("-i");
+	if (input.fixed_strings) args.push("--fixed-strings");
+	if (input["-w"]) args.push("--word-regexp");
+	if (mode === "content") {
+		if (typeof input["-A"] === "number") args.push("-A", String(input["-A"]));
+		if (typeof input["-B"] === "number") args.push("-B", String(input["-B"]));
+		if (typeof input["-C"] === "number" && typeof input["-A"] !== "number" && typeof input["-B"] !== "number") args.push("-C", String(input["-C"]));
+	}
+	if (input.multiline) args.push("--multiline", "--multiline-dotall");
+	if (input.gitignore === false) args.push("--no-ignore");
+	if (input.glob) args.push("--glob", input.glob);
+	if (input.type) args.push("--type", input.type);
+	for (const pattern of allPatterns(input)) args.push("-e", pattern);
+	args.push("--", ...searchRoots(input));
+	const command = args.map(shellQuote).join(" ");
+	const result = await ctx.execution.exec(ctx.handle, command, { signal: ctx.signal });
+	if (result.exitCode !== 0 && result.exitCode !== 1) return `grep error: ${result.stderr.trim() || `rg exited with code ${result.exitCode}`}`;
+	return formatPaginated(result.stdout, input);
+}
+async function runFallback(input, ctx) {
+	const mode = input.output_mode ?? DEFAULT_OUTPUT_MODE;
+	const flags = `${input["-i"] ? "i" : ""}${input.multiline ? "s" : ""}${mode !== "content" ? "" : "g"}`;
+	let regex;
+	try {
+		regex = new RegExp(fallbackSource(input), flags || void 0);
+	} catch (err) {
+		return `grep error: invalid regex: ${errorMessage(err)}`;
+	}
+	const multilineRegex = input.multiline ? new RegExp(regex.source, `${flags.replace(/g/, "")}g`) : void 0;
+	const files = [];
+	for (const root of searchRoots(input)) for (const file of await enumerateFiles(input, root, ctx)) if (!files.includes(file)) files.push(file);
+	const showLineNumbers = input["-n"] ?? true;
+	const before = input["-B"] ?? input["-C"] ?? 0;
+	const after = input["-A"] ?? input["-C"] ?? 0;
+	if (files.length === 1 && searchRoots(input).includes(files[0])) {
+		const size = await ctx.execution.fileSize?.(ctx.handle, files[0]) ?? null;
+		if (size !== null && size > FALLBACK_MAX_FILE_BYTES) return "(no matches)";
+	}
+	const lines = [];
+	for (const path of files) {
+		let content;
+		try {
+			content = await ctx.execution.readFile(ctx.handle, path);
+		} catch (err) {
+			if (isAbortLikeError(err)) throw err;
+			continue;
+		}
+		if (multilineRegex) {
+			const allMatches = [...content.matchAll(multilineRegex)];
+			if (allMatches.length === 0) continue;
+			if (mode === "files_with_matches") {
+				lines.push(path);
+				continue;
+			}
+			if (mode === "count") {
+				lines.push(`${path}:${allMatches.length}`);
+				continue;
+			}
+			let lineNo = 1;
+			let scannedTo = 0;
+			for (const m of allMatches) {
+				const lineStart = content.lastIndexOf("\n", m.index - 1) + 1;
+				const lineEnd = content.indexOf("\n", m.index);
+				const snippet = content.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd);
+				for (let nl = content.indexOf("\n", scannedTo); nl !== -1 && nl < m.index; nl = content.indexOf("\n", nl + 1)) lineNo++;
+				scannedTo = m.index;
+				lines.push(formatContentLine(path, lineNo, snippet, showLineNumbers));
+			}
+			continue;
+		}
+		const fileLines = content.split("\n");
+		const matched = [];
+		for (let i = 0; i < fileLines.length; i++) {
+			regex.lastIndex = 0;
+			if (regex.test(fileLines[i])) matched.push(i);
+		}
+		if (matched.length === 0) continue;
+		if (mode === "files_with_matches") {
+			lines.push(path);
+			continue;
+		}
+		if (mode === "count") {
+			lines.push(`${path}:${matched.length}`);
+			continue;
+		}
+		const includeLineNos = /* @__PURE__ */ new Set();
+		for (const m of matched) for (let i = Math.max(0, m - before); i <= Math.min(fileLines.length - 1, m + after); i++) includeLineNos.add(i);
+		const sorted = [...includeLineNos].sort((a, b) => a - b);
+		let prev = -2;
+		for (const lineNo of sorted) {
+			if (lineNo > prev + 1 && lines.length > 0) lines.push("--");
+			const snippet = fileLines[lineNo];
+			lines.push(formatContentLine(path, lineNo + 1, snippet, showLineNumbers));
+			prev = lineNo;
+		}
+	}
+	return formatPaginated(lines.join("\n"), input);
+}
+function formatContentLine(path, lineNo, snippet, showLineNumbers) {
+	return showLineNumbers ? `${path}:${lineNo}:${snippet}` : `${path}:${snippet}`;
+}
+/**
+* JS regex source for the fallback: patterns OR'ed together, escaped under
+* `fixed_strings`, wrapped in word boundaries under `-w`.
+*/
+function fallbackSource(input) {
+	const parts = allPatterns(input).map((p) => input.fixed_strings ? p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : p);
+	const joined = parts.length === 1 ? parts[0] : parts.map((p) => `(?:${p})`).join("|");
+	return input["-w"] ? `\\b(?:${joined})\\b` : joined;
+}
+async function enumerateFiles(input, root, ctx) {
+	if (root !== "." && !root.includes("*") && !root.includes("?")) {
+		if ((await ctx.execution.exec(ctx.handle, `test -f ${shellQuote(root)} && echo file || echo dir`, { signal: ctx.signal })).stdout.trim() === "file") return [root];
+	}
+	const result = await ctx.execution.exec(ctx.handle, buildFindCommand(root, input.glob), { signal: ctx.signal });
+	if (result.exitCode !== 0 && !result.stdout.trim()) throw new Error(result.stderr.trim() || `find exited with code ${result.exitCode}`);
+	const files = result.stdout.split("\n").map((line) => line.replace(/^\.\//, "")).filter((line) => line.length > 0).sort();
+	if (input.gitignore === false) return files;
+	return filterByGitignore(files, root, ctx);
+}
+/**
+* Best-effort intersection of `files` with `git ls-files` (non-ignored set).
+* Returns `files` unchanged when git is unavailable, the dir isn't a repo, or
+* `root` escapes the repo (absolute / `..`) — the filter can only fail open.
+*/
+async function filterByGitignore(files, root, ctx) {
+	if (files.length === 0) return files;
+	if (root !== "." && (root.startsWith("/") || root.split("/").includes(".."))) return files;
+	try {
+		const res = await ctx.execution.exec(ctx.handle, GIT_LS_FILES_COMMAND, { signal: ctx.signal });
+		if (res.exitCode !== 0) return files;
+		const allowed = new Set(parseGitLsFiles(res.stdout));
+		if (allowed.size === 0) return files;
+		return files.filter((file) => allowed.has(file));
+	} catch {
+		return files;
+	}
+}
+/**
+* Build a `find` command listing files under `root`, optionally filtered by
+* `glob`. Mirrors `glob`'s shell fallback:
+*   - a bare basename, or one behind a leading recursive-wildcard segment,
+*     with no inner slash → `-name` (matches at any depth, including the top
+*     level — preserving the recursive-glob semantics).
+*   - anything with a slash → `-path` against the full relative path. `find`'s
+*     `*` spans `/`, so the single- and double-star forms collapse to the
+*     same matcher; close enough for the no-`rg` fallback.
+*/
+function buildFindCommand(root, glob) {
+	const findRoot = normalizeFindRoot(root);
+	const base = shellQuote(findRoot);
+	const sizeGuard = `! -size +${FALLBACK_MAX_FILE_BYTES}c`;
+	if (!glob) return `find ${base} -type f ${sizeGuard}`;
+	const anyDepth = glob.match(/^(?:\*\*\/)?([^/]+)$/);
+	if (anyDepth) return `find ${base} -type f ${sizeGuard} -name ${shellQuote(anyDepth[1])}`;
+	const normRoot = findRoot.replace(/\/$/, "");
+	const pathPattern = root === "." ? `./${glob}` : `${normRoot}/${glob}`;
+	return `find ${base} -type f ${sizeGuard} -path ${shellQuote(pathPattern)}`;
+}
+function normalizeFindRoot(root) {
+	return root.startsWith("-") ? `./${root}` : root;
+}
+function formatPaginated(text, input) {
+	const headLimit = typeof input.head_limit === "number" && input.head_limit >= 0 ? input.head_limit : DEFAULT_HEAD_LIMIT;
+	const offset = typeof input.offset === "number" && input.offset > 0 ? Math.floor(input.offset) : 0;
+	if (!text.trim()) return "(no matches)";
+	const lines = applyExclude(text.split("\n").filter((l) => l.length > 0), input.exclude);
+	if (lines.length === 0) return "(no matches after exclude)";
+	const total = lines.length;
+	const sliced = headLimit === 0 ? lines.slice(offset) : lines.slice(offset, offset + headLimit);
+	if (sliced.length === 0) return "(no matches in this slice)";
+	const capped = [];
+	let bytesUsed = 0;
+	let byteCut = false;
+	for (const line of sliced) {
+		const clipped = clipLine(line);
+		const lineBytes = Buffer.byteLength(clipped) + 1;
+		if (bytesUsed + lineBytes > OUTPUT_BYTE_CAP && capped.length > 0) {
+			byteCut = true;
+			break;
+		}
+		capped.push(clipped);
+		bytesUsed += lineBytes;
+	}
+	const shown = capped.length;
+	const truncatedHead = offset > 0;
+	const lineCutTail = headLimit > 0 && offset + headLimit < total;
+	let out = capped.join("\n");
+	if (truncatedHead) out = `…(${offset} earlier lines skipped)…\n${out}`;
+	if (byteCut) out = `${out}\n…(output truncated at ${OUTPUT_BYTE_CAP} bytes after ${shown} of ${total - offset} matching lines; narrow the pattern or page with offset=${offset + shown})`;
+	else if (lineCutTail) out = `${out}\n…(${total - offset - headLimit} more lines; re-run with offset=${offset + headLimit} or larger head_limit)`;
+	return out;
+}
+/**
+* Drop output lines matching `exclude` (validated upfront). Context-group
+* `--` separators are kept only between surviving lines, never doubled or at
+* the edges.
+*/
+function applyExclude(lines, exclude) {
+	if (!exclude) return lines;
+	const re = new RegExp(exclude);
+	const kept = [];
+	for (const line of lines) {
+		if (line === "--") {
+			if (kept.length > 0 && kept[kept.length - 1] !== "--") kept.push(line);
+			continue;
+		}
+		if (!re.test(line)) kept.push(line);
+	}
+	while (kept.length > 0 && kept[kept.length - 1] === "--") kept.pop();
+	return kept;
+}
+/**
+* Clip one output line to `MAX_LINE_BYTES` at a UTF-8-safe boundary, appending
+* a marker that reports how many bytes were withheld. Lines within budget pass
+* through untouched.
+*/
+function clipLine(line) {
+	if (Buffer.byteLength(line) <= MAX_LINE_BYTES) return line;
+	let cut = Math.min(line.length, MAX_LINE_BYTES);
+	while (cut > 0 && Buffer.byteLength(line.slice(0, cut)) > MAX_LINE_BYTES) cut--;
+	const omitted = Buffer.byteLength(line) - Buffer.byteLength(line.slice(0, cut));
+	return `${line.slice(0, cut)}… [line clipped, ${omitted} more bytes]`;
+}
+//#endregion
+//#region src/tools/interaction.ts
+function abortReason(signal) {
+	return typeof signal.reason === "string" && signal.reason.length > 0 ? signal.reason : "Interaction aborted";
+}
+/**
+* Create an interaction tool that lets the agent request structured input.
+*
+* The model calls this tool with a payload matching the schema.
+* `onRequest` is called with the payload and should return the response
+* (string or object) that gets sent back to the model as the tool result.
+*/
+function createInteractionTool(options) {
+	return {
+		spec: {
+			name: options.name ?? "interaction",
+			description: options.description ?? toolPrompts.interaction,
+			inputSchema: options.schema
+		},
+		async execute(input, ctx) {
+			const { signal } = ctx;
+			if (signal?.aborted) throw new Error(abortReason(signal));
+			let onAbort;
+			const abortPromise = signal ? new Promise((_, reject) => {
+				onAbort = () => reject(new Error(abortReason(signal)));
+				signal.addEventListener("abort", onAbort, { once: true });
+			}) : void 0;
+			try {
+				const result = abortPromise ? await Promise.race([options.onRequest(input, ctx), abortPromise]) : await options.onRequest(input, ctx);
+				return typeof result === "string" ? result : JSON.stringify(result);
+			} finally {
+				if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+			}
+		}
+	};
+}
+//#endregion
+export { grep as n, glob as r, createInteractionTool as t };
+
+//# sourceMappingURL=tools-_DnT3AGM.js.map