@5ss/ai-tools 2.11.1

package/dist/modules/files/index.js

@@ -0,0 +1,733 @@
+import { t as ToolError } from "../../errors-DoSpNHvs.js";
+import { n as defineModule, r as defineTool } from "../../define-CvpJ_pNP.js";
+import { n as requireAuth } from "../../provider-CgDAlg6K.js";
+import { t as artifactRefSchema } from "../../artifact-D064mHfK.js";
+import { n as bytesToBase64, r as bytesToUtf8 } from "../../bytes-BxpimpQx.js";
+import { m as s3AuthSchema, p as S3Client } from "../../s3-CsOaPWMP.js";
+import { z } from "zod";
+//#region src/modules/files/contracts.ts
+/** Max bytes for a single range read through files tools. */
+const MAX_FILES_RANGE_BYTES = 8 * 1024 * 1024;
+/** Max lines for files-read-lines. */
+const MAX_FILES_READ_LINES = 2e3;
+/** Max UTF-8 bytes scanned for line reads. */
+const MAX_FILES_LINES_SCAN_BYTES = 2 * 1024 * 1024;
+const filesAuthSchema = z.object({
+	root_prefix: z.string().min(1).describe("Object key prefix for this workspace, for example orgs/acme/files/ (no leading slash)"),
+	storage: s3AuthSchema.describe("S3-compatible object storage credentials (AWS S3, R2 S3 endpoint, MinIO, …) for this workspace")
+});
+const fileItemSchema = z.object({
+	path: z.string().describe("Path relative to the bound root_prefix"),
+	kind: z.enum(["file", "folder"]).describe("Object file or common-prefix folder"),
+	size: z.number().optional().describe("Byte size when kind is file and known"),
+	last_modified: z.string().optional().describe("Last-modified timestamp when known"),
+	etag: z.string().optional().describe("ETag when known"),
+	media_type: z.string().optional().describe("Content-Type when known from head")
+});
+const filesListInputSchema = z.object({
+	path: z.string().optional().describe("Relative folder path under root (no leading slash). Omit for workspace root"),
+	cursor: z.string().min(1).optional().describe("Pagination cursor from a prior list call"),
+	limit: z.int().min(1).max(1e3).optional().describe("Maximum items to return (1-1000)")
+});
+const filesListOutputSchema = z.object({
+	items: z.array(fileItemSchema),
+	next_cursor: z.string().optional().describe("Pass as cursor for the next page"),
+	truncated: z.boolean()
+});
+const filesSearchInputSchema = z.object({
+	query: z.string().min(1).max(200).describe("Literal name fragment to match against the last path segment (not full-text content)"),
+	path: z.string().optional().describe("Optional relative folder to search under. Omit to search the whole root prefix"),
+	cursor: z.string().min(1).optional().describe("Pagination cursor from a prior search call"),
+	limit: z.int().min(1).max(1e3).optional().describe("Maximum items to scan/return (1-1000)")
+});
+const filesSearchOutputSchema = z.object({
+	items: z.array(fileItemSchema),
+	next_cursor: z.string().optional(),
+	truncated: z.boolean()
+});
+const filesStatInputSchema = z.object({ path: z.string().min(1).describe("Relative file path under root (no leading slash)") });
+const filesStatOutputSchema = z.object({
+	exists: z.boolean(),
+	item: fileItemSchema.optional()
+});
+const filesGetInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root"),
+	encoding: z.enum(["base64", "utf8"]).optional().describe("Body encoding. Defaults to base64")
+});
+const filesGetOutputSchema = z.object({
+	path: z.string(),
+	body: z.string().describe("File body encoded per encoding"),
+	encoding: z.enum(["base64", "utf8"]),
+	content_type: z.string().optional(),
+	content_length: z.number().optional()
+});
+const filesGetRangeInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root"),
+	start_byte: z.int().min(0).describe("Inclusive start byte offset"),
+	end_byte: z.int().min(0).describe(`Inclusive end byte offset (range size max ${MAX_FILES_RANGE_BYTES} bytes)`),
+	encoding: z.enum(["base64", "utf8"]).optional().describe("Body encoding. Defaults to base64")
+});
+const filesGetRangeOutputSchema = z.object({
+	path: z.string(),
+	body: z.string().describe("Range body encoded per encoding"),
+	encoding: z.enum(["base64", "utf8"]),
+	start_byte: z.number().int().nonnegative(),
+	end_byte: z.number().int().nonnegative(),
+	total_bytes: z.number().int().nonnegative().optional().describe("Full object size when known"),
+	content_type: z.string().optional()
+});
+const filesReadLinesInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root (UTF-8 text)"),
+	start_line: z.int().min(1).optional().describe("1-based start line (default 1)"),
+	max_lines: z.int().min(1).max(MAX_FILES_READ_LINES).optional().describe(`Max lines to return (default 200, max ${MAX_FILES_READ_LINES})`)
+});
+const filesReadLinesOutputSchema = z.object({
+	path: z.string(),
+	start_line: z.number().int().positive(),
+	lines: z.array(z.string()),
+	truncated: z.boolean().describe("True when more lines may exist after this page"),
+	next_start_line: z.number().int().positive().optional().describe("Pass as start_line for the next page")
+});
+const filesCreateArtifactInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root to expose as ArtifactRef"),
+	filename: z.string().min(1).optional().describe("Display filename on the ArtifactRef"),
+	media_type: z.string().min(1).optional().describe("MIME type override (defaults from head when known)")
+});
+const filesCreateArtifactOutputSchema = z.object({
+	path: z.string(),
+	artifact: artifactRefSchema.describe("Object-store ArtifactRef for the same object (logical key under storage key_prefix + root_prefix)")
+});
+const filesPutInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root to write or replace"),
+	body: z.string().describe("File body as utf8 text or base64 (see body_encoding)"),
+	body_encoding: z.enum(["utf8", "base64"]).optional().describe("How to interpret body. Defaults to utf8"),
+	content_type: z.string().optional().describe("Content-Type to store")
+});
+const filesPutOutputSchema = z.object({
+	path: z.string(),
+	content_length: z.number(),
+	etag: z.string().optional()
+});
+const filesDeleteInputSchema = z.object({ path: z.string().min(1).describe("Relative file path under root to delete") });
+const filesDeleteOutputSchema = z.object({
+	path: z.string(),
+	deleted: z.boolean()
+});
+const filesCopyInputSchema = z.object({
+	source_path: z.string().min(1).describe("Relative source path under root"),
+	destination_path: z.string().min(1).describe("Relative destination path under root")
+});
+const filesCopyOutputSchema = z.object({
+	source_path: z.string(),
+	destination_path: z.string(),
+	etag: z.string().optional()
+});
+const filesMkdirInputSchema = z.object({ path: z.string().min(1).describe("Relative folder path under root. Creates a marker object so the prefix is listable") });
+const filesMkdirOutputSchema = z.object({
+	path: z.string(),
+	created: z.boolean()
+});
+const filesMoveInputSchema = z.object({
+	source_path: z.string().min(1).describe("Relative source path under root to move from"),
+	destination_path: z.string().min(1).describe("Relative destination path under root to move to")
+});
+const filesMoveOutputSchema = z.object({
+	source_path: z.string(),
+	destination_path: z.string(),
+	etag: z.string().optional().describe("ETag of the destination object after copy")
+});
+const filesMultipartStartInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root for the multipart upload"),
+	content_type: z.string().optional().describe("Content-Type stored on the completed object")
+});
+const filesMultipartStartOutputSchema = z.object({
+	path: z.string(),
+	upload_id: z.string().min(1).describe("Upload id for subsequent part/complete/abort calls")
+});
+const filesMultipartUploadPartInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root for the in-progress multipart upload"),
+	upload_id: z.string().min(1).describe("Upload id from files-multipart-start"),
+	part_number: z.int().min(1).max(1e4).describe("Part number (1-10000)"),
+	body: z.string().describe("Part body as utf8 text or base64 (see body_encoding)"),
+	body_encoding: z.enum(["utf8", "base64"]).optional().describe("How to interpret body. Defaults to utf8")
+});
+const filesMultipartUploadPartOutputSchema = z.object({
+	path: z.string(),
+	upload_id: z.string(),
+	part_number: z.int(),
+	etag: z.string().min(1).describe("Part ETag required when completing the multipart upload"),
+	content_length: z.number()
+});
+const filesMultipartPartSchema = z.object({
+	part_number: z.int().min(1).max(1e4).describe("Uploaded part number from files-multipart-upload-part"),
+	etag: z.string().min(1).describe("ETag returned by files-multipart-upload-part")
+});
+const filesMultipartCompleteInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root for the in-progress multipart upload"),
+	upload_id: z.string().min(1).describe("Upload id from files-multipart-start"),
+	parts: z.array(filesMultipartPartSchema).min(1).max(1e4).describe("Uploaded parts with part_number and etag (any order; sorted before complete)")
+});
+const filesMultipartCompleteOutputSchema = z.object({
+	path: z.string(),
+	upload_id: z.string(),
+	etag: z.string().optional()
+});
+const filesMultipartAbortInputSchema = z.object({
+	path: z.string().min(1).describe("Relative file path under root for the in-progress multipart upload"),
+	upload_id: z.string().min(1).describe("Upload id from files-multipart-start")
+});
+const filesMultipartAbortOutputSchema = z.object({
+	path: z.string(),
+	upload_id: z.string(),
+	aborted: z.boolean()
+});
+//#endregion
+//#region src/modules/files/path.ts
+/** Reject path segments that are parent references; allow names like `report..final.pdf`. */
+function assertNoParentSegments(segments, code) {
+	for (const segment of segments) if (segment === "..") throw new ToolError(code === "bad_auth" ? "root_prefix must not contain parent-directory segments" : "Path must not contain parent-directory segments", { code });
+}
+/** Normalize root to a non-absolute prefix that always ends with `/`. */
+function normalizeRootPrefix(rootPrefix) {
+	let root = rootPrefix.trim().replaceAll("\\", "/");
+	if (root.startsWith("/")) throw new ToolError("root_prefix must not be absolute (no leading /)", { code: "bad_auth" });
+	root = root.replace(/\/+/g, "/");
+	const segments = root.split("/").filter((segment) => segment.length > 0 && segment !== ".");
+	assertNoParentSegments(segments, "bad_auth");
+	if (segments.length === 0) throw new ToolError("root_prefix must not be empty", { code: "bad_auth" });
+	return `${segments.join("/")}/`;
+}
+/** Resolve a model-facing relative key under root. Rejects escapes. */
+function resolveUnderRoot(root, relativePath) {
+	const rel = relativePath.trim().replaceAll("\\", "/").replace(/^\/+/, "");
+	if (rel.length === 0) throw new ToolError("Path must not be empty", { code: "bad_input" });
+	if (rel.startsWith("/")) throw new ToolError("Invalid path", { code: "bad_input" });
+	const segments = rel.split("/").filter((segment) => segment.length > 0 && segment !== ".");
+	assertNoParentSegments(segments, "bad_input");
+	if (segments.length === 0) throw new ToolError("Path must not be empty", { code: "bad_input" });
+	return `${root}${segments.join("/")}`;
+}
+/** Prefix for listing (relative folder path, may be empty for root). */
+function resolveListPrefix(root, relativePath) {
+	if (!relativePath || !relativePath.trim()) return root;
+	const segments = relativePath.trim().replaceAll("\\", "/").replace(/^\/+/, "").replace(/\/+$/, "").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+	assertNoParentSegments(segments, "bad_input");
+	if (segments.length === 0) return root;
+	return `${root}${segments.join("/")}/`;
+}
+/** Map absolute object key back to relative, or undefined if outside root. */
+function toRelativeKey(root, absoluteKey) {
+	if (!absoluteKey.startsWith(root)) return void 0;
+	return absoluteKey.slice(root.length);
+}
+function basename(relativeKey) {
+	const parts = relativeKey.replace(/\/+$/, "").split("/");
+	return parts[parts.length - 1] ?? relativeKey;
+}
+//#endregion
+//#region src/modules/files/client.ts
+/**
+* Files client — path-rooted workspace over S3Client.
+* Host: withAuth + fromContext. Tools stay thin adapters.
+*/
+function transportOptions(ctx) {
+	return {
+		...ctx.fetch && { fetch: ctx.fetch },
+		...ctx.signal && { signal: ctx.signal }
+	};
+}
+var FilesClient = class FilesClient {
+	#s3;
+	#root;
+	constructor(auth, ctx = {}) {
+		const parsed = filesAuthSchema.safeParse(auth);
+		if (!parsed.success) throw new ToolError("Invalid files auth credentials", {
+			code: "bad_auth",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		this.#root = normalizeRootPrefix(parsed.data.root_prefix);
+		this.#s3 = new S3Client(parsed.data.storage, transportOptions(ctx));
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, filesAuthSchema);
+		return new FilesClient(auth, ctx);
+	}
+	static fromAuth(auth, ctx = {}) {
+		return new FilesClient(auth, ctx);
+	}
+	async list(input) {
+		const prefix = resolveListPrefix(this.#root, input.path);
+		const listed = await this.#s3.list({
+			prefix,
+			delimiter: "/",
+			...input.cursor && { cursor: input.cursor },
+			...input.limit !== void 0 && { limit: input.limit }
+		});
+		const items = [];
+		for (const obj of listed.items) {
+			const rel = toRelativeKey(this.#root, obj.key);
+			if (!rel) continue;
+			items.push({
+				path: rel,
+				kind: "file",
+				...obj.size !== void 0 && { size: obj.size },
+				...obj.last_modified && { last_modified: obj.last_modified },
+				...obj.etag && { etag: obj.etag }
+			});
+		}
+		if (listed.common_prefixes) for (const folderAbs of listed.common_prefixes) {
+			const rel = toRelativeKey(this.#root, folderAbs.endsWith("/") ? folderAbs.slice(0, -1) : folderAbs);
+			if (!rel) continue;
+			const folderPath = folderAbs.endsWith("/") ? toRelativeKey(this.#root, folderAbs.slice(0, -1)) ?? rel : rel;
+			items.push({
+				path: folderPath.endsWith("/") ? folderPath.slice(0, -1) : folderPath,
+				kind: "folder"
+			});
+		}
+		return filesListOutputSchema.parse({
+			items,
+			truncated: listed.truncated,
+			...listed.next_cursor && { next_cursor: listed.next_cursor }
+		});
+	}
+	async search(input) {
+		const prefix = resolveListPrefix(this.#root, input.path);
+		const listed = await this.#s3.list({
+			prefix,
+			...input.cursor && { cursor: input.cursor },
+			...input.limit !== void 0 && { limit: input.limit }
+		});
+		const needle = input.query.toLowerCase();
+		const items = [];
+		for (const obj of listed.items) {
+			const rel = toRelativeKey(this.#root, obj.key);
+			if (!rel) continue;
+			if (!basename(rel).toLowerCase().includes(needle)) continue;
+			items.push({
+				path: rel,
+				kind: "file",
+				...obj.size !== void 0 && { size: obj.size },
+				...obj.last_modified && { last_modified: obj.last_modified },
+				...obj.etag && { etag: obj.etag }
+			});
+		}
+		return filesSearchOutputSchema.parse({
+			items,
+			truncated: listed.truncated,
+			...listed.next_cursor && { next_cursor: listed.next_cursor }
+		});
+	}
+	async stat(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const head = await this.#s3.head({ key: absolute });
+		if (!head.exists) return filesStatOutputSchema.parse({ exists: false });
+		const rel = toRelativeKey(this.#root, head.key) ?? input.path;
+		return filesStatOutputSchema.parse({
+			exists: true,
+			item: {
+				path: rel,
+				kind: "file",
+				...head.content_length !== void 0 && { size: head.content_length },
+				...head.etag && { etag: head.etag },
+				...head.content_type && { media_type: head.content_type }
+			}
+		});
+	}
+	async get(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const got = await this.#s3.get({
+			key: absolute,
+			...input.encoding && { encoding: input.encoding }
+		});
+		return filesGetOutputSchema.parse({
+			path: input.path,
+			body: got.body,
+			encoding: got.encoding,
+			...got.content_type && { content_type: got.content_type },
+			...got.content_length !== void 0 && { content_length: got.content_length }
+		});
+	}
+	async getRange(input) {
+		if (input.end_byte < input.start_byte) throw new ToolError("end_byte must be >= start_byte", { code: "bad_input" });
+		const rangeSize = input.end_byte - input.start_byte + 1;
+		if (rangeSize > 8388608) throw new ToolError(`Byte range exceeds max of ${MAX_FILES_RANGE_BYTES} bytes`, {
+			code: "too_large",
+			details: {
+				max_bytes: MAX_FILES_RANGE_BYTES,
+				requested_bytes: rangeSize
+			}
+		});
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const range = await this.#s3.getBytesRange(absolute, {
+			start_byte: input.start_byte,
+			end_byte: input.end_byte
+		});
+		const encoding = input.encoding ?? "base64";
+		const body = encoding === "utf8" ? bytesToUtf8(range.bytes) : bytesToBase64(range.bytes);
+		return filesGetRangeOutputSchema.parse({
+			path: input.path,
+			body,
+			encoding,
+			start_byte: range.start_byte,
+			end_byte: range.end_byte,
+			...range.total_bytes !== void 0 && { total_bytes: range.total_bytes },
+			...range.content_type && { content_type: range.content_type }
+		});
+	}
+	async readLines(input) {
+		const startLine = input.start_line ?? 1;
+		const maxLines = input.max_lines ?? 200;
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const range = await this.#s3.getBytesRange(absolute, {
+			start_byte: 0,
+			end_byte: MAX_FILES_LINES_SCAN_BYTES - 1
+		});
+		const allLines = bytesToUtf8(range.bytes).split(/\r\n|\n|\r/);
+		if (allLines.length > 0 && allLines[allLines.length - 1] === "") allLines.pop();
+		const sliceStart = startLine - 1;
+		const page = allLines.slice(sliceStart, sliceStart + maxLines);
+		const scannedAll = range.total_bytes === void 0 || range.end_byte >= range.total_bytes - 1;
+		const truncated = sliceStart + page.length < allLines.length || !scannedAll;
+		return filesReadLinesOutputSchema.parse({
+			path: input.path,
+			start_line: startLine,
+			lines: page,
+			truncated,
+			...truncated && { next_start_line: startLine + page.length }
+		});
+	}
+	async createArtifact(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const head = await this.#s3.head({ key: absolute });
+		if (!head.exists) throw new ToolError("File not found", {
+			code: "not_found",
+			details: { path: input.path }
+		});
+		const artifact = {
+			store: "object",
+			key: absolute,
+			...input.filename && { filename: input.filename },
+			...input.media_type ? { media_type: input.media_type } : head.content_type ? { media_type: head.content_type } : {},
+			...head.content_length !== void 0 && { byte_length: head.content_length }
+		};
+		return filesCreateArtifactOutputSchema.parse({
+			path: input.path,
+			artifact
+		});
+	}
+	async put(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const put = await this.#s3.put({
+			key: absolute,
+			body: input.body,
+			...input.body_encoding && { body_encoding: input.body_encoding },
+			...input.content_type && { content_type: input.content_type }
+		});
+		return filesPutOutputSchema.parse({
+			path: input.path,
+			content_length: put.content_length,
+			...put.etag && { etag: put.etag }
+		});
+	}
+	async delete(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const result = await this.#s3.delete({ key: absolute });
+		return filesDeleteOutputSchema.parse({
+			path: input.path,
+			deleted: result.deleted
+		});
+	}
+	async copy(input) {
+		const source = resolveUnderRoot(this.#root, input.source_path);
+		const destination = resolveUnderRoot(this.#root, input.destination_path);
+		const result = await this.#s3.copy({
+			source_key: source,
+			destination_key: destination
+		});
+		return filesCopyOutputSchema.parse({
+			source_path: input.source_path,
+			destination_path: input.destination_path,
+			...result.etag && { etag: result.etag }
+		});
+	}
+	async mkdir(input) {
+		const folder = input.path.trim().replaceAll("\\", "/").replace(/^\/+/, "").replace(/\/+$/, "");
+		const keepRelative = `${folder}/.keep`;
+		const absolute = resolveUnderRoot(this.#root, keepRelative);
+		await this.#s3.put({
+			key: absolute,
+			body: "",
+			body_encoding: "utf8",
+			content_type: "application/x-directory"
+		});
+		return filesMkdirOutputSchema.parse({
+			path: folder,
+			created: true
+		});
+	}
+	async move(input) {
+		const source = resolveUnderRoot(this.#root, input.source_path);
+		const destination = resolveUnderRoot(this.#root, input.destination_path);
+		if (source === destination) throw new ToolError("source_path and destination_path must differ", { code: "bad_input" });
+		const copied = await this.#s3.copy({
+			source_key: source,
+			destination_key: destination
+		});
+		await this.#s3.delete({ key: source });
+		return filesMoveOutputSchema.parse({
+			source_path: input.source_path,
+			destination_path: input.destination_path,
+			...copied.etag && { etag: copied.etag }
+		});
+	}
+	async multipartStart(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const started = await this.#s3.createMultipartUpload({
+			key: absolute,
+			...input.content_type && { content_type: input.content_type }
+		});
+		return filesMultipartStartOutputSchema.parse({
+			path: input.path,
+			upload_id: started.upload_id
+		});
+	}
+	async multipartUploadPart(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const part = await this.#s3.uploadPart({
+			key: absolute,
+			upload_id: input.upload_id,
+			part_number: input.part_number,
+			body: input.body,
+			...input.body_encoding && { body_encoding: input.body_encoding }
+		});
+		return filesMultipartUploadPartOutputSchema.parse({
+			path: input.path,
+			upload_id: input.upload_id,
+			part_number: part.part_number,
+			etag: part.etag,
+			content_length: part.content_length
+		});
+	}
+	async multipartComplete(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const completed = await this.#s3.completeMultipartUpload({
+			key: absolute,
+			upload_id: input.upload_id,
+			parts: input.parts
+		});
+		return filesMultipartCompleteOutputSchema.parse({
+			path: input.path,
+			upload_id: input.upload_id,
+			...completed.etag && { etag: completed.etag }
+		});
+	}
+	async multipartAbort(input) {
+		const absolute = resolveUnderRoot(this.#root, input.path);
+		const aborted = await this.#s3.abortMultipartUpload({
+			key: absolute,
+			upload_id: input.upload_id
+		});
+		return filesMultipartAbortOutputSchema.parse({
+			path: input.path,
+			upload_id: input.upload_id,
+			aborted: aborted.aborted
+		});
+	}
+};
+//#endregion
+//#region src/modules/files/module.ts
+const filesListTool = defineTool({
+	id: "files-list",
+	name: "listFiles",
+	description: "List files and folders under a relative path in the bound workspace root. Returns names, kinds, sizes when known, and pagination fields. Does not return file body bytes.",
+	inputSchema: filesListInputSchema,
+	outputSchema: filesListOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).list(input)
+});
+const filesSearchTool = defineTool({
+	id: "files-search",
+	name: "searchFiles",
+	description: "Search for files and folders by name fragment under the bound workspace root (optional relative folder). Matches the last path segment only; not full-text content search. Returns metadata without file body bytes.",
+	inputSchema: filesSearchInputSchema,
+	outputSchema: filesSearchOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).search(input)
+});
+const filesStatTool = defineTool({
+	id: "files-stat",
+	name: "statFile",
+	description: "Get metadata for one relative file path under the bound workspace root (exists, size, content type, etag when known). Does not return file body bytes.",
+	inputSchema: filesStatInputSchema,
+	outputSchema: filesStatOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).stat(input)
+});
+const filesGetTool = defineTool({
+	id: "files-get",
+	name: "getFile",
+	description: "Download one file by relative path under the bound workspace root. Bodies larger than the storage provider limit fail. Returns body as base64 by default or utf8 when requested.",
+	inputSchema: filesGetInputSchema,
+	outputSchema: filesGetOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).get(input)
+});
+const filesGetRangeTool = defineTool({
+	id: "files-get-range",
+	name: "getFileRange",
+	description: "Download a byte range of one file under the bound workspace root (inclusive start_byte/end_byte). Max range size is 8 MiB. Prefer this over files-get for large objects.",
+	inputSchema: filesGetRangeInputSchema,
+	outputSchema: filesGetRangeOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).getRange(input)
+});
+const filesReadLinesTool = defineTool({
+	id: "files-read-lines",
+	name: "readFileLines",
+	description: "Read a page of UTF-8 text lines from a file under the bound workspace root (1-based start_line, max_lines). Scans at most 2 MiB from the start of the object for line boundaries.",
+	inputSchema: filesReadLinesInputSchema,
+	outputSchema: filesReadLinesOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).readLines(input)
+});
+const filesCreateArtifactTool = defineTool({
+	id: "files-create-artifact",
+	name: "createFileArtifact",
+	description: "Return an object-store ArtifactRef for an existing file under the bound workspace root (zero-copy; same storage key). Use when another tool needs an ArtifactRef without re-uploading bytes.",
+	inputSchema: filesCreateArtifactInputSchema,
+	outputSchema: filesCreateArtifactOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).createArtifact(input)
+});
+const filesPutTool = defineTool({
+	id: "files-put",
+	name: "putFile",
+	description: "Upload or replace one file at a relative path under the bound workspace root. Provide utf8 text or base64 body. Paths cannot escape the root prefix.",
+	inputSchema: filesPutInputSchema,
+	outputSchema: filesPutOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).put(input)
+});
+const filesDeleteTool = defineTool({
+	id: "files-delete",
+	name: "deleteFile",
+	description: "Delete one file by relative path under the bound workspace root. Idempotent when the object is already missing.",
+	inputSchema: filesDeleteInputSchema,
+	outputSchema: filesDeleteOutputSchema,
+	sideEffect: "delete",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).delete(input)
+});
+const filesCopyTool = defineTool({
+	id: "files-copy",
+	name: "copyFile",
+	description: "Copy one file to a new relative path under the same bound workspace root. Both source and destination must stay inside the root prefix.",
+	inputSchema: filesCopyInputSchema,
+	outputSchema: filesCopyOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).copy(input)
+});
+const filesMkdirTool = defineTool({
+	id: "files-mkdir",
+	name: "makeFileDirectory",
+	description: "Create a folder marker under the bound workspace root so the prefix is listable. Uses an empty .keep object inside the folder path.",
+	inputSchema: filesMkdirInputSchema,
+	outputSchema: filesMkdirOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).mkdir(input)
+});
+const filesMoveTool = defineTool({
+	id: "files-move",
+	name: "moveFile",
+	description: "Move one file to a new relative path under the same bound workspace root (copy then delete source). Both paths must stay inside the root prefix. Destination is overwritten if it already exists when the store allows it.",
+	inputSchema: filesMoveInputSchema,
+	outputSchema: filesMoveOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).move(input)
+});
+const filesMultipartStartTool = defineTool({
+	id: "files-multipart-start",
+	name: "startFileMultipartUpload",
+	description: "Start a multipart upload for a relative path under the bound workspace root. Returns upload_id for part/complete/abort. Use when the file exceeds the single put limit.",
+	inputSchema: filesMultipartStartInputSchema,
+	outputSchema: filesMultipartStartOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).multipartStart(input)
+});
+const filesMultipartUploadPartTool = defineTool({
+	id: "files-multipart-upload-part",
+	name: "uploadFileMultipartPart",
+	description: "Upload one part of an in-progress multipart upload under the bound workspace root. Part bodies up to 25 MiB. Some object stores require each part except the last to be at least 5 MiB. Returns etag required for complete.",
+	inputSchema: filesMultipartUploadPartInputSchema,
+	outputSchema: filesMultipartUploadPartOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).multipartUploadPart(input)
+});
+const filesMultipartCompleteTool = defineTool({
+	id: "files-multipart-complete",
+	name: "completeFileMultipartUpload",
+	description: "Complete a multipart upload under the bound workspace root by assembling uploaded parts (part_number + etag). Parts may be in any order.",
+	inputSchema: filesMultipartCompleteInputSchema,
+	outputSchema: filesMultipartCompleteOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).multipartComplete(input)
+});
+const filesMultipartAbortTool = defineTool({
+	id: "files-multipart-abort",
+	name: "abortFileMultipartUpload",
+	description: "Abort an in-progress multipart upload under the bound workspace root and discard uploaded parts for that upload_id.",
+	inputSchema: filesMultipartAbortInputSchema,
+	outputSchema: filesMultipartAbortOutputSchema,
+	sideEffect: "delete",
+	runtime: "both",
+	execute: async (input, ctx) => FilesClient.fromContext(ctx).multipartAbort(input)
+});
+const filesModule = defineModule({
+	id: "files",
+	title: "Files",
+	description: "Manage durable workspace files by relative path: list, search by name, inspect metadata, read bounded content, create ArtifactRefs, write, copy, move, delete, create folders, and use multipart upload. This is distinct from temporary sandbox files.",
+	runtime: "both",
+	auth: {
+		type: "custom",
+		schema: filesAuthSchema
+	},
+	categories: ["storage", "files"],
+	classification: "pii",
+	tags: ["path-root", "s3"],
+	tools: [
+		filesListTool,
+		filesSearchTool,
+		filesStatTool,
+		filesGetTool,
+		filesGetRangeTool,
+		filesReadLinesTool,
+		filesCreateArtifactTool,
+		filesPutTool,
+		filesDeleteTool,
+		filesCopyTool,
+		filesMoveTool,
+		filesMkdirTool,
+		filesMultipartStartTool,
+		filesMultipartUploadPartTool,
+		filesMultipartCompleteTool,
+		filesMultipartAbortTool
+	]
+});
+//#endregion
+export { FilesClient, filesAuthSchema, filesCopyTool, filesCreateArtifactTool, filesDeleteTool, filesGetRangeTool, filesGetTool, filesListTool, filesMkdirTool, filesModule, filesMoveTool, filesMultipartAbortTool, filesMultipartCompleteTool, filesMultipartStartTool, filesMultipartUploadPartTool, filesPutTool, filesReadLinesTool, filesSearchTool, filesStatTool, normalizeRootPrefix, resolveUnderRoot, toRelativeKey };
+
+//# sourceMappingURL=index.js.map