@xopcai/xopc 0.0.308 → 0.0.311

package/dist/src/agent/data-acquisition/scheduler.js

@@ -0,0 +1,53 @@
+//#region src/agent/data-acquisition/scheduler.ts
+/** Shared limits across batches and callers; queued cancellation never consumes a permit. */
+var DataScheduler = class {
+	running = /* @__PURE__ */ new Map();
+	queue = [];
+	active = 0;
+	constructor(totalLimit = 8, resourceLimit = 4) {
+		this.totalLimit = totalLimit;
+		this.resourceLimit = resourceLimit;
+	}
+	run(key, signal, task) {
+		signal?.throwIfAborted();
+		return new Promise((resolve, reject) => {
+			const item = {
+				key,
+				signal,
+				abort: () => {
+					const index = this.queue.indexOf(item);
+					if (index !== -1) this.queue.splice(index, 1);
+					reject(signal?.reason ?? /* @__PURE__ */ new Error("Data operation cancelled"));
+				},
+				start: () => {
+					signal?.removeEventListener("abort", item.abort);
+					this.active++;
+					this.running.set(key, (this.running.get(key) ?? 0) + 1);
+					Promise.resolve().then(() => {
+						signal?.throwIfAborted();
+						return task();
+					}).then(resolve, reject).finally(() => {
+						this.active--;
+						const count = (this.running.get(key) ?? 1) - 1;
+						if (count) this.running.set(key, count);
+						else this.running.delete(key);
+						this.drain();
+					});
+				}
+			};
+			signal?.addEventListener("abort", item.abort, { once: true });
+			this.queue.push(item);
+			this.drain();
+		});
+	}
+	drain() {
+		while (this.active < this.totalLimit) {
+			const index = this.queue.findIndex((item) => (this.running.get(item.key) ?? 0) < this.resourceLimit);
+			if (index === -1) return;
+			this.queue.splice(index, 1)[0].start();
+		}
+	}
+};
+const dataScheduler = new DataScheduler();
+//#endregion
+export { DataScheduler, dataScheduler };

package/dist/src/agent/data-acquisition/schema.d.ts

@@ -0,0 +1,75 @@
+import { type Static } from '@sinclair/typebox';
+export declare const DataBatchSchema: import("@sinclair/typebox").TObject<{
+    operations: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"file_read">;
+        path: import("@sinclair/typebox").TString;
+        startLine: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxLines: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"file_search">;
+        paths: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        patterns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        contextLines: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"git_recent">;
+        paths: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        since: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        until: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"git_read">;
+        path: import("@sinclair/typebox").TString;
+        commit: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"knowledge_search">;
+        query: import("@sinclair/typebox").TString;
+        maxResults: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"knowledge_get">;
+        knowledgeId: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"web_search">;
+        query: import("@sinclair/typebox").TString;
+        count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"web_fetch">;
+        url: import("@sinclair/typebox").TString;
+        maxChars: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>, import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        kind: import("@sinclair/typebox").TLiteral<"external_read">;
+        toolRef: import("@sinclair/typebox").TString;
+        revision: import("@sinclair/typebox").TString;
+        arguments: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>;
+    }>]>>;
+}>;
+export type DataBatchArgs = Static<typeof DataBatchSchema>;
+export type DataOperation = DataBatchArgs['operations'][number];
+export declare const DATA_OPERATION_TOOLS: {
+    readonly file_read: "read_file";
+    readonly file_search: "grep";
+    readonly git_recent: "exec_command";
+    readonly git_read: "exec_command";
+    readonly knowledge_search: "knowledge_search";
+    readonly knowledge_get: "knowledge_get";
+    readonly web_search: "web_search";
+    readonly web_fetch: "web_fetch";
+    readonly external_read: "xopc_tool_execute";
+};
+export declare function nativeDataArgs(op: DataOperation): Record<string, unknown>;
+/** Expose each underlying access to existing approval, hook and call-limit policies. */
+export declare function dataOperationCalls(args: unknown): Array<{
+    name: string;
+    args: Record<string, unknown>;
+}>;
+export declare function validateDataBatch(args: unknown): asserts args is DataBatchArgs;

