@xopcai/xopc 0.0.307 → 0.0.309

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 };

package/dist/src/agent/embedded/run-turn.js

@@ -2,6 +2,7 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { getClarification, getClarificationResumeInput, isClarificationSuspended } from "../../storage/sqlite/clarification-wait-repository.js";
 import { getConnectionResumeInput, init_connection_wait_repository, isConnectionSuspended } from "../../storage/sqlite/connection-wait-repository.js";
+import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { isComputerControlActive, isComputerLeaseTool, stopComputerControl } from "../../computer/control-guard.js";
 import { EmbeddedRunConflictError, abortEmbeddedRun, acquireEmbeddedRunLease, queueEmbeddedSteer } from "./runs.js";
 import { lastAssistantPlainText, subscribeEmbeddedSessionEvents } from "./subscribe-session.js";
@@ -22,6 +23,7 @@ import { isPromptCacheExpired, recordPromptCacheTouch } from "../../providers/pr
 import { markTurnToolResult } from "../memory/turn-provenance.js";
 import { RepositoryInstructions } from "../coding/repository-instructions.js";
 import { RunVerification } from "../coding/run-verification.js";
+import { withDelegationScope } from "../orchestration/delegation-scope.js";
 //#region src/agent/embedded/run-turn.ts
 init_connection_wait_repository();
 init_logger();
@@ -318,9 +320,16 @@ async function runXopcEmbeddedTurn(params) {
 		session.agent.afterToolCall = async (context) => {
 			connectionStopped ||= isConnectionSuspended(conversationId, runId);
 			clarificationStopped ||= isClarificationSuspended(conversationId, runId);
-			const scoped = context.toolCall.name === "read_file" ? await instructions.forTool(context.toolCall.name, context.args) : "";
+			const scoped = context.toolCall.name === "read_file" ? await instructions.forTool(context.toolCall.name, context.args) : context.toolCall.name === "data_batch" ? await instructions.forDataResult(context.result.content) : "";
 			const checked = await verification.afterTool(context);
-			if (scoped) checked.result.content.unshift({
+			if (scoped && context.toolCall.name === "data_batch") checked.result = {
+				content: [{
+					type: "text",
+					text: `${scoped}\n\nNew directory instructions were discovered. Apply them before retrying the affected data queries; this result is not evidence of a complete search.`
+				}],
+				details: { status: "retry_required" }
+			};
+			else if (scoped) checked.result.content.unshift({
 				type: "text",
 				text: scoped
 			});
@@ -347,7 +356,10 @@ async function runXopcEmbeddedTurn(params) {
 		};
 		runAbortSignal.addEventListener("abort", abortListener, { once: true });
 		try {
-			await runAgentTurnWithTimeout(session.agent, async () => {
+			await runAgentTurnWithTimeout(session.agent, () => withDelegationScope({
+				tools,
+				authorizeToolCall: params.turnPolicy ? (context, signal) => runWithEmbeddedExecutionSession(conversationId, () => params.turnPolicy.beforeToolCall(context, signal), runId) : void 0
+			}, async () => {
 				const connectionResume = getConnectionResumeInput(conversationId, runId);
 				const clarificationResume = getClarificationResumeInput(conversationId, runId);
 				if (connectionResume) await session.sendCustomMessage({
@@ -392,7 +404,7 @@ async function runXopcEmbeddedTurn(params) {
 					}, { triggerTurn: true });
 					await session.agent.waitForIdle();
 				}
-			}, timeoutMs);
+			}), timeoutMs);
 			if (connectionStopped) runner.piSm.appendCustomEntry("connection_required", {
 				runId,
 				conversationId

package/dist/src/agent/embedded/session-runner.d.ts

@@ -9,6 +9,7 @@ export type EmbeddedRunnerFingerprintInput = {
     workspaceDir: string;
     modelRef: string;
     toolNames: readonly string[];
+    toolContracts: readonly string[];
     systemPrompt: string;
     thinkingLevel: string;
     credentialRevision: string;

package/dist/src/agent/embedded/session-runner.js

@@ -23,6 +23,7 @@ function buildEmbeddedRunnerFingerprint(input) {
 		input.workspaceDir,
 		input.modelRef,
 		tools,
+		[...input.toolContracts].sort().join("\0"),
 		input.systemPrompt,
 		input.thinkingLevel,
 		input.credentialRevision
@@ -92,6 +93,7 @@ var EmbeddedSessionRunnerPool = class {
 			workspaceDir: params.workspaceDir,
 			modelRef: params.modelRef,
 			toolNames: params.tools.map((t) => t.name),
+			toolContracts: params.tools.map((tool) => JSON.stringify([tool.name, tool.parameters])),
 			systemPrompt: params.systemPrompt,
 			thinkingLevel: params.thinkingLevel ?? "medium",
 			credentialRevision: providerCredentialRevision(params.model.provider)
@@ -196,6 +198,7 @@ var EmbeddedSessionRunnerPool = class {
 				workspaceDir,
 				modelRef: params.modelRef,
 				toolNames,
+				toolContracts: tools.map((tool) => JSON.stringify([tool.name, tool.parameters])),
 				systemPrompt,
 				thinkingLevel: thinkingLevel ?? "medium",
 				credentialRevision: providerCredentialRevision(model.provider)

package/dist/src/agent/embedded/tool-result-truncation.js

@@ -1,4 +1,5 @@
 import { init_string_coerce, normalizeLowercaseStringOrEmpty } from "../../utils/string-coerce.js";
+import { isDataBatchResult, renderDataBatch } from "../data-acquisition/render.js";
 import { formatContextLimitTruncationNotice } from "./tool-result-context-guard.js";
 //#region src/agent/embedded/tool-result-truncation.ts
 init_string_coerce();
@@ -101,6 +102,16 @@ function truncateToolResultMessage(msg, maxChars, options = {}) {
 	if (!Array.isArray(content)) return msg;
 	const totalTextChars = getToolResultTextLength(msg);
 	if (totalTextChars <= maxChars) return msg;
+	if (msg.toolName === "data_batch" && content.length === 1 && content[0]?.type === "text") try {
+		const batch = JSON.parse(content[0].text);
+		if (isDataBatchResult(batch)) return {
+			...msg,
+			content: [{
+				type: "text",
+				text: renderDataBatch(batch, maxChars).text
+			}]
+		};
+	} catch {}
 	const newContent = content.map((block) => {
 		if (!block || typeof block !== "object" || block.type !== "text") return block;
 		const textBlock = block;

package/dist/src/agent/embedded/xopc-tools-bridge.js

@@ -1,3 +1,4 @@
+import { withDataToolPermissions } from "../tools/dataBatch.js";
 //#region src/agent/embedded/xopc-tools-bridge.ts
 const APPLY_PATCH_BEGIN_MARKER = "*** Begin Patch";
 const APPLY_PATCH_END_MARKER = "*** End Patch";
@@ -106,7 +107,7 @@ function xopcToolsToDefinitions(tools) {
 					const envelopeError = validateApplyPatchEnvelope(params);
 					if (envelopeError) return invalidApplyPatchEnvelopeResult(envelopeError);
 				}
-				return tool.execute(toolCallId, params, signal, onUpdate);
+				return withDataToolPermissions(new Set(tools.map((item) => item.name)), () => tool.execute(toolCallId, params, signal, onUpdate));
 			}
 		};
 	});