@rivus/agent 0.13.2 → 0.14.1

package/dist/chunks/pi.js

@@ -0,0 +1,329 @@
+import { l as toEffectAgentLoopInput } from "./agent-loop.js";
+import "./api.js";
+import { h as requiresToolApproval, o as createToolInputDigest, p as createInvocationAuthority } from "./pi-skill-tool.js";
+import { createHash } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, relative } from "node:path";
+import { DefaultResourceLoader, SettingsManager, createReadToolDefinition } from "@earendil-works/pi-coding-agent";
+import { realpathSync, statSync } from "node:fs";
+import { Unsafe } from "typebox";
+//#region src/adapters/pi/skills/pi-skill-read-tool.ts
+var ProjectSkillReadDenied = class extends Error {
+	name = "ProjectSkillReadDenied";
+};
+function createPiSkillReadTool(options) {
+	if (options.skillPaths.length === 0) throw new ProjectSkillReadDenied("Pi Skill read requires a trusted Skill source");
+	const allowedSources = options.skillPaths.map((source) => {
+		const path = realpathSync(source);
+		return Object.freeze({
+			directory: statSync(path).isDirectory(),
+			path
+		});
+	});
+	return createReadToolDefinition(options.cwd, { operations: {
+		access: async (absolutePath) => {
+			await stat(await authorize(absolutePath, allowedSources));
+		},
+		readFile: async (absolutePath) => readFile(await authorize(absolutePath, allowedSources))
+	} });
+}
+const createPiProjectSkillReadTool = createPiSkillReadTool;
+function createPiSkillReadTools(options) {
+	if (options.skillPaths.length === 0 || options.runtimeToolIds.includes("read")) return [];
+	return [createPiSkillReadTool(options)];
+}
+async function authorize(path, sources) {
+	const candidate = await realpath(path);
+	for (const source of sources) {
+		if (!source.directory) {
+			if (candidate === source.path) return candidate;
+			continue;
+		}
+		const relation = relative(source.path, candidate);
+		if (relation === "" || !relation.startsWith("..") && !isAbsolute(relation)) return candidate;
+	}
+	throw new ProjectSkillReadDenied("read is restricted to the bound Pi Skill sources");
+}
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-catalog.ts
+var InvalidPiSkillCatalog = class extends Error {
+	name = "InvalidPiSkillCatalog";
+};
+function validatePiSkillCatalog(input) {
+	const fatal = input.diagnostics.find(({ type }) => type === "error" || type === "collision");
+	if (fatal) throw new InvalidPiSkillCatalog(`Pi Skill discovery failed: ${fatal.message}${fatal.path ? ` (${fatal.path})` : ""}`);
+	const names = /* @__PURE__ */ new Set();
+	for (const { name } of input.skills) {
+		validateSkillName(name);
+		if (names.has(name)) throw new InvalidPiSkillCatalog(`Pi Skill discovery contains duplicate name: ${name}`);
+		names.add(name);
+	}
+	return names;
+}
+function validateSkillName(name) {
+	if (typeof name !== "string" || name.length === 0 || name.length > 64 || !/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/.test(name) || name.includes("--")) throw new InvalidPiSkillCatalog(`Pi Skill discovery contains unsafe name: ${String(name)}`);
+}
+function validatePiSkillCommand(text, skillNames) {
+	if (!text.startsWith("/skill:")) return;
+	const name = text.slice(7).split(/\s/, 1)[0];
+	if (!skillNames.has(name)) throw new InvalidPiSkillCatalog(`Unknown Pi Skill: ${name}`);
+}
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-sources.ts
+var InvalidPiSkillSource = class extends Error {
+	name = "InvalidPiSkillSource";
+};
+async function resolvePiSkillSources(options) {
+	const roots = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const path of [join(options.agentDir, "skills"), join(options.homeDirectory, ".agents", "skills")]) {
+		const canonical = await optionalDirectory(path);
+		if (canonical) appendUnique(roots, seen, canonical);
+	}
+	for (const path of options.projectSkillPaths ?? []) appendUnique(roots, seen, await requiredSkillSource(path));
+	return Object.freeze(roots);
+}
+async function optionalDirectory(path) {
+	let canonical;
+	try {
+		canonical = await realpath(path);
+	} catch (error) {
+		if (isMissingPath(error)) return void 0;
+		throw new InvalidPiSkillSource(`failed to resolve optional user Skill directory: ${path}`, { cause: error });
+	}
+	if (!(await stat(canonical)).isDirectory()) throw new InvalidPiSkillSource(`user Skill source must be a directory: ${path}`);
+	return canonical;
+}
+async function requiredSkillSource(path) {
+	try {
+		const canonical = await realpath(path);
+		const metadata = await stat(canonical);
+		if (!metadata.isDirectory() && !metadata.isFile()) throw new InvalidPiSkillSource(`Project Space Skill source must be a file or directory: ${path}`);
+		return canonical;
+	} catch (error) {
+		if (error instanceof InvalidPiSkillSource) throw error;
+		throw new InvalidPiSkillSource(`required Project Space Skill source is unavailable: ${path}`, { cause: error });
+	}
+}
+function appendUnique(roots, seen, path) {
+	if (seen.has(path)) return;
+	seen.add(path);
+	roots.push(path);
+}
+function isMissingPath(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-session-tools.ts
+function resolvePiSessionToolNames(runtimeToolIds, customTools) {
+	const names = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of [...runtimeToolIds, ...customTools.map(({ name }) => name)]) {
+		if (seen.has(name)) throw new Error(`Pi Session Tool name collision: ${name}`);
+		seen.add(name);
+		names.push(name);
+	}
+	return Object.freeze(names);
+}
+//#endregion
+//#region src/adapters/pi/runtime/pi-session-resources.ts
+const PI_BEHAVIOR_SETTING_KEYS = Object.freeze([
+	"lastChangelogVersion",
+	"defaultProvider",
+	"defaultModel",
+	"defaultThinkingLevel",
+	"transport",
+	"steeringMode",
+	"followUpMode",
+	"theme",
+	"compaction",
+	"branchSummary",
+	"retry",
+	"hideThinkingBlock",
+	"showCacheMissNotices",
+	"externalEditor",
+	"shellPath",
+	"quietStartup",
+	"shellCommandPrefix",
+	"collapseChangelog",
+	"enableSkillCommands",
+	"terminal",
+	"images",
+	"enabledModels",
+	"doubleEscapeAction",
+	"treeFilterMode",
+	"thinkingBudgets",
+	"editorPaddingX",
+	"outputPad",
+	"autocompleteMaxVisible",
+	"showHardwareCursor",
+	"markdown",
+	"warnings",
+	"httpProxy",
+	"httpIdleTimeoutMs",
+	"websocketConnectTimeoutMs"
+]);
+async function createPiSessionResources(options) {
+	const settingsManager = createSanitizedSettingsManager(options.cwd, options.agentDir);
+	const skillPaths = await resolvePiSkillSources({
+		agentDir: options.agentDir,
+		homeDirectory: options.homeDirectory,
+		...options.projectSkillPaths ? { projectSkillPaths: options.projectSkillPaths } : {}
+	});
+	const resourceLoader = new DefaultResourceLoader({
+		agentDir: options.agentDir,
+		additionalSkillPaths: [...skillPaths],
+		...options.appendSystemPromptOverride ? { appendSystemPromptOverride: options.appendSystemPromptOverride } : {},
+		cwd: options.cwd,
+		noContextFiles: true,
+		noExtensions: true,
+		noPromptTemplates: true,
+		noSkills: true,
+		noThemes: true,
+		settingsManager,
+		...options.systemPromptOverride ? { systemPromptOverride: options.systemPromptOverride } : {}
+	});
+	await resourceLoader.reload();
+	const skillNames = validatePiSkillCatalog(resourceLoader.getSkills());
+	return Object.freeze({
+		skillNames,
+		skillPaths,
+		withSessionOptions: (sessionOptions) => Object.freeze({
+			...sessionOptions,
+			agentDir: options.agentDir,
+			cwd: options.cwd,
+			resourceLoader,
+			settingsManager
+		})
+	});
+}
+function createSanitizedSettingsManager(cwd, agentDir) {
+	const fileSettings = SettingsManager.create(cwd, agentDir, { projectTrusted: false }).getGlobalSettings();
+	const behaviorSettings = Object.fromEntries(PI_BEHAVIOR_SETTING_KEYS.flatMap((key) => fileSettings[key] === void 0 ? [] : [[key, fileSettings[key]]]));
+	return SettingsManager.inMemory(behaviorSettings, { projectTrusted: false });
+}
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-tool-proxy.ts
+function createPiToolProxyDefinitions$1(options) {
+	const names = /* @__PURE__ */ new Set();
+	return options.tools.map((tool) => {
+		const name = toPiToolName(tool.id);
+		if (names.has(name)) throw new Error(`Pi tool name collision: ${name}`);
+		names.add(name);
+		return {
+			description: tool.description,
+			execute: async (callId, input, signal) => {
+				const activeInput = options.getActiveInput();
+				const invocation = activeInput?.invocation;
+				if (!activeInput || !invocation) throw new Error(`tool ${tool.id} requires an active agent run with a trusted invocation`);
+				if (!invocation.tenantKey) throw new Error(`tool ${tool.id} requires a trusted tenant identity`);
+				throwIfAborted(signal ?? activeInput.abortSignal);
+				const inputDigest = createToolInputDigest(input);
+				const operationId = createBoundId("operation", {
+					agentId: options.agentId,
+					inputDigest,
+					instanceId: options.instanceId,
+					sourceMessageId: invocation.sourceMessageId,
+					toolId: tool.id,
+					toolVersion: tool.version
+				});
+				const approvalId = createBoundId("approval", {
+					callId,
+					operationId,
+					runId: activeInput.runId
+				});
+				if (requiresToolApproval(tool.risk)) {
+					if (invocation.allowedActorOpenIds.length === 0) throw new Error(`tool ${tool.id} requires at least one trusted approval actor`);
+					await options.approvals.requestApproval({
+						agentId: options.agentId,
+						allowedActorOpenIds: invocation.allowedActorOpenIds,
+						approvalId,
+						callId,
+						endpointId: invocation.endpointId,
+						inputDigest,
+						instanceId: options.instanceId,
+						operationId,
+						risk: tool.risk,
+						runId: activeInput.runId,
+						sessionKey: activeInput.sessionKey,
+						signal: signal ?? activeInput.abortSignal,
+						sourceMessageId: invocation.sourceMessageId,
+						tenantKey: invocation.tenantKey,
+						toolId: tool.id,
+						toolVersion: tool.version
+					});
+					throwIfAborted(signal ?? activeInput.abortSignal);
+				}
+				const result = await options.broker.execute({
+					authority: createInvocationAuthority({
+						agentId: options.agentId,
+						allowedActorOpenIds: invocation.allowedActorOpenIds,
+						...invocation.kind === "background-session" ? invocation.conversationId ? { conversationId: invocation.conversationId } : {} : invocation.memory?.conversationId ? { conversationId: invocation.memory.conversationId } : {},
+						endpointId: invocation.endpointId,
+						instanceId: options.instanceId,
+						...invocation.memory ? { memory: {
+							...invocation.memory,
+							scopes: options.memoryScopes ?? []
+						} } : {},
+						runId: activeInput.runId,
+						sessionKey: activeInput.sessionKey,
+						sourceMessageId: invocation.sourceMessageId,
+						tenantKey: invocation.tenantKey,
+						toolGrantSet: options.toolGrantSet
+					}),
+					callId,
+					input,
+					operationId,
+					...requiresToolApproval(tool.risk) ? { approvalId } : {},
+					toolId: tool.id,
+					version: tool.version
+				});
+				return {
+					content: [{
+						text: stringifyToolResult(result),
+						type: "text"
+					}],
+					details: result
+				};
+			},
+			executionMode: "sequential",
+			label: tool.id,
+			name,
+			parameters: Unsafe(tool.inputSchema),
+			promptSnippet: `${name}: ${tool.description}`
+		};
+	});
+}
+function createPiToolNameResolver$1(tools) {
+	const toolIdsByPiName = new Map(tools.map((tool) => [toPiToolName(tool.id), tool.id]));
+	return (toolName) => toolIdsByPiName.get(toolName) ?? toolName;
+}
+function toPiToolName(toolId) {
+	return `rivus_${toolId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function createBoundId(kind, binding) {
+	return `${kind}:${createHash("sha256").update(JSON.stringify(binding)).digest("hex")}`;
+}
+function throwIfAborted(signal) {
+	if (signal.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("tool execution was aborted");
+}
+function stringifyToolResult(result) {
+	if (typeof result === "string") return result;
+	return JSON.stringify(result ?? null);
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-tool-proxy.ts
+function createPiToolProxyDefinitions(options) {
+	return createPiToolProxyDefinitions$1({
+		...options,
+		getActiveInput: () => {
+			const input = options.getActiveInput();
+			return input ? toEffectAgentLoopInput(input) : void 0;
+		}
+	});
+}
+function createPiToolNameResolver(tools) {
+	return createPiToolNameResolver$1(tools);
+}
+//#endregion
+export { InvalidPiSkillSource as a, validatePiSkillCatalog as c, createPiProjectSkillReadTool as d, createPiSkillReadTool as f, resolvePiSessionToolNames as i, validatePiSkillCommand as l, createPiToolProxyDefinitions as n, resolvePiSkillSources as o, createPiSkillReadTools as p, createPiSessionResources as r, InvalidPiSkillCatalog as s, createPiToolNameResolver as t, ProjectSkillReadDenied as u };