package/dist/src/agent/data-acquisition/schema.js

@@ -0,0 +1,206 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+//#region src/agent/data-acquisition/schema.ts
+const id = Type.String({
+	minLength: 1,
+	maxLength: 48,
+	pattern: "^[a-zA-Z0-9_-]+$"
+});
+const path = Type.String({
+	minLength: 1,
+	maxLength: 1024
+});
+const DataBatchSchema = Type.Object({ operations: Type.Array(Type.Union([
+	Type.Object({
+		id,
+		kind: Type.Literal("file_read"),
+		path,
+		startLine: Type.Optional(Type.Integer({ minimum: 1 })),
+		maxLines: Type.Optional(Type.Integer({
+			minimum: 1,
+			maximum: 500
+		}))
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("file_search"),
+		paths: Type.Array(path, {
+			minItems: 1,
+			maxItems: 8
+		}),
+		patterns: Type.Array(Type.String({
+			minLength: 1,
+			maxLength: 512
+		}), {
+			minItems: 1,
+			maxItems: 8
+		}),
+		literal: Type.Optional(Type.Boolean()),
+		ignoreCase: Type.Optional(Type.Boolean()),
+		glob: Type.Optional(Type.String({
+			minLength: 1,
+			maxLength: 512
+		})),
+		contextLines: Type.Optional(Type.Integer({
+			minimum: 0,
+			maximum: 10
+		}))
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("git_recent"),
+		paths: Type.Optional(Type.Array(path, {
+			minItems: 1,
+			maxItems: 8
+		})),
+		since: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })),
+		until: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" }))
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("git_read"),
+		path,
+		commit: Type.String({ pattern: "^[a-fA-F0-9]{7,64}$" })
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("knowledge_search"),
+		query: Type.String({
+			minLength: 1,
+			maxLength: 1e3
+		}),
+		maxResults: Type.Optional(Type.Integer({
+			minimum: 1,
+			maximum: 20
+		}))
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("knowledge_get"),
+		knowledgeId: Type.String({
+			minLength: 1,
+			maxLength: 256
+		})
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("web_search"),
+		query: Type.String({
+			minLength: 1,
+			maxLength: 1e3
+		}),
+		count: Type.Optional(Type.Integer({
+			minimum: 1,
+			maximum: 10
+		}))
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("web_fetch"),
+		url: Type.String({
+			minLength: 1,
+			maxLength: 2048
+		}),
+		maxChars: Type.Optional(Type.Integer({
+			minimum: 100,
+			maximum: 12e3
+		}))
+	}, { additionalProperties: false }),
+	Type.Object({
+		id,
+		kind: Type.Literal("external_read"),
+		toolRef: Type.String({
+			minLength: 1,
+			maxLength: 512
+		}),
+		revision: Type.String({
+			minLength: 1,
+			maxLength: 128
+		}),
+		arguments: Type.Record(Type.String(), Type.Unknown())
+	}, { additionalProperties: false })
+]), {
+	minItems: 1,
+	maxItems: 8
+}) }, { additionalProperties: false });
+const DATA_OPERATION_TOOLS = {
+	file_read: "read_file",
+	file_search: "grep",
+	git_recent: "exec_command",
+	git_read: "exec_command",
+	knowledge_search: "knowledge_search",
+	knowledge_get: "knowledge_get",
+	web_search: "web_search",
+	web_fetch: "web_fetch",
+	external_read: "xopc_tool_execute"
+};
+function nativeDataArgs(op) {
+	switch (op.kind) {
+		case "knowledge_search": return {
+			query: op.query,
+			maxResults: op.maxResults
+		};
+		case "knowledge_get": return { id: op.knowledgeId };
+		case "web_search": return {
+			query: op.query,
+			count: op.count
+		};
+		case "web_fetch": return {
+			url: op.url,
+			maxChars: op.maxChars ?? 8e3
+		};
+		case "external_read": return {
+			toolRef: op.toolRef,
+			revision: op.revision,
+			arguments: op.arguments,
+			readOnly: true
+		};
+		default: throw new Error("Not a native data operation");
+	}
+}
+/** Expose each underlying access to existing approval, hook and call-limit policies. */
+function dataOperationCalls(args) {
+	validateDataBatch(args);
+	return args.operations.flatMap((op) => {
+		if (op.kind === "file_read") return [{
+			name: "read_file",
+			args: {
+				path: op.path,
+				offset: op.startLine,
+				limit: op.maxLines
+			}
+		}];
+		if (op.kind === "file_search") return op.paths.flatMap((path) => op.patterns.map((pattern) => ({
+			name: "grep",
+			args: {
+				path,
+				pattern,
+				literal: op.literal,
+				glob: op.glob,
+				ignoreCase: op.ignoreCase,
+				context: op.contextLines ?? 2
+			}
+		})));
+		if (op.kind === "git_read" || op.kind === "git_recent") return [{
+			name: "exec_command",
+			args: {
+				cmd: op.kind === "git_read" ? `git show ${op.commit} (file read)` : "git log HEAD (recent history)",
+				...op
+			}
+		}, ...op.kind === "git_read" ? [{
+			name: "read_file",
+			args: { path: op.path }
+		}] : []];
+		return [{
+			name: DATA_OPERATION_TOOLS[op.kind],
+			args: nativeDataArgs(op)
+		}];
+	});
+}
+function validateDataBatch(args) {
+	if (!Value.Check(DataBatchSchema, args)) throw new Error("Invalid data_batch parameters");
+	if (new Set(args.operations.map((op) => op.id)).size !== args.operations.length) throw new Error("Operation ids must be unique");
+	if (Buffer.byteLength(JSON.stringify(args)) > 32e3) throw new Error("Batch input exceeds 32 KB");
+}
+//#endregion
+export { DATA_OPERATION_TOOLS, DataBatchSchema, dataOperationCalls, nativeDataArgs, validateDataBatch };

