@junando/worker 0.10.1 → 0.11.1

package/dist/node-BzYEGMG1.cjs

@@ -0,0 +1,1177 @@
+const require_rolldown_runtime = require('./rolldown-runtime-CfAboj1T.cjs');
+const require_sdk = require('./sdk-BD78kZ4E.cjs');
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_stream = require("node:stream");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises, 1);
+let node_child_process = require("node:child_process");
+node_child_process = require_rolldown_runtime.__toESM(node_child_process, 1);
+let node_util = require("node:util");
+let node_readline = require("node:readline");
+node_readline = require_rolldown_runtime.__toESM(node_readline, 1);
+let node_stream_promises = require("node:stream/promises");
+
+//#region ../../node_modules/.pnpm/@anthropic-ai+sdk@0.102.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/lib/transform-json-schema.mjs
+const SUPPORTED_STRING_FORMATS = new Set([
+	"date-time",
+	"time",
+	"date",
+	"duration",
+	"email",
+	"hostname",
+	"uri",
+	"ipv4",
+	"ipv6",
+	"uuid"
+]);
+function deepClone(obj) {
+	return JSON.parse(JSON.stringify(obj));
+}
+function transformJSONSchema(jsonSchema) {
+	const workingCopy = deepClone(jsonSchema);
+	return _transformJSONSchema(workingCopy);
+}
+function _transformJSONSchema(jsonSchema) {
+	const strictSchema = {};
+	const ref = require_sdk.pop(jsonSchema, "$ref");
+	if (ref !== undefined) {
+		strictSchema["$ref"] = ref;
+		return strictSchema;
+	}
+	const defs = require_sdk.pop(jsonSchema, "$defs");
+	if (defs !== undefined) {
+		const strictDefs = {};
+		strictSchema["$defs"] = strictDefs;
+		for (const [name, defSchema] of Object.entries(defs)) {
+			strictDefs[name] = _transformJSONSchema(defSchema);
+		}
+	}
+	const type = require_sdk.pop(jsonSchema, "type");
+	const anyOf = require_sdk.pop(jsonSchema, "anyOf");
+	const oneOf = require_sdk.pop(jsonSchema, "oneOf");
+	const allOf = require_sdk.pop(jsonSchema, "allOf");
+	if (Array.isArray(anyOf)) {
+		strictSchema["anyOf"] = anyOf.map((variant) => _transformJSONSchema(variant));
+	} else if (Array.isArray(oneOf)) {
+		strictSchema["anyOf"] = oneOf.map((variant) => _transformJSONSchema(variant));
+	} else if (Array.isArray(allOf)) {
+		strictSchema["allOf"] = allOf.map((entry) => _transformJSONSchema(entry));
+	} else {
+		if (type === undefined) {
+			throw new Error("JSON schema must have a type defined if anyOf/oneOf/allOf are not used");
+		}
+		strictSchema["type"] = type;
+	}
+	const description = require_sdk.pop(jsonSchema, "description");
+	if (description !== undefined) {
+		strictSchema["description"] = description;
+	}
+	const title = require_sdk.pop(jsonSchema, "title");
+	if (title !== undefined) {
+		strictSchema["title"] = title;
+	}
+	if (type === "object") {
+		const properties = require_sdk.pop(jsonSchema, "properties") || {};
+		strictSchema["properties"] = Object.fromEntries(Object.entries(properties).map(([key, propSchema]) => [key, _transformJSONSchema(propSchema)]));
+		require_sdk.pop(jsonSchema, "additionalProperties");
+		strictSchema["additionalProperties"] = false;
+		const required = require_sdk.pop(jsonSchema, "required");
+		if (required !== undefined) {
+			strictSchema["required"] = required;
+		}
+	} else if (type === "string") {
+		const format = require_sdk.pop(jsonSchema, "format");
+		if (format !== undefined && SUPPORTED_STRING_FORMATS.has(format)) {
+			strictSchema["format"] = format;
+		} else if (format !== undefined) {
+			jsonSchema["format"] = format;
+		}
+	} else if (type === "array") {
+		const items = require_sdk.pop(jsonSchema, "items");
+		if (items !== undefined) {
+			strictSchema["items"] = _transformJSONSchema(items);
+		}
+		const minItems = require_sdk.pop(jsonSchema, "minItems");
+		if (minItems !== undefined && (minItems === 0 || minItems === 1)) {
+			strictSchema["minItems"] = minItems;
+		} else if (minItems !== undefined) {
+			jsonSchema["minItems"] = minItems;
+		}
+	}
+	if (Object.keys(jsonSchema).length > 0) {
+		const existingDescription = strictSchema["description"];
+		strictSchema["description"] = (existingDescription ? existingDescription + "\n\n" : "") + "{" + Object.entries(jsonSchema).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ") + "}";
+	}
+	return strictSchema;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@anthropic-ai+sdk@0.102.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/helpers/beta/json-schema.mjs
+/**
+* Creates a Tool with a provided JSON schema that can be passed
+* to the `.toolRunner()` method. The schema is used to automatically validate
+* the input arguments for the tool.
+*/
+function betaTool(options) {
+	if (options.inputSchema.type !== "object") {
+		throw new Error(`JSON schema for tool "${options.name}" must be an object, but got ${options.inputSchema.type}`);
+	}
+	return {
+		type: "custom",
+		name: options.name,
+		input_schema: options.inputSchema,
+		description: options.description,
+		run: options.run,
+		parse: (content) => content,
+		...options.close ? { close: options.close } : {}
+	};
+}
+/**
+* Creates a JSON schema output format object from the given JSON schema.
+* If this is passed to the `.parse()` method then the response message will contain a
+* `.parsed_output` property that is the result of parsing the content with the given JSON schema.
+*
+*/
+function betaJSONSchemaOutputFormat(jsonSchema, options) {
+	if (jsonSchema.type !== "object") {
+		throw new Error(`JSON schema for tool must be an object, but got ${jsonSchema.type}`);
+	}
+	const transform = options?.transform ?? true;
+	if (transform) {
+		jsonSchema = transformJSONSchema(jsonSchema);
+	}
+	return {
+		type: "json_schema",
+		schema: { ...jsonSchema },
+		parse: (content) => {
+			try {
+				return JSON.parse(content);
+			} catch (error) {
+				throw new require_sdk.AnthropicError(`Failed to parse structured output: ${error}`);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@anthropic-ai+sdk@0.102.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/tools/agent-toolset/fs-util.mjs
+/**
+* Shared, Node-only filesystem helpers for the agent toolset's file tools:
+* path confinement (symlink-aware), an atomic write, and language-independent
+* error messages. Kept out of `node.ts` so the tool implementations stay focused
+* and these helpers can be reused by every file tool.
+*/
+/** Mode for directories the file tools create — not world-writable under a 0 umask. */
+const DIR_CREATE_MODE = 493;
+/** Mode for files the file tools create. */
+const FILE_CREATE_MODE = 420;
+/** `realpath` `p`, or return `p` unchanged when it cannot be resolved. */
+async function realpathOrSelf(p) {
+	try {
+		return await node_fs_promises.realpath(p);
+	} catch {
+		return p;
+	}
+}
+/**
+* Fully resolve `abs`: `realpath` the longest existing ancestor and re-append
+* the rest, but never re-append a component that is itself a symlink — read the
+* link and continue from its target instead. This handles paths being created
+* (write/edit) without letting a symlink leaf (e.g. a dangling one pointing
+* outside a confinement root) slip through unresolved.
+*/
+async function canonicalize(abs) {
+	const tail = [];
+	let prefix = abs;
+	for (;;) {
+		let real;
+		try {
+			real = await node_fs_promises.realpath(prefix);
+		} catch {
+			let isLink = false;
+			try {
+				isLink = (await node_fs_promises.lstat(prefix)).isSymbolicLink();
+			} catch {}
+			if (isLink) {
+				prefix = node_path.resolve(node_path.dirname(prefix), await node_fs_promises.readlink(prefix));
+				continue;
+			}
+			const parent = node_path.dirname(prefix);
+			if (parent === prefix) return abs;
+			tail.push(node_path.basename(prefix));
+			prefix = parent;
+			continue;
+		}
+		return tail.length ? node_path.join(real, ...tail.reverse()) : real;
+	}
+}
+/**
+* Resolve `p` and confine it to `root`.
+*
+* Unless `allowOutside` is set, absolute inputs are rejected and the
+* **canonical** path is returned — every symlink in `p` (including the leaf,
+* even a dangling one) is resolved before the confinement check, and the
+* resolved path is what the caller then operates on, so a symlink inside `root`
+* that points outside it can neither pass the check nor be followed afterwards.
+*
+* Residual TOCTOU: a component could still be swapped for a symlink between this
+* call and the eventual `fs` operation. Closing that fully needs per-component
+* `O_NOFOLLOW`/`openat`, which Node does not expose ergonomically; this is why a
+* sandbox is still recommended for the toolset as a whole.
+*/
+async function confineToRoot(root, p, opts) {
+	const allowOutside = opts?.allowOutside ?? false;
+	if (node_path.isAbsolute(p)) {
+		if (!allowOutside) {
+			throw new require_sdk.ToolError(`absolute path ${JSON.stringify(p)} not permitted`);
+		}
+		return node_path.resolve(p);
+	}
+	const realRoot = await realpathOrSelf(node_path.resolve(root));
+	const abs = node_path.resolve(realRoot, p);
+	if (allowOutside) return abs;
+	const real = await canonicalize(abs);
+	const rootSep = realRoot.endsWith(node_path.sep) ? realRoot : realRoot + node_path.sep;
+	if (real !== realRoot && !real.startsWith(rootSep)) {
+		throw new require_sdk.ToolError(`path ${JSON.stringify(p)} escapes workdir`);
+	}
+	return real;
+}
+/**
+* Atomically write `content` to `targetPath`: write a sibling temp file, fsync
+* it, then rename over the target. The rename is atomic on most filesystems, so
+* a crash mid-write never leaves the target half-written.
+*/
+async function atomicWriteFile(targetPath, content) {
+	const dir = node_path.dirname(targetPath);
+	const tempPath = node_path.join(dir, `.tmp-${process.pid}-${(0, node_crypto.randomUUID)()}`);
+	let handle;
+	try {
+		handle = await node_fs_promises.open(tempPath, "wx", 420);
+		await handle.writeFile(content, "utf-8");
+		await handle.sync();
+		await handle.close();
+		handle = undefined;
+		await node_fs_promises.rename(tempPath, targetPath);
+	} catch (err) {
+		if (handle) await handle.close().catch(() => {});
+		await node_fs_promises.unlink(tempPath).catch(() => {});
+		throw err;
+	}
+}
+/**
+* Map a thrown filesystem error to a consistent, language-independent message,
+* so the model sees the same wording regardless of the runtime (Node's raw
+* `ENOENT: no such file...` text would otherwise leak through). Falls back to
+* the raw error message for codes we don't special-case.
+*/
+function fsErrorMessage(err, file) {
+	const code = err?.code;
+	switch (code) {
+		case "ENOENT": return `${file}: no such file or directory`;
+		case "EACCES":
+		case "EPERM": return `${file}: permission denied`;
+		case "ENOTDIR": return `${file}: not a directory`;
+		case "EISDIR": return `${file}: is a directory`;
+		case "ELOOP": return `${file}: too many levels of symbolic links`;
+		case "ENAMETOOLONG": return `${file}: file name too long`;
+		case "ENOSPC": return `${file}: no space left on device`;
+		case "EMFILE":
+		case "ENFILE": return `${file}: too many open files`;
+		default: return `${file}: ${err instanceof Error ? err.message : String(err)}`;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@anthropic-ai+sdk@0.102.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/tools/agent-toolset/skills.mjs
+/**
+* Node-only skill plumbing for the agent toolset: downloading a session
+* agent's skills into the workdir and extracting the archives. Kept in its own
+* file because it is a distinct concern from the tool implementations in
+* `node.ts` — distinct enough, and large enough, to review on its own.
+*/
+const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
+/**
+* Download the session agent's skills into `{ctx.workdir}/skills/<name>/`.
+*
+* No-op (returns a no-op cleanup) unless both `ctx.client` and `ctx.sessionId`
+* are set. Looks up the session's resolved agent and, for each skill, fetches
+* its files via `client.beta.skills.versions.download` and extracts the archive
+* (a zip or tar.* archive) into a directory named after the skill. A failure on
+* one skill is logged and does not block the others. Call this before starting
+* the session tool runner (e.g. right after the bash session / workdir is
+* ready).
+*
+* Returns a cleanup function that removes the skill directories this call
+* created — call it once the work item is done so downloaded skills do not
+* accumulate in the workdir across sessions.
+*/
+async function setupSkills(ctx) {
+	const { client, sessionId } = ctx;
+	if (!client || !sessionId) return async () => {};
+	const log = require_sdk.loggerFor(client);
+	const session = await client.beta.sessions.retrieve(sessionId);
+	const skillsRoot = node_path.resolve(ctx.workdir, "skills");
+	const created = [];
+	for (const skill of session.agent.skills) {
+		try {
+			const versionId = await resolveSkillVersion(client, skill.skill_id, skill.version);
+			const version = await client.beta.skills.versions.retrieve(versionId, { skill_id: skill.skill_id });
+			let dirname = node_path.basename(version.name.trim());
+			if (dirname === "" || dirname === "." || dirname === "..") dirname = skill.skill_id;
+			const dest = node_path.resolve(skillsRoot, dirname);
+			if (dest !== skillsRoot && !dest.startsWith(skillsRoot + node_path.sep)) {
+				log.warn("skill name escapes the skills dir; skipping", {
+					component: "agent-tool-context",
+					name: version.name
+				});
+				continue;
+			}
+			const resp = await client.beta.skills.versions.download(versionId, { skill_id: skill.skill_id });
+			await node_fs_promises.rm(dest, {
+				recursive: true,
+				force: true
+			});
+			await node_fs_promises.mkdir(dest, {
+				recursive: true,
+				mode: 493
+			});
+			created.push(dest);
+			await extractSkillArchive(resp, dest);
+			log.info("downloaded skill", {
+				component: "agent-tool-context",
+				skill_id: skill.skill_id,
+				version: versionId,
+				dest
+			});
+		} catch (e) {
+			log.warn("failed to download skill", {
+				component: "agent-tool-context",
+				skill_id: skill.skill_id,
+				error: String(e)
+			});
+		}
+	}
+	return async () => {
+		for (const dest of created) {
+			await node_fs_promises.rm(dest, {
+				recursive: true,
+				force: true
+			}).catch((e) => {
+				log.warn("failed to clean up skill", {
+					component: "agent-tool-context",
+					dest,
+					error: String(e)
+				});
+			});
+		}
+	};
+}
+/**
+* Resolve `version` to the concrete numeric timestamp the
+* `/v1/skills/{id}/versions/{version}` endpoints require — `session.agent.skills[].version`
+* can be an alias such as `"latest"`, which those endpoints reject. Numeric
+* versions pass through unchanged.
+*/
+async function resolveSkillVersion(client, skillId, version) {
+	if (/^\d+$/.test(version)) return version;
+	let newest;
+	for await (const v of client.beta.skills.versions.list(skillId)) {
+		if (/^\d+$/.test(v.version) && (newest === undefined || BigInt(v.version) > BigInt(newest))) {
+			newest = v.version;
+		}
+	}
+	if (newest === undefined) {
+		throw new require_sdk.AnthropicError(`skill ${JSON.stringify(skillId)} has no concrete version to resolve ${JSON.stringify(version)} against`);
+	}
+	return newest;
+}
+/** Reject archive members that are absolute or contain a `..` component. */
+function assertSafeMemberNames(names) {
+	for (const raw of names.split("\n")) {
+		const entry = raw.trim();
+		if (!entry) continue;
+		if (node_path.isAbsolute(entry) || entry.split(/[\\/]/).includes("..")) {
+			throw new require_sdk.AnthropicError(`refusing to extract unsafe archive member: ${entry}`);
+		}
+	}
+}
+/**
+* Reject archives that contain anything other than regular files and
+* directories. The type char is the first byte of each `ls`-style line emitted
+* by `tar -tvf` / `unzip -Z`: `-` file, `d` dir, `l` symlink, `h` hardlink,
+* `b`/`c` device, `p` fifo, `s` socket. A symlink/hardlink member is how an
+* archive escapes its extraction dir even when no name contains `..`.
+*/
+function assertNoSpecialMembers(verboseListing) {
+	for (const line of verboseListing.split("\n")) {
+		const type = line.trimStart()[0];
+		if (type === "l" || type === "h" || type === "b" || type === "c" || type === "p" || type === "s") {
+			throw new require_sdk.AnthropicError("refusing to extract archive with symlink/hardlink/device member");
+		}
+	}
+}
+/**
+* Run an archive CLI (`unzip` for zip archives, `tar` for everything else),
+* returning its stdout. Both binaries must be on `PATH`; a missing one would
+* otherwise surface as an opaque `ENOENT` spawn failure, so it is turned into a
+* clear, specific error naming the missing command.
+*/
+async function runArchiveTool(cmd, args) {
+	try {
+		const { stdout } = await execFileAsync(cmd, args);
+		return stdout;
+	} catch (e) {
+		if (e != null && typeof e === "object" && e.code === "ENOENT") {
+			throw new require_sdk.AnthropicError(`skill extraction requires the \`${cmd}\` command, but it was not found on PATH`);
+		}
+		throw e;
+	}
+}
+/**
+* The single top-level directory shared by every entry in a newline-separated
+* archive listing, or `''` if entries don't all live under one common
+* directory. Skill bundles are packaged wrapped in one directory named after
+* the skill (e.g. `pdf/SKILL.md`, `pdf/scripts/...`); the extractor strips it
+* so contents land directly in the skill's dir instead of a redundant nested
+* `<skill>/<skill>/` level. A flat or multi-root archive yields `''`.
+*/
+function archiveTopDir(listing) {
+	let top;
+	let nested = false;
+	for (const raw of listing.split("\n")) {
+		const parts = raw.trim().split("/").filter((p) => p !== "" && p !== ".");
+		if (parts.length === 0) continue;
+		const first = parts[0];
+		if (top === undefined) top = first;
+		else if (first !== top) return "";
+		if (parts.length > 1) nested = true;
+	}
+	return top !== undefined && nested ? top : "";
+}
+/**
+* Extract a skill download (a zip or tar.* archive) into `dest`. Streams the
+* response body straight to a temp file beside `dest` (so the whole archive is
+* never buffered in memory — skills can contain large binaries), then shells out
+* to `unzip`/`tar` — consistent with the rest of the toolset, which already
+* invokes `bash` and `rg`. Both `unzip` and `tar` must be available on `PATH`; a
+* missing binary surfaces as a clear error (see {@link runArchiveTool}). Refuses
+* any member that would escape `dest` (zip-slip / tar-slip), including
+* symlink/hardlink members: skill archives come from the API, but skills can be
+* third-party.
+*
+* The skill bundle's single wrapper directory is stripped: the archive is
+* extracted into a staging dir and the wrapper's contents are promoted into
+* `dest`, so files land at `dest/SKILL.md` rather than a doubled
+* `dest/<skill>/SKILL.md` (`unzip` has no `--strip-components`, so this is
+* done uniformly by staging + promote rather than per-tool flags).
+*/
+async function extractSkillArchive(resp, dest) {
+	const tmp = node_path.join(dest, `.skill-archive-${process.pid}-${Date.now()}`);
+	if (!resp.body) {
+		throw new require_sdk.AnthropicError("skill download response had no body");
+	}
+	await (0, node_stream_promises.pipeline)(node_stream.Readable.fromWeb(resp.body), node_fs.createWriteStream(tmp));
+	const stage = node_path.join(node_path.dirname(dest), `.skill-stage-${process.pid}-${Date.now()}`);
+	try {
+		const head = await readHead(tmp, 4);
+		const isZip = head.length >= 4 && head[0] === 80 && head[1] === 75 && head[2] === 3 && head[3] === 4;
+		const archiveCmd = isZip ? "unzip" : "tar";
+		const listing = await runArchiveTool(archiveCmd, isZip ? ["-Z1", tmp] : ["-tf", tmp]);
+		assertSafeMemberNames(listing);
+		assertNoSpecialMembers(await runArchiveTool(archiveCmd, isZip ? ["-Z", tmp] : ["-tvf", tmp]));
+		const top = archiveTopDir(listing);
+		await node_fs_promises.mkdir(stage, {
+			recursive: true,
+			mode: 493
+		});
+		await runArchiveTool(archiveCmd, isZip ? [
+			"-oq",
+			tmp,
+			"-d",
+			stage
+		] : [
+			"-xf",
+			tmp,
+			"-C",
+			stage
+		]);
+		const srcRoot = top ? node_path.join(stage, top) : stage;
+		for (const entry of await node_fs_promises.readdir(srcRoot)) {
+			await node_fs_promises.rename(node_path.join(srcRoot, entry), node_path.join(dest, entry));
+		}
+	} finally {
+		await node_fs_promises.rm(tmp, { force: true });
+		await node_fs_promises.rm(stage, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Read the first `n` bytes of `file`. */
+async function readHead(file, n) {
+	const handle = await node_fs_promises.open(file, "r");
+	try {
+		const buf = Buffer.alloc(n);
+		const { bytesRead } = await handle.read(buf, 0, n, 0);
+		return buf.subarray(0, bytesRead);
+	} finally {
+		await handle.close();
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@anthropic-ai+sdk@0.102.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/tools/agent-toolset/node.mjs
+/**
+* Node implementation of the `agent_toolset_20260401` tools — `bash`, `read`,
+* `write`, `edit`, `glob`, `grep` — plus the workdir/skills
+* {@link AgentToolContext}.
+*
+* This mirrors `@anthropic-ai/sdk/tools/memory/node`: it is the explicit,
+* Node-only entry point for these implementations. Importing it pulls in
+* `node:child_process`, `node:fs`, etc., so it is kept separate from the rest of
+* the SDK — depending on it is an opt-in.
+*
+* **Node 22+ is required** for this module: the `glob` tool uses the native
+* `fs.glob`, added in Node 22. The rest of the SDK still supports Node 18+; only
+* the agent toolset has this requirement.
+*
+* The result of {@link betaAgentToolset20260401} is a plain `BetaRunnableTool[]`;
+* hand it to any tool runner — `client.beta.messages.toolRunner({ …, tools })`
+* for the Messages API, or `client.beta.sessions.events.toolRunner({ …, tools })`
+* for a managed-agents session:
+*
+* ```ts
+* import { betaAgentToolset20260401 } from '@anthropic-ai/sdk/tools/agent-toolset/node';
+*
+* const tools = betaAgentToolset20260401({ workdir: '/work' });
+* const tools2 = betaAgentToolset20260401({ workdir: '/work' }).filter((t) => t.name !== 'bash');
+* ```
+*
+* Trust model: the file tools confine to `workdir` (symlink-aware) and are safe
+* without a sandbox; `bash` is unrestricted and should run inside one. See
+* {@link AgentToolContext}.
+*/
+var _BashSession_instances;
+var _BashSession_proc;
+var _BashSession_buf;
+var _BashSession_truncated;
+var _BashSession_closed;
+var _BashSession_waiting;
+var _BashSession_append;
+const BASH_OUTPUT_LIMIT = 100 * 1024;
+const BASH_DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_MAX_FILE_BYTES = 256 * 1024;
+const GREP_OUTPUT_LIMIT = 100 * 1024;
+const GREP_MAX_LINE_LENGTH = 2e3;
+const GLOB_RESULT_LIMIT = 200;
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+const fsGlob = node_fs_promises.glob;
+function resolveMaxBytes(configured) {
+	return configured === undefined ? DEFAULT_MAX_FILE_BYTES : configured;
+}
+/**
+* Returns the `agent_toolset_20260401` implementations bound to `ctx`. The
+* result is a plain array of `BetaRunnableTool`; filter or extend it before
+* handing it to a tool runner:
+*
+* ```ts
+* const tools = [...betaAgentToolset20260401(ctx), myCustomTool];
+* const tools = betaAgentToolset20260401(ctx).filter((t) => t.name !== 'grep');
+* ```
+*
+* Concurrency note: `client.beta.sessions.events.toolRunner` dispatches a
+* session's tool calls serially (the sessions API delivers one `agent.tool_use`
+* at a time). `client.beta.messages.toolRunner` runs a turn's `tool.run` calls
+* via `Promise.all`. The toolset below is safe under either model —
+* {@link betaBashTool} serializes its persistent shell internally and the FS
+* tools are independent per call — but {@link betaEditTool}/{@link betaWriteTool}
+* cannot synchronize concurrent writes to the *same* file across processes, so a
+* multi-edit turn touching one path is still subject to inherent FS lost-update
+* races. Custom tools that close over mutable state should do their own queueing.
+*/
+function betaAgentToolset20260401(ctx) {
+	return [
+		betaBashTool(ctx),
+		betaReadTool(ctx),
+		betaWriteTool(ctx),
+		betaEditTool(ctx),
+		betaGlobTool(ctx),
+		betaGrepTool(ctx)
+	];
+}
+/**
+* Resolve `p` relative to `ctx.workdir`. Unless `unrestrictedPaths` is set,
+* absolute inputs are rejected and the **canonical** path is returned — every
+* symlink in `p` (including the leaf, even a dangling one) is resolved before
+* the workdir check, and the resolved path is what the tool then operates on, so
+* a symlink inside the workdir that points outside it can neither pass the check
+* nor be followed afterwards. See the trust model on {@link AgentToolContext}.
+*
+* Residual TOCTOU: a component could still be swapped for a symlink between this
+* call and the eventual `fs` operation. Closing that fully needs per-component
+* `O_NOFOLLOW`/`openat`, which Node does not expose ergonomically; the same
+* residual exposure exists in `tools/memory/node` and is why a sandbox is still
+* recommended for the toolset as a whole.
+*/
+function resolvePath(ctx, p) {
+	return confineToRoot(ctx.workdir, p, { allowOutside: ctx.unrestrictedPaths ?? false });
+}
+/**
+* Build the environment for the spawned bash shell. The runner process holds
+* Anthropic credentials in `ANTHROPIC_*` env vars — the API key, the auth token,
+* and the per-work session token among them. `bash` runs an unrestricted shell,
+* so any command the agent runs could read those straight out of `process.env`;
+* strip the whole `ANTHROPIC_*` namespace from the child's environment.
+* Everything else (PATH, HOME, locale, …) is passed through unchanged.
+*
+* Passing an explicit `env` to {@link AgentToolContext} does NOT add to this
+* default — it FULLY REPLACES it. The provided mapping becomes the entire bash
+* environment verbatim; nothing here is merged in, so callers who want the
+* scrubbed process environment plus extras must build that mapping themselves.
+*/
+function scrubbedShellEnv() {
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (key.startsWith("ANTHROPIC_")) continue;
+		env[key] = value;
+	}
+	return env;
+}
+/**
+* A persistent /bin/bash process. State (cwd, env, background jobs) survives
+* across exec() calls. Uses pipes rather than a PTY so input is never echoed.
+*/
+var BashSession = class {
+	constructor(dir, env = scrubbedShellEnv()) {
+		_BashSession_instances.add(this);
+		_BashSession_proc.set(this, void 0);
+		_BashSession_buf.set(this, "");
+		_BashSession_truncated.set(this, false);
+		_BashSession_closed.set(this, false);
+		_BashSession_waiting.set(this, null);
+		require_sdk.__classPrivateFieldSet(this, _BashSession_proc, node_child_process.spawn("/bin/bash", ["--noprofile", "--norc"], {
+			cwd: dir,
+			env: {
+				...env,
+				PS1: "",
+				PS2: "",
+				TERM: "dumb"
+			},
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			detached: true
+		}), "f");
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stdout.setEncoding("utf8");
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stderr.setEncoding("utf8");
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stdout.on("data", (d) => require_sdk.__classPrivateFieldGet(this, _BashSession_instances, "m", _BashSession_append).call(this, d));
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stderr.on("data", (d) => require_sdk.__classPrivateFieldGet(this, _BashSession_instances, "m", _BashSession_append).call(this, d));
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").once("close", () => {
+			require_sdk.__classPrivateFieldSet(this, _BashSession_closed, true, "f");
+			const w = require_sdk.__classPrivateFieldGet(this, _BashSession_waiting, "f");
+			require_sdk.__classPrivateFieldSet(this, _BashSession_waiting, null, "f");
+			w?.resolve();
+		});
+	}
+	/** Whether the underlying shell process has exited. */
+	get closed() {
+		return require_sdk.__classPrivateFieldGet(this, _BashSession_closed, "f");
+	}
+	async exec(command, opts = {}) {
+		if (require_sdk.__classPrivateFieldGet(this, _BashSession_closed, "f")) {
+			throw new require_sdk.AnthropicError("bash session terminated");
+		}
+		const timeoutMs = opts.timeoutMs ?? BASH_DEFAULT_TIMEOUT_MS;
+		const signal = opts.signal;
+		if (signal?.aborted) {
+			throw new require_sdk.AnthropicError("bash command aborted");
+		}
+		require_sdk.__classPrivateFieldSet(this, _BashSession_buf, "", "f");
+		require_sdk.__classPrivateFieldSet(this, _BashSession_truncated, false, "f");
+		const sentinel = `__ANT_CMD_${node_crypto.randomUUID()}_DONE__`;
+		const sentinelSplit = `${sentinel.slice(0, 8)}''${sentinel.slice(8)}`;
+		const wrapped = `{ ${command}\n} </dev/null 2>&1; printf '\\n${sentinelSplit}%d\\n' $?\n`;
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stdin.write(wrapped);
+		if (require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").indexOf(sentinel) < 0) {
+			const { promise: sentinelSeen, resolve } = require_sdk.promiseWithResolvers();
+			require_sdk.__classPrivateFieldSet(this, _BashSession_waiting, {
+				sentinel,
+				resolve
+			}, "f");
+			let timer;
+			let onAbort;
+			try {
+				await Promise.race([
+					sentinelSeen,
+					new Promise((_, reject) => {
+						timer = setTimeout(() => reject(new require_sdk.AnthropicError(`bash command timed out after ${timeoutMs}ms`)), timeoutMs);
+					}),
+					new Promise((_, reject) => {
+						if (!signal) return;
+						onAbort = () => reject(new require_sdk.AnthropicError("bash command aborted"));
+						signal.addEventListener("abort", onAbort, { once: true });
+					})
+				]);
+			} finally {
+				if (timer) clearTimeout(timer);
+				if (onAbort && signal) signal.removeEventListener("abort", onAbort);
+				require_sdk.__classPrivateFieldSet(this, _BashSession_waiting, null, "f");
+			}
+		}
+		const idx = require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").indexOf(sentinel);
+		if (idx < 0) {
+			throw new require_sdk.AnthropicError("bash session terminated");
+		}
+		const tail = require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").slice(idx + sentinel.length);
+		const m = tail.match(/^(-?\d+)/);
+		const exitCode = m ? parseInt(m[1], 10) : -1;
+		let out = require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").slice(0, idx).replace(ANSI_RE, "").replace(/\n+$/, "");
+		if (require_sdk.__classPrivateFieldGet(this, _BashSession_truncated, "f")) {
+			out = `[output truncated]\n${out}`;
+		}
+		return {
+			output: out,
+			exitCode
+		};
+	}
+	close() {
+		if (require_sdk.__classPrivateFieldGet(this, _BashSession_closed, "f")) return;
+		require_sdk.__classPrivateFieldSet(this, _BashSession_closed, true, "f");
+		const w = require_sdk.__classPrivateFieldGet(this, _BashSession_waiting, "f");
+		require_sdk.__classPrivateFieldSet(this, _BashSession_waiting, null, "f");
+		w?.resolve();
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stdout.destroy();
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stderr.destroy();
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").stdin.destroy();
+		try {
+			process.kill(-require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").pid, "SIGKILL");
+		} catch {
+			require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").kill("SIGKILL");
+		}
+		require_sdk.__classPrivateFieldGet(this, _BashSession_proc, "f").unref();
+	}
+};
+_BashSession_proc = new WeakMap(), _BashSession_buf = new WeakMap(), _BashSession_truncated = new WeakMap(), _BashSession_closed = new WeakMap(), _BashSession_waiting = new WeakMap(), _BashSession_instances = new WeakSet(), _BashSession_append = function _BashSession_append(d) {
+	require_sdk.__classPrivateFieldSet(this, _BashSession_buf, require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f") + d, "f");
+	if (require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").length > BASH_OUTPUT_LIMIT) {
+		require_sdk.__classPrivateFieldSet(this, _BashSession_buf, require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").slice(require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").length - BASH_OUTPUT_LIMIT), "f");
+		require_sdk.__classPrivateFieldSet(this, _BashSession_truncated, true, "f");
+	}
+	if (require_sdk.__classPrivateFieldGet(this, _BashSession_waiting, "f") && require_sdk.__classPrivateFieldGet(this, _BashSession_buf, "f").indexOf(require_sdk.__classPrivateFieldGet(this, _BashSession_waiting, "f").sentinel) >= 0) {
+		const w = require_sdk.__classPrivateFieldGet(this, _BashSession_waiting, "f");
+		require_sdk.__classPrivateFieldSet(this, _BashSession_waiting, null, "f");
+		w.resolve();
+	}
+};
+function betaBashTool(ctx) {
+	let session;
+	let tail = Promise.resolve();
+	return betaTool({
+		name: "bash",
+		description: "Run a bash command in a persistent shell. State (cwd, env vars) persists across calls.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				command: {
+					type: "string",
+					description: "The command to run"
+				},
+				restart: {
+					type: "boolean",
+					description: "Restart the persistent shell before running"
+				},
+				timeout_ms: {
+					type: "integer",
+					description: "Per-call timeout in milliseconds"
+				}
+			}
+		},
+		run: async ({ command, restart, timeout_ms }, context) => {
+			const prev = tail;
+			const gate = require_sdk.promiseWithResolvers();
+			tail = gate.promise;
+			try {
+				await prev;
+			} catch {}
+			try {
+				if (restart) {
+					session?.close();
+					session = undefined;
+				}
+				if (!command) {
+					if (restart) return "bash session restarted";
+					throw new require_sdk.ToolError("bash: command is required");
+				}
+				session ?? (session = new BashSession(ctx.workdir, ctx.env));
+				try {
+					const { output, exitCode } = await session.exec(command, {
+						timeoutMs: timeout_ms ?? BASH_DEFAULT_TIMEOUT_MS,
+						signal: context?.signal
+					});
+					if (exitCode !== 0) throw new require_sdk.ToolError(output || `exit ${exitCode}`);
+					return output;
+				} catch (e) {
+					if (e instanceof require_sdk.ToolError) throw e;
+					session.close();
+					session = undefined;
+					throw new require_sdk.ToolError(`bash: ${e instanceof Error ? e.message : String(e)}`);
+				}
+			} finally {
+				gate.resolve();
+			}
+		},
+		close: () => {
+			session?.close();
+			session = undefined;
+		}
+	});
+}
+function betaReadTool(ctx) {
+	return betaTool({
+		name: "read",
+		description: "Read a UTF-8 text file relative to the workdir.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				file_path: { type: "string" },
+				view_range: {
+					type: "array",
+					items: { type: "integer" },
+					description: "[start_line, end_line] 1-indexed inclusive"
+				}
+			},
+			required: ["file_path"]
+		},
+		run: async ({ file_path, view_range }) => {
+			if (!file_path) throw new require_sdk.ToolError("read: file_path is required");
+			const abs = await resolvePath(ctx, file_path);
+			let data;
+			try {
+				const st = await node_fs_promises.stat(abs);
+				if (!st.isFile()) {
+					throw new require_sdk.ToolError(`read: ${file_path} is not a regular file`);
+				}
+				const limit = resolveMaxBytes(ctx.maxFileBytes);
+				if (limit !== null && st.size > limit) {
+					throw new require_sdk.ToolError(`read: ${file_path} is ${st.size} bytes, exceeds ${limit}-byte limit. ` + "Use bash (head/tail/sed) to read a slice.");
+				}
+				data = await node_fs_promises.readFile(abs, "utf8");
+			} catch (e) {
+				if (e instanceof require_sdk.ToolError) throw e;
+				throw new require_sdk.ToolError(`read: ${fsErrorMessage(e, file_path)}`);
+			}
+			if (!view_range) return data;
+			if (view_range.length !== 2) throw new require_sdk.ToolError("read: view_range must be [start_line, end_line]");
+			const [startLine, endLine] = view_range;
+			const lines = data.split("\n");
+			const start = Math.max(0, startLine - 1);
+			const end = endLine > 0 ? endLine : lines.length;
+			return lines.slice(start, end).join("\n");
+		}
+	});
+}
+function betaWriteTool(ctx) {
+	return betaTool({
+		name: "write",
+		description: "Write a UTF-8 text file relative to the workdir, creating parent directories as needed.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				file_path: { type: "string" },
+				content: { type: "string" }
+			},
+			required: ["file_path", "content"]
+		},
+		run: async ({ file_path, content }) => {
+			if (!file_path) throw new require_sdk.ToolError("write: file_path is required");
+			const abs = await resolvePath(ctx, file_path);
+			try {
+				await node_fs_promises.mkdir(node_path.dirname(abs), {
+					recursive: true,
+					mode: 493
+				});
+				await atomicWriteFile(abs, content ?? "");
+			} catch (e) {
+				throw new require_sdk.ToolError(`write: ${fsErrorMessage(e, file_path)}`);
+			}
+			return `wrote ${Buffer.byteLength(content ?? "")} bytes to ${file_path}`;
+		}
+	});
+}
+function betaEditTool(ctx) {
+	return betaTool({
+		name: "edit",
+		description: "Replace old_string with new_string in a file. old_string must be unique unless replace_all.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				file_path: { type: "string" },
+				old_string: { type: "string" },
+				new_string: { type: "string" },
+				replace_all: { type: "boolean" }
+			},
+			required: [
+				"file_path",
+				"old_string",
+				"new_string"
+			]
+		},
+		run: async ({ file_path, old_string, new_string, replace_all }) => {
+			if (!file_path) throw new require_sdk.ToolError("edit: file_path is required");
+			if (!old_string) throw new require_sdk.ToolError("edit: old_string is required");
+			const abs = await resolvePath(ctx, file_path);
+			let data;
+			try {
+				const st = await node_fs_promises.stat(abs);
+				if (!st.isFile()) {
+					throw new require_sdk.ToolError(`edit: ${file_path} is not a regular file`);
+				}
+				const limit = resolveMaxBytes(ctx.maxFileBytes);
+				if (limit !== null && st.size > limit) {
+					throw new require_sdk.ToolError(`edit: ${file_path} is ${st.size} bytes, exceeds ${limit}-byte limit. ` + "Use bash (sed/awk) to edit a large file.");
+				}
+				data = await node_fs_promises.readFile(abs, "utf8");
+			} catch (e) {
+				if (e instanceof require_sdk.ToolError) throw e;
+				throw new require_sdk.ToolError(`edit: ${fsErrorMessage(e, file_path)}`);
+			}
+			const count = data.split(old_string).length - 1;
+			if (count === 0) throw new require_sdk.ToolError(`edit: old_string not found in ${file_path}`);
+			let updated;
+			if (replace_all) {
+				updated = data.split(old_string).join(new_string);
+			} else {
+				if (count > 1) throw new require_sdk.ToolError(`edit: old_string appears ${count} times in ${file_path} (must be unique)`);
+				updated = data.replace(old_string, () => new_string);
+			}
+			try {
+				await atomicWriteFile(abs, updated);
+			} catch (e) {
+				throw new require_sdk.ToolError(`edit: write: ${fsErrorMessage(e, file_path)}`);
+			}
+			return `edited ${file_path} (${replace_all ? count : 1} replacement(s))`;
+		}
+	});
+}
+function betaGlobTool(ctx) {
+	return betaTool({
+		name: "glob",
+		description: "Match files under the workdir against a glob pattern. Results are mtime-sorted, newest first.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				pattern: { type: "string" },
+				path: {
+					type: "string",
+					description: "Directory to search in. Defaults to the workdir."
+				}
+			},
+			required: ["pattern"]
+		},
+		run: async ({ pattern, path: searchPath }) => {
+			if (!pattern) throw new require_sdk.ToolError("glob: pattern is required");
+			let root = node_path.resolve(ctx.workdir);
+			let pat = pattern;
+			if (node_path.isAbsolute(pattern)) {
+				if (!ctx.unrestrictedPaths) throw new require_sdk.ToolError("glob: absolute pattern not permitted");
+				root = node_path.parse(pattern).root;
+				pat = node_path.relative(root, pattern);
+			} else if (searchPath) {
+				root = await resolvePath(ctx, searchPath);
+			}
+			if (!ctx.unrestrictedPaths && pat.split(/[\\/]/).includes("..")) {
+				throw new require_sdk.ToolError("glob: \"..\" is not permitted in the pattern");
+			}
+			const matches = [];
+			try {
+				for await (const entry of fsGlob(pat, {
+					cwd: root,
+					withFileTypes: true,
+					exclude: (d) => d.name === ".git" || d.name === "node_modules"
+				})) {
+					if (!entry.isFile()) continue;
+					const full = node_path.join(entry.parentPath, entry.name);
+					if (!ctx.unrestrictedPaths && !isWithin(root, full)) continue;
+					let mtime = 0;
+					try {
+						mtime = (await node_fs_promises.stat(full)).mtimeMs;
+					} catch {}
+					matches.push({
+						path: full,
+						mtime
+					});
+				}
+			} catch (e) {
+				throw new require_sdk.ToolError(`glob: ${e instanceof Error ? e.message : String(e)}`);
+			}
+			if (matches.length === 0) return "no matches";
+			matches.sort((a, b) => b.mtime - a.mtime);
+			return matches.slice(0, GLOB_RESULT_LIMIT).map((m) => m.path).join("\n");
+		}
+	});
+}
+function betaGrepTool(ctx) {
+	return betaTool({
+		name: "grep",
+		description: "Search file contents for a regex. Uses ripgrep if available, otherwise a built-in walker.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				pattern: { type: "string" },
+				path: { type: "string" }
+			},
+			required: ["pattern"]
+		},
+		run: async ({ pattern, path: p }, context) => {
+			if (!pattern) throw new require_sdk.ToolError("grep: pattern is required");
+			let searchPath = node_path.resolve(ctx.workdir);
+			if (p) searchPath = await resolvePath(ctx, p);
+			const rg = await findRg();
+			return rg ? runRipgrep(rg, pattern, searchPath, context?.signal) : runWalkGrep(pattern, searchPath, context?.signal);
+		}
+	});
+}
+function runRipgrep(rg, pattern, searchPath, signal) {
+	return new Promise((resolve, reject) => {
+		const proc = node_child_process.spawn(rg, [
+			"-n",
+			"--no-heading",
+			"-e",
+			pattern,
+			"--",
+			searchPath
+		], { ...signal ? { signal } : {} });
+		let out = "";
+		let errOut = "";
+		let truncated = false;
+		proc.stdout.on("data", (d) => {
+			if (truncated) return;
+			out += d;
+			if (out.length > GREP_OUTPUT_LIMIT) {
+				truncated = true;
+				out = out.slice(0, GREP_OUTPUT_LIMIT);
+				proc.kill("SIGKILL");
+			}
+		});
+		proc.stderr.on("data", (d) => errOut += d);
+		proc.on("close", (code) => {
+			if (signal?.aborted) return reject(new require_sdk.ToolError("grep: aborted"));
+			if (truncated) return resolve(out + `\n[output truncated at ${GREP_OUTPUT_LIMIT} bytes]`);
+			if (code === 0) return resolve(out);
+			if (code === 1) return resolve("no matches");
+			reject(new require_sdk.ToolError(`grep: rg failed: ${errOut || `exit ${code}`}`));
+		});
+		proc.on("error", (e) => {
+			if (signal?.aborted) return reject(new require_sdk.ToolError("grep: aborted"));
+			reject(new require_sdk.ToolError(`grep: rg failed: ${e.message}`));
+		});
+	});
+}
+async function runWalkGrep(pattern, root, signal) {
+	let re;
+	try {
+		re = new RegExp(pattern);
+	} catch (e) {
+		throw new require_sdk.ToolError(`grep: invalid regex: ${e instanceof Error ? e.message : String(e)}`);
+	}
+	const hits = [];
+	let budget = GREP_OUTPUT_LIMIT;
+	const push = (line) => {
+		budget -= line.length + 1;
+		if (budget < 0) {
+			hits.push(`[output truncated at ${GREP_OUTPUT_LIMIT} bytes]`);
+			return false;
+		}
+		hits.push(line);
+		return true;
+	};
+	const stat = await node_fs_promises.stat(root).catch(() => null);
+	if (stat?.isFile()) {
+		await grepFile(root, re, push);
+	} else {
+		await walk(root, "", (rel) => grepFile(node_path.join(root, rel), re, push), signal);
+	}
+	if (signal?.aborted) throw new require_sdk.ToolError("grep: aborted");
+	if (hits.length === 0) return "no matches";
+	return hits.join("\n");
+}
+async function grepFile(file, re, push) {
+	const stream = node_fs.createReadStream(file, { encoding: "utf8" });
+	const rl = node_readline.createInterface({
+		input: stream,
+		crlfDelay: Infinity
+	});
+	let i = 0;
+	try {
+		for await (const line of rl) {
+			i++;
+			if (line.length > GREP_MAX_LINE_LENGTH) continue;
+			if (re.test(line) && !push(`${file}:${i}:${line}`)) return false;
+		}
+	} catch {} finally {
+		stream.destroy();
+	}
+	return true;
+}
+/** True when `p` is `root` itself or lexically contained within it. */
+function isWithin(root, p) {
+	const rel = node_path.relative(root, p);
+	return rel === "" || !rel.startsWith(".." + node_path.sep) && rel !== ".." && !node_path.isAbsolute(rel);
+}
+const WALK_MAX_DEPTH = 40;
+const WALK_MAX_ENTRIES = 5e4;
+/**
+* Bounded recursive walk. `fn` may return `false` to abort. Only real
+* directories are descended into and only real files are handed to `fn` —
+* symlinks (and devices/fifos/sockets) are skipped entirely so a symlink inside
+* the root cannot be followed out of it.
+*/
+async function walk(root, rel, fn, signal) {
+	let remaining = WALK_MAX_ENTRIES;
+	async function inner(rel, depth) {
+		if (depth > WALK_MAX_DEPTH) return true;
+		if (signal?.aborted) return false;
+		let entries;
+		try {
+			entries = await node_fs_promises.readdir(node_path.join(root, rel), { withFileTypes: true });
+		} catch {
+			return true;
+		}
+		for (const e of entries) {
+			if (e.name === ".git" || e.name === "node_modules") continue;
+			if (remaining-- <= 0) return false;
+			if (signal?.aborted) return false;
+			const childRel = rel ? node_path.join(rel, e.name) : e.name;
+			if (e.isDirectory()) {
+				if (!await inner(childRel, depth + 1)) return false;
+			} else if (e.isFile()) {
+				if (await fn(childRel) === false) return false;
+			}
+		}
+		return true;
+	}
+	await inner(rel, 0);
+}
+async function findRg() {
+	const dirs = (process.env["PATH"] ?? "").split(node_path.delimiter);
+	for (const d of dirs) {
+		const candidate = node_path.join(d, "rg");
+		try {
+			await node_fs_promises.access(candidate, node_fs.constants.X_OK);
+			return candidate;
+		} catch {}
+	}
+	return null;
+}
+
+//#endregion
+exports.betaAgentToolset20260401 = betaAgentToolset20260401;
+exports.setupSkills = setupSkills;