package/dist/src/agent/data-acquisition/service.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+import { type DataBatchArgs } from './schema.js';
+import type { DataBatchResult } from './types.js';
+/** Each batch owns its read cache; permissions are checked before sharing any data. */
+export interface DataSourceOptions {
+    getTools?: () => readonly AgentTool[];
+    allowHostGit?: () => boolean;
+    canExecute?: (toolName: string) => boolean;
+}
+export declare function acquireData(workspace: string, args: DataBatchArgs, allowed: ReadonlySet<string>, signal?: AbortSignal, options?: DataSourceOptions): Promise<DataBatchResult>;

package/dist/src/agent/data-acquisition/service.js

@@ -0,0 +1,292 @@
+import { executeWithTimeout } from "../lifecycle/timeout-wrapper.js";
+import { checkedFilePath, readWorkspaceFileAsync } from "../sandbox/fileAccess.js";
+import { dataScheduler } from "./scheduler.js";
+import { checkFileSafety } from "../prompt/safety.js";
+import { parseRepositoryMatch, repositorySearch } from "../tools/repository-search.js";
+import { DATA_OPERATION_TOOLS, nativeDataArgs, validateDataBatch } from "./schema.js";
+import { readGitData } from "./git.js";
+import { resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
+//#region src/agent/data-acquisition/service.ts
+async function acquireData(workspace, args, allowed, signal, options = {}) {
+	validateDataBatch(args);
+	signal?.throwIfAborted();
+	const deadline = AbortSignal.any([...signal ? [signal] : [], AbortSignal.timeout(15e3)]);
+	const files = /* @__PURE__ */ new Map();
+	const result = {
+		schemaVersion: 1,
+		operations: [],
+		fragments: [],
+		sourceRequests: 0
+	};
+	let readBytes = 0;
+	const runOperation = async (op) => {
+		const started = Date.now();
+		const output = {
+			id: op.id,
+			kind: op.kind,
+			status: "ok",
+			fragmentIds: [],
+			scope: "",
+			sourceExhausted: false,
+			outputOmitted: false,
+			durationMs: 0
+		};
+		const fragments = [];
+		const add = (resource, text, startLine, revision) => {
+			fragments.push({
+				id: "",
+				operationIds: [op.id],
+				source: {
+					kind: "file",
+					resource,
+					revision,
+					capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+				},
+				startLine,
+				endLine: startLine + text.split("\n").length - 1,
+				text
+			});
+		};
+		try {
+			deadline.throwIfAborted();
+			const toolAllowed = () => allowed.has(DATA_OPERATION_TOOLS[op.kind]) && options.canExecute?.(DATA_OPERATION_TOOLS[op.kind]) !== false;
+			if (!toolAllowed()) {
+				output.status = "denied";
+				output.reason = "Underlying tool is not allowed";
+				return {
+					output,
+					fragments
+				};
+			}
+			const checkPermission = () => {
+				if (!toolAllowed() || op.kind === "git_read" && options.canExecute?.("read_file") === false) throw new Error("Sandbox: data access was revoked");
+			};
+			if (op.kind === "git_read" && !allowed.has("read_file")) {
+				output.status = "denied";
+				output.reason = "Git object reads require read_file permission";
+				return {
+					output,
+					fragments
+				};
+			}
+			const operationSignal = AbortSignal.any([deadline, AbortSignal.timeout(5e3)]);
+			const safePath = (input) => {
+				const safety = checkFileSafety("read", input);
+				if (!safety.allowed) throw new Error(`Sandbox: ${safety.message}`);
+				return checkedFilePath(workspace, resolve(workspace, input), "read");
+			};
+			if (op.kind === "file_read") {
+				const target = safePath(op.path);
+				const first = op.startLine ?? 1;
+				const count = op.maxLines ?? 120;
+				output.scope = `${target}:${first}-${first + count - 1}`;
+				let reading = files.get(target);
+				if (!reading) {
+					reading = dataScheduler.run(workspace, operationSignal, async () => {
+						checkPermission();
+						const bytes = (await stat(target)).size;
+						if (readBytes + bytes > 32 * 1024 * 1024) throw new Error("Batch read byte budget exceeded");
+						readBytes += bytes;
+						result.sourceRequests++;
+						const data = await readWorkspaceFileAsync(workspace, target, operationSignal, Math.min(bytes, 10 * 1024 * 1024));
+						if (data.includes(0)) throw new Error("Binary file: use the appropriate media or document tool");
+						return {
+							lines: data.toString("utf8").split("\n"),
+							revision: createHash("sha256").update(data).digest("hex")
+						};
+					});
+					files.set(target, reading);
+				}
+				const { lines, revision } = await reading;
+				operationSignal.throwIfAborted();
+				if (first > lines.length) throw new Error(`Offset ${first} exceeds ${lines.length} lines`);
+				const requestedEnd = Math.min(lines.length, first - 1 + count);
+				let end = first - 1, bytes = 0;
+				while (end < requestedEnd) {
+					const size = Buffer.byteLength(lines[end]) + 1;
+					if (bytes + size > Math.floor(256 * 1024 / args.operations.length)) break;
+					bytes += size;
+					end++;
+				}
+				if (end === first - 1) throw new Error("Line exceeds batch fragment budget; use a targeted search or a format-specific tool");
+				output.outputOmitted = end < requestedEnd;
+				add(target, lines.slice(first - 1, end).join("\n"), first, revision);
+				output.scope = `${target}:${first}-${end}`;
+				output.sourceExhausted = end === lines.length;
+				if (!output.sourceExhausted) output.next = {
+					path: target,
+					startLine: end + 1,
+					maxLines: count
+				};
+			} else if (op.kind === "file_search") {
+				const paths = op.paths.map(safePath);
+				output.scope = JSON.stringify({
+					paths,
+					patterns: op.patterns,
+					glob: op.glob
+				}).slice(0, 3e3);
+				const byFile = /* @__PURE__ */ new Map();
+				let buffered = 0;
+				result.sourceRequests++;
+				const search = await repositorySearch(workspace, [
+					"--json",
+					"--line-number",
+					"--with-filename",
+					"--color",
+					"never",
+					"--context",
+					String(op.contextLines ?? 2),
+					...op.literal ? ["--fixed-strings"] : [],
+					...op.ignoreCase ? ["--ignore-case"] : [],
+					...op.glob ? ["--glob", op.glob] : [],
+					...op.patterns.flatMap((pattern) => ["-e", pattern]),
+					"--",
+					...paths
+				], operationSignal, {
+					maxBytes: Math.min(1024 * 1024, Math.floor(4 * 1024 * 1024 / args.operations.length)),
+					onLine: (line) => {
+						const match = parseRepositoryMatch(workspace, line);
+						if (!match) return;
+						const resource = match.path;
+						const text = match.text;
+						const bytes = Buffer.byteLength(text);
+						if (bytes > 4096 || buffered + bytes > Math.floor(256 * 1024 / args.operations.length)) {
+							output.outputOmitted = true;
+							return;
+						}
+						const group = byFile.get(resource) ?? [];
+						const last = group.at(-1);
+						if (last && last.endLine === match.line - 1 && Buffer.byteLength(last.text) + bytes < 4096) {
+							last.text += `\n${text}`;
+							last.endLine = match.line;
+						} else if (group.length < 3 && fragments.length < 32) {
+							add(resource, text, match.line);
+							group.push(fragments.at(-1));
+							byFile.set(resource, group);
+						} else {
+							output.outputOmitted = true;
+							return;
+						}
+						buffered += bytes;
+					}
+				});
+				output.sourceExhausted = !search.truncated;
+				if (search.truncated) {
+					output.status = "partial";
+					output.reason = "scan_budget";
+				}
+			} else if (op.kind === "git_read" || op.kind === "git_recent") {
+				if (options.allowHostGit?.() === false) throw new Error("Sandbox: use exec_command for Git in the configured isolated environment");
+				const git = await readGitData(workspace, op, operationSignal, () => {
+					result.sourceRequests++;
+				});
+				output.scope = JSON.stringify(op);
+				output.sourceExhausted = git.exhausted;
+				if (git.reason) {
+					output.status = "partial";
+					output.reason = git.reason;
+					output.outputOmitted = git.reason === "output_budget";
+				}
+				fragments.push({
+					id: "",
+					operationIds: [op.id],
+					source: {
+						kind: "git",
+						resource: git.resource,
+						revision: git.revision,
+						capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+					},
+					text: git.text
+				});
+			} else {
+				const tool = options.getTools?.().find((tool) => tool.name === DATA_OPERATION_TOOLS[op.kind]);
+				if (!tool) throw new Error("Data source tool is unavailable");
+				const resource = op.kind === "web_fetch" ? op.url : op.kind === "knowledge_get" ? op.knowledgeId : op.kind === "external_read" ? `${op.toolRef}#account=${encodeURIComponent(String(op.arguments.xopcAccountId ?? ""))}` : op.query;
+				output.scope = JSON.stringify({
+					kind: op.kind,
+					resource
+				});
+				const resourceKey = op.kind === "external_read" ? `connector:${op.toolRef.split(":").slice(0, 2).join(":")}:${String(op.arguments.xopcAccountId ?? "")}` : op.kind.startsWith("web_") ? `web:${op.kind === "web_fetch" ? new URL(op.url).hostname : "search"}` : workspace;
+				const native = await executeWithTimeout(() => dataScheduler.run(resourceKey, operationSignal, async () => {
+					checkPermission();
+					result.sourceRequests++;
+					return tool.execute(op.id, nativeDataArgs(op), operationSignal);
+				}), {
+					toolName: op.kind,
+					signal: operationSignal,
+					timeoutMs: 15e3
+				});
+				operationSignal.throwIfAborted();
+				const details = native.details;
+				if (details?.error || details?.status === "failed") throw new Error(String(details.error ?? "Data source failed"));
+				const text = native.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+				if (text.length > 32e3) output.outputOmitted = true;
+				if (details?.truncated) output.outputOmitted = true;
+				fragments.push({
+					id: "",
+					operationIds: [op.id],
+					source: {
+						kind: op.kind,
+						resource,
+						revision: op.kind === "external_read" ? op.revision : void 0,
+						capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+					},
+					text: text.slice(0, 32e3)
+				});
+				output.sourceExhausted = details?.complete === true;
+			}
+			checkPermission();
+			if (output.outputOmitted) {
+				output.status = "partial";
+				output.reason ??= "output_budget";
+			}
+		} catch (error) {
+			output.status = deadline.aborted ? "cancelled" : String(error).includes("Sandbox:") ? "denied" : "error";
+			output.reason = (error instanceof Error ? error.message : String(error)).slice(0, 300);
+			if (fragments.length && output.status === "error") output.status = "partial";
+			if (output.status === "denied" || output.status === "cancelled") fragments.length = 0;
+		} finally {
+			output.durationMs = Date.now() - started;
+		}
+		return {
+			output,
+			fragments
+		};
+	};
+	const operations = new Array(args.operations.length);
+	let nextOperation = 0;
+	await Promise.all(Array.from({ length: Math.min(4, args.operations.length) }, async () => {
+		while (nextOperation < args.operations.length) {
+			const index = nextOperation++;
+			operations[index] = await runOperation(args.operations[index]);
+		}
+	}));
+	const unique = /* @__PURE__ */ new Map();
+	for (const { output, fragments } of operations) {
+		for (const fragment of fragments) {
+			const key = JSON.stringify([
+				fragment.source.kind,
+				fragment.source.resource,
+				fragment.source.revision,
+				fragment.startLine,
+				fragment.text
+			]);
+			const previous = unique.get(key);
+			if (previous) {
+				previous.operationIds.push(output.id);
+				output.fragmentIds.push(previous.id);
+			} else {
+				fragment.id = `f${unique.size + 1}`;
+				unique.set(key, fragment);
+				output.fragmentIds.push(fragment.id);
+				result.fragments.push(fragment);
+			}
+		}
+		result.operations.push(output);
+	}
+	return result;
+}
+//#endregion
+export { acquireData };

package/dist/src/agent/data-acquisition/types.d.ts

@@ -0,0 +1,37 @@
+export interface DataFragment {
+    id: string;
+    operationIds: string[];
+    source: {
+        kind: string;
+        resource: string;
+        revision?: string;
+        capturedAt: string;
+    };
+    startLine?: number;
+    endLine?: number;
+    text: string;
+}
+export interface DataOperationResult {
+    id: string;
+    kind: string;
+    status: 'ok' | 'partial' | 'error' | 'denied' | 'cancelled';
+    fragmentIds: string[];
+    scope: string;
+    sourceExhausted: boolean;
+    outputOmitted: boolean;
+    reason?: string;
+    next?: {
+        path: string;
+        startLine: number;
+        maxLines: number;
+    };
+    durationMs: number;
+}
+export interface DataBatchResult {
+    schemaVersion: 1;
+    operations: DataOperationResult[];
+    fragments: DataFragment[];
+    sourceRequests: number;
+}
+export declare const DATA_MAX_CHARS = 12000;
+export declare const DATA_MAX_BYTES: number;

package/dist/src/agent/data-acquisition/types.js

@@ -0,0 +1,5 @@
+//#region src/agent/data-acquisition/types.ts
+const DATA_MAX_CHARS = 12e3;
+const DATA_MAX_BYTES = 32 * 1024;
+//#endregion
+export { DATA_MAX_BYTES, DATA_MAX_CHARS };