@aigne/afs-ash 1.11.0-beta.12

package/dist/agent-run-CXJQ0jPV.mjs

@@ -0,0 +1,873 @@
+//#region src/ash-generator.ts
+/**
+* Format a value as an ASH inline literal.
+* Strings get quoted, numbers/booleans are bare.
+*/
+function formatValue(v) {
+	if (typeof v === "string") return JSON.stringify(v);
+	if (typeof v === "number" || typeof v === "boolean") return String(v);
+	return JSON.stringify(v);
+}
+/**
+* Format args as ASH inline object: { key: "val", num: 42 }
+*/
+function formatInlineArgs(args) {
+	const entries = Object.entries(args);
+	if (entries.length === 0) return "";
+	return ` { ${entries.map(([k, v]) => `${k}: ${formatValue(v)}`).join(", ")} }`;
+}
+/**
+* Generate a single pipeline statement for a tool call.
+*/
+function generateStatement(call) {
+	const resultPath = `/.results/${call.id}`;
+	if (call.op === "read" || call.op === "list") return `find ${call.path} | save ${resultPath}`;
+	const inlineArgs = formatInlineArgs(call.args);
+	return `action ${call.path}${inlineArgs} | save ${resultPath}`;
+}
+/**
+* Derive @caps declaration from the calls in this round.
+*
+* Capabilities:
+* - read: for read/list ops (exact path)
+* - exec: for exec ops (exact path)
+* - write: always /.results/* (where save goes)
+*/
+function deriveCaps(calls) {
+	const parts = [];
+	for (const call of calls) if (call.op === "read" || call.op === "list") parts.push(`read ${call.path}`);
+	else if (call.op === "exec") parts.push(`exec ${call.path}`);
+	parts.push("write /.results/*");
+	return `@caps(${parts.join(" ")})`;
+}
+/**
+* Generate a complete ASH program from validated tool calls.
+*
+* Each call becomes a separate pipeline within a single job.
+* The program is scoped with @caps derived from actual paths.
+*/
+function generateAsh(calls, round) {
+	const caps = deriveCaps(calls);
+	const statements = calls.map(generateStatement);
+	return `${caps}\njob round_${round} {\n  ${statements.length > 0 ? statements.join("\n  ") : "output \"no-op\""}\n}`;
+}
+
+//#endregion
+//#region src/path-validator.ts
+/**
+* Match an actual path against a declaration pattern.
+*
+* Supports:
+* - Exact: "/a/b" matches "/a/b"
+* - Single-level `*`: "/a/*" matches "/a/b" but NOT "/a/b/c"
+* - Multi-level `**`: "/a/**" matches "/a/b/c" up to `maxDepth` levels from `**` position
+*
+* @param maxDepth Maximum levels `**` can consume. Defaults to 0 (no expansion).
+*/
+function matchPath(actual, pattern, maxDepth = 0) {
+	if (actual === pattern) return true;
+	const patternParts = pattern.split("/");
+	const actualParts = actual.split("/");
+	const dstarIdx = patternParts.indexOf("**");
+	if (dstarIdx === -1) return matchSingleLevel(actualParts, patternParts);
+	const prefix = patternParts.slice(0, dstarIdx);
+	const suffix = patternParts.slice(dstarIdx + 1);
+	if (actualParts.length < prefix.length + suffix.length) return false;
+	for (let i = 0; i < prefix.length; i++) {
+		if (prefix[i] === "*") continue;
+		if (prefix[i] !== actualParts[i]) return false;
+	}
+	const suffixStart = actualParts.length - suffix.length;
+	if (suffixStart < prefix.length) return false;
+	for (let i = 0; i < suffix.length; i++) {
+		if (suffix[i] === "*") continue;
+		if (suffix[i] !== actualParts[suffixStart + i]) return false;
+	}
+	const dstarLevels = actualParts.length - prefix.length - suffix.length;
+	return dstarLevels >= 0 && dstarLevels <= maxDepth;
+}
+/** Single-level * matching (no **). */
+function matchSingleLevel(actualParts, patternParts) {
+	if (!patternParts.some((p) => p === "*")) return false;
+	if (actualParts.length === patternParts.length) {
+		for (let i = 0; i < patternParts.length; i++) {
+			if (patternParts[i] === "*") continue;
+			if (patternParts[i] !== actualParts[i]) return false;
+		}
+		return true;
+	}
+	if (actualParts.length < patternParts.length) {
+		for (let i = actualParts.length; i < patternParts.length; i++) if (patternParts[i] !== "*") return false;
+		for (let i = 0; i < actualParts.length; i++) if (patternParts[i] !== "*" && patternParts[i] !== actualParts[i]) return false;
+		return true;
+	}
+	return false;
+}
+/**
+* Extract the action name from an exec path.
+* E.g., "/modules/github/issues/42/.actions/close-issue" → "close-issue"
+*/
+function extractActionName(path) {
+	const idx = path.lastIndexOf("/.actions/");
+	if (idx === -1) return void 0;
+	return path.slice(idx + 10).split("/")[0];
+}
+/**
+* Validate a tool_call's path and operation against the tools declaration.
+*/
+function validateToolCall(path, op, tools) {
+	let basePath;
+	if (op === "exec") {
+		const idx = path.indexOf("/.actions/");
+		if (idx !== -1) basePath = path.slice(0, idx);
+	}
+	let pathMatched = false;
+	for (const entry of tools) {
+		const md = entry.maxDepth ?? 0;
+		if (!matchPath(path, entry.path, md) && !(basePath && matchPath(basePath, entry.path, md))) continue;
+		pathMatched = true;
+		if (!entry.ops.includes(op)) continue;
+		if (op === "exec" && entry.exclude_actions?.length) {
+			const actionName = extractActionName(path);
+			if (actionName && entry.exclude_actions.includes(actionName)) return {
+				allowed: false,
+				reason: `Action '${actionName}' is excluded on '${entry.path}'`
+			};
+		}
+		return { allowed: true };
+	}
+	if (pathMatched) return {
+		allowed: false,
+		reason: `Operation '${op}' not allowed on '${path}'`
+	};
+	return {
+		allowed: false,
+		reason: `Path '${path}' not in tools declaration`
+	};
+}
+
+//#endregion
+//#region src/tool-schema.ts
+const OP_DEFINITIONS = {
+	read: {
+		name: "afs_read",
+		description: "Read content at an AFS path",
+		extraProps: {},
+		extraRequired: []
+	},
+	list: {
+		name: "afs_list",
+		description: "List directory contents at an AFS path",
+		extraProps: {
+			depth: {
+				type: "number",
+				description: "Recursion depth (default 1)"
+			},
+			pattern: {
+				type: "string",
+				description: "Filter pattern, e.g. *.md"
+			}
+		},
+		extraRequired: []
+	},
+	exec: {
+		name: "afs_exec",
+		description: "Execute an action at an AFS path. IMPORTANT: Before calling, use afs_list on the parent path's .actions/ to discover available actions and their inputSchema, then pass the required fields in args.",
+		extraProps: { args: {
+			type: "object",
+			description: "Action arguments matching the action's inputSchema"
+		} },
+		extraRequired: []
+	},
+	search: {
+		name: "afs_search",
+		description: "Search for content within an AFS path",
+		extraProps: { query: {
+			type: "string",
+			description: "Search query"
+		} },
+		extraRequired: ["query"]
+	},
+	write: {
+		name: "afs_write",
+		description: "Write content to an AFS path",
+		extraProps: { content: {
+			type: "string",
+			description: "Content to write"
+		} },
+		extraRequired: ["content"]
+	},
+	stat: {
+		name: "afs_stat",
+		description: "Get metadata for an AFS path",
+		extraProps: {},
+		extraRequired: []
+	},
+	explain: {
+		name: "afs_explain",
+		description: "Get a human-readable explanation for an AFS path",
+		extraProps: {},
+		extraRequired: []
+	}
+};
+/**
+* Build OpenAI function-calling tools from ToolEntry declarations.
+*
+* Deduplicates operations across entries — one tool per unique op.
+* Each tool's path description lists all allowed patterns for that op.
+*
+* When actionSchemas are provided (from startup discovery), generates
+* per-action tools (afs_action_{name}) with explicit typed parameters
+* so LLMs know exactly what fields each action requires.
+*/
+function buildToolSchema(tools, actionSchemas) {
+	const pathsByOp = /* @__PURE__ */ new Map();
+	const excludedActionsByOp = /* @__PURE__ */ new Map();
+	const maxDepthByOp = /* @__PURE__ */ new Map();
+	for (const entry of tools) for (const op of entry.ops) {
+		if (!pathsByOp.has(op)) pathsByOp.set(op, []);
+		const paths = pathsByOp.get(op);
+		if (!paths.includes(entry.path)) paths.push(entry.path);
+		if (entry.path.includes("**") && entry.maxDepth != null) {
+			if (!maxDepthByOp.has(op)) maxDepthByOp.set(op, /* @__PURE__ */ new Map());
+			maxDepthByOp.get(op).set(entry.path, entry.maxDepth);
+		}
+		if (op === "exec" && entry.exclude_actions?.length) {
+			if (!excludedActionsByOp.has(op)) excludedActionsByOp.set(op, []);
+			const excluded = excludedActionsByOp.get(op);
+			for (const a of entry.exclude_actions) if (!excluded.includes(a)) excluded.push(a);
+		}
+	}
+	const result = [];
+	for (const [op, paths] of pathsByOp) {
+		const def = OP_DEFINITIONS[op];
+		if (!def) continue;
+		const depthMap = maxDepthByOp.get(op);
+		const hasDstar = paths.some((p) => p.includes("**"));
+		let pathDesc = `AFS path. Allowed: ${paths.join(", ")}.`;
+		if (hasDstar && depthMap) {
+			const depthNotes = [...depthMap.entries()].map(([p, d]) => `${p} (maxDepth ${d})`).join(", ");
+			pathDesc += ` ** matches multiple levels: ${depthNotes}.`;
+		}
+		pathDesc += " Note: * matches one level only (e.g. /a/* matches /a/b but NOT /a/b/c).";
+		const excluded = excludedActionsByOp.get(op);
+		if (excluded?.length) pathDesc += ` Excluded actions: ${excluded.join(", ")}.`;
+		let description = def.description;
+		let extraProps = def.extraProps;
+		let extraRequired = def.extraRequired;
+		if (op === "exec" && actionSchemas?.length) {
+			description = `Execute an action. Pass the action's parameters in args.
+Available actions:\n${actionSchemas.map((a) => {
+				const fields = Object.entries(a.inputSchema?.properties ?? {}).map(([k, v]) => {
+					const req = a.inputSchema?.required?.includes(k) ? " (required)" : "";
+					return `${k}: ${v.type ?? "string"}${req}`;
+				}).join(", ");
+				return `- ${a.pathPattern}: {${fields || "none"}} — ${a.description}`;
+			}).join("\n")}`;
+			extraRequired = ["args"];
+			const mergedProps = {};
+			for (const a of actionSchemas) if (a.inputSchema?.properties) for (const [k, v] of Object.entries(a.inputSchema.properties)) mergedProps[k] = {
+				type: v.type ?? "string",
+				...v.description ? { description: v.description } : {}
+			};
+			extraProps = { args: {
+				type: "object",
+				description: "Action arguments matching the action's inputSchema",
+				...Object.keys(mergedProps).length > 0 ? { properties: mergedProps } : {}
+			} };
+		}
+		result.push({
+			type: "function",
+			function: {
+				name: def.name,
+				description,
+				parameters: {
+					type: "object",
+					properties: {
+						path: {
+							type: "string",
+							description: pathDesc
+						},
+						...extraProps
+					},
+					required: ["path", ...extraRequired]
+				}
+			}
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region src/agent-run.ts
+const DEFAULT_MAX_ROUNDS = 20;
+const DEFAULT_ACTIONS_PER_ROUND = 10;
+const RESULTS_PREFIX = "/.results/";
+/**
+* Operations routed through ASH (deterministic sandbox).
+*
+* Currently empty: all ops go through direct AFS calls.
+* agent-run's security comes from path-validator (tools declaration whitelist),
+* not from ASH @caps. The ASH sandbox is valuable for user-written scripts
+* (/.actions/run) but redundant for agent-run's auto-generated single-step execs.
+*/
+const ASH_OPS = /* @__PURE__ */ new Set([]);
+/** Required arguments per operation (beyond path) */
+const REQUIRED_ARGS = {
+	search: ["query"],
+	write: ["content"]
+};
+/** Map tool function name → AFS operation name */
+function toolNameToOp(name) {
+	if (name.startsWith("afs_action_")) return "exec";
+	return {
+		afs_read: "read",
+		afs_list: "list",
+		afs_exec: "exec",
+		afs_search: "search",
+		afs_write: "write",
+		afs_stat: "stat",
+		afs_explain: "explain"
+	}[name];
+}
+/**
+* Normalize a tool call from any format to our internal ToolCallInput.
+*
+* AigneHub returns OpenAI format:
+*   { id, type: "function", function: { name, arguments } }
+* Some SDKs return Vercel AI SDK format:
+*   { toolCallId, toolName, args }
+*/
+function normalizeToolCall(tc) {
+	if (tc.toolCallId && tc.toolName) return {
+		toolCallId: tc.toolCallId,
+		toolName: tc.toolName,
+		args: tc.args ?? {}
+	};
+	const fn = tc.function;
+	const rawArgs = fn?.arguments;
+	let args = {};
+	if (typeof rawArgs === "string") try {
+		args = JSON.parse(rawArgs);
+	} catch {
+		args = { _parseError: `Invalid JSON in function arguments: ${rawArgs.slice(0, 200)}` };
+	}
+	else if (rawArgs && typeof rawArgs === "object") args = rawArgs;
+	return {
+		toolCallId: tc.toolCallId ?? tc.id ?? "",
+		toolName: tc.toolName ?? fn?.name ?? "",
+		args
+	};
+}
+/**
+* Fix path for per-action tool calls.
+*
+* LLMs often make mistakes with per-action tools:
+* 1. Put tool name in path: /.actions/afs_action_send → /.actions/send
+* 2. Drop mount prefix: /default/conversations/123 → /telegram/default/conversations/123
+*
+* Uses discovered pathPattern to auto-correct missing mount prefixes.
+* Mutates call.args.path in place.
+*/
+function fixPerActionPath(call, schemasByAction) {
+	const path = call.args.path;
+	if (!path) return;
+	const realName = call.toolName.slice(11).replace(/_/g, "-");
+	const marker = "/.actions/";
+	const idx = path.lastIndexOf(marker);
+	if (idx !== -1) {
+		const currentAction = path.slice(idx + 10).split("/")[0];
+		if (currentAction && currentAction !== realName) call.args.path = path.slice(0, idx) + marker + realName;
+	}
+	const schema = schemasByAction.get(realName);
+	if (!schema?.pathPattern) return;
+	const fixedPath = call.args.path;
+	const starIdx = schema.pathPattern.indexOf("*");
+	if (starIdx === -1) return;
+	const expectedPrefix = schema.pathPattern.slice(0, starIdx);
+	if (fixedPath.startsWith(expectedPrefix)) return;
+	for (let i = 1; i < expectedPrefix.length; i++) if (expectedPrefix[i] === "/" && fixedPath.startsWith(expectedPrefix.slice(i))) {
+		call.args.path = expectedPrefix.slice(0, i) + fixedPath;
+		return;
+	}
+}
+/** Extract exec args from tool call: try nested `args` field first, fall back to all fields except `path`. */
+function extractExecArgs(callArgs) {
+	if (callArgs.args && typeof callArgs.args === "object" && !Array.isArray(callArgs.args)) return callArgs.args;
+	const { path: _, ...rest } = callArgs;
+	return rest;
+}
+/**
+* Discover available actions and their inputSchemas at startup.
+*
+* Strategy (per exec-capable tool entry):
+* 1. Instance-probe: list basePath to find a child, then list its .actions/
+* 2. Capabilities fallback: walk up path hierarchy to find /.meta/.capabilities,
+*    extract action schemas from the manifest's catalog entries
+*
+* Results are used to generate per-action tools with explicit typed parameters.
+* Best-effort: failures are silently ignored and the generic afs_exec fallback remains.
+*/
+async function discoverActionSchemas(tools, deps) {
+	const schemas = [];
+	const discoveredPaths = /* @__PURE__ */ new Set();
+	const discoveredActions = /* @__PURE__ */ new Set();
+	for (const tool of tools) {
+		if (!tool.ops.includes("exec")) continue;
+		const basePath = tool.path.replace(/\/?\*+$/, "");
+		if (!basePath || discoveredPaths.has(basePath)) continue;
+		discoveredPaths.add(basePath);
+		try {
+			if (basePath.endsWith("/.actions")) {
+				await discoverFromActionsDir(tool, basePath, discoveredActions, schemas, deps);
+				continue;
+			}
+			if (!await discoverViaInstanceProbe(tool, basePath, discoveredActions, schemas, deps)) await discoverViaCapabilities(tool, basePath, discoveredActions, schemas, deps);
+		} catch {}
+	}
+	return schemas;
+}
+/** Fast path: tool path already ends with /.actions/* — list the directory directly. */
+async function discoverFromActionsDir(tool, actionsPath, discoveredActions, schemas, deps) {
+	const result = await deps.callAFS("list", actionsPath);
+	if (!result.success) return;
+	const actions = extractEntries(result.data);
+	for (const action of actions) {
+		const name = extractActionNameFromEntry(action);
+		if (!name || discoveredActions.has(name)) continue;
+		discoveredActions.add(name);
+		schemas.push({
+			actionName: name,
+			description: action.meta?.description || `Execute ${name}`,
+			pathPattern: `${tool.path.replace(/\*+$/, name)}`,
+			inputSchema: action.meta?.inputSchema
+		});
+	}
+}
+/** Strategy 1: list basePath, pick first child, list its .actions/ */
+async function discoverViaInstanceProbe(tool, basePath, discoveredActions, schemas, deps) {
+	const listResult = await deps.callAFS("list", basePath);
+	if (!listResult.success) return false;
+	const entries = extractEntries(listResult.data);
+	if (entries.length === 0) return false;
+	const mcpTools = entries.filter((e) => e.meta?.kind === "mcp:tool" || e.meta?.kinds?.includes?.("mcp:tool"));
+	if (mcpTools.length > 0) {
+		let found$1 = false;
+		for (const mcpTool of mcpTools) {
+			const name = mcpTool.meta?.mcp?.name || extractActionNameFromEntry(mcpTool);
+			if (!name || discoveredActions.has(name)) continue;
+			discoveredActions.add(name);
+			found$1 = true;
+			const toolPath = mcpTool.path || `${basePath}/${name}`;
+			schemas.push({
+				actionName: name,
+				description: mcpTool.meta?.description || `Execute ${name}`,
+				pathPattern: toolPath,
+				inputSchema: mcpTool.meta?.inputSchema
+			});
+		}
+		return found$1;
+	}
+	const firstChild = entries[0];
+	const childPath = firstChild.path || firstChild.id;
+	if (!childPath) return false;
+	const actionsPath = `${childPath}/.actions`;
+	const actionsResult = await deps.callAFS("list", actionsPath);
+	if (!actionsResult.success) return false;
+	const actions = extractEntries(actionsResult.data);
+	let found = false;
+	for (const action of actions) {
+		const name = extractActionNameFromEntry(action);
+		if (!name || discoveredActions.has(name)) continue;
+		discoveredActions.add(name);
+		found = true;
+		schemas.push({
+			actionName: name,
+			description: action.meta?.description || `Execute ${name}`,
+			pathPattern: `${tool.path}/.actions/${name}`,
+			inputSchema: action.meta?.inputSchema
+		});
+	}
+	return found;
+}
+/**
+* Strategy 2: walk up path hierarchy to find a provider's /.meta/.capabilities,
+* then extract action schemas from the manifest's catalog + inputSchema.
+*
+* For a tool path like /telegram/default/conversations/*, tries:
+*   /telegram/default/conversations/.meta/.capabilities
+*   /telegram/default/.meta/.capabilities
+*   /telegram/.meta/.capabilities
+*/
+async function discoverViaCapabilities(tool, basePath, discoveredActions, schemas, deps) {
+	const segments = basePath.split("/").filter(Boolean);
+	for (let depth = segments.length; depth >= 1; depth--) {
+		const capsPath = `${`/${segments.slice(0, depth).join("/")}`}/.meta/.capabilities`;
+		try {
+			const result = await deps.callAFS("read", capsPath);
+			if (!result.success) continue;
+			const content = extractCapabilitiesContent(result.data);
+			if (!content?.actions) continue;
+			let found = false;
+			for (const actionGroup of content.actions) {
+				const catalog = actionGroup.catalog;
+				if (!Array.isArray(catalog)) continue;
+				for (const entry of catalog) {
+					const name = entry.name;
+					if (!name || discoveredActions.has(name)) continue;
+					discoveredActions.add(name);
+					found = true;
+					schemas.push({
+						actionName: name,
+						description: entry.description || `Execute ${name}`,
+						pathPattern: `${tool.path}/.actions/${name}`,
+						inputSchema: entry.inputSchema
+					});
+				}
+			}
+			if (found) return true;
+		} catch {}
+	}
+	return false;
+}
+/** Extract capabilities content from a read result (may be nested in data.content or data directly). */
+function extractCapabilitiesContent(data) {
+	if (!data || typeof data !== "object") return null;
+	const d = data;
+	if (d.actions) return d;
+	if (d.content && typeof d.content === "object" && d.content.actions) return d.content;
+	return null;
+}
+/** Extract entries array from callAFS response data (may be raw array or wrapped). */
+function extractEntries(data) {
+	if (Array.isArray(data)) return data;
+	if (data && typeof data === "object" && Array.isArray(data.data)) return data.data;
+	return [];
+}
+/** Extract action name from an action entry (from path or id). */
+function extractActionNameFromEntry(entry) {
+	if (entry.meta?.name) return entry.meta.name;
+	const path = entry.path || entry.id || "";
+	const idx = path.lastIndexOf("/.actions/");
+	if (idx !== -1) return path.slice(idx + 10).split("/")[0];
+	if (entry.id && !entry.id.includes("/")) return entry.id;
+}
+/** Normalize an in-memory message (AigneHub camelCase) to canonical JSONL format (OpenAI snake_case). */
+function normalizeForHistory(msg) {
+	const role = msg.role;
+	if (role === "system") return null;
+	if (role === "user") return {
+		role: "user",
+		content: String(msg.content ?? "")
+	};
+	if (role === "assistant") {
+		const result = {
+			role: "assistant",
+			content: String(msg.content ?? "")
+		};
+		const rawToolCalls = msg.toolCalls ?? msg.tool_calls;
+		if (rawToolCalls?.length) result.tool_calls = rawToolCalls.map((tc) => {
+			const fn = tc.function;
+			const rawArgs = fn?.arguments ?? tc.args;
+			return {
+				id: tc.id ?? tc.toolCallId ?? "",
+				type: "function",
+				function: {
+					name: fn?.name ?? tc.toolName ?? "",
+					arguments: typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs ?? {})
+				}
+			};
+		});
+		return result;
+	}
+	if (role === "tool") return {
+		role: "tool",
+		tool_call_id: msg.tool_call_id ?? msg.toolCallId ?? "",
+		content: String(msg.content ?? "")
+	};
+	return null;
+}
+async function runAgentLoop(params, deps) {
+	const maxRounds = params.budget?.max_rounds ?? DEFAULT_MAX_ROUNDS;
+	const actionsPerRound = params.budget?.actions_per_round ?? DEFAULT_ACTIONS_PER_ROUND;
+	const tokenBudget = params.budget?.total_tokens ?? Number.POSITIVE_INFINITY;
+	const actionSchemas = await discoverActionSchemas(params.tools, deps);
+	const schemasByAction = /* @__PURE__ */ new Map();
+	for (const s of actionSchemas) schemasByAction.set(s.actionName, s);
+	const toolSchema = buildToolSchema(params.tools, actionSchemas);
+	let history = [];
+	if (params.session && deps.loadHistory) try {
+		history = await deps.loadHistory(params.session);
+	} catch {}
+	const messages = [];
+	if (params.system) messages.push({
+		role: "system",
+		content: params.system
+	});
+	for (const msg of history) messages.push({ ...msg });
+	messages.push({
+		role: "user",
+		content: params.task
+	});
+	const saveSession = async () => {
+		if (!params.session || !deps.saveHistory) return;
+		try {
+			const toSave = [];
+			for (const msg of messages) {
+				const normalized = normalizeForHistory(msg);
+				if (normalized) toSave.push(normalized);
+			}
+			await deps.saveHistory(params.session, toSave);
+		} catch {}
+	};
+	const trace = [];
+	let totalTokens = 0;
+	let totalActions = 0;
+	for (let round = 1; round <= maxRounds; round++) {
+		const llmArgs = { messages: [...messages] };
+		if (toolSchema.length > 0) {
+			llmArgs.tools = toolSchema;
+			llmArgs.toolChoice = "auto";
+		}
+		const llmResult = await deps.callLLM(llmArgs);
+		if (!llmResult.success) {
+			const errMsg = llmResult.data?.error ?? llmResult.error?.message ?? "unknown error";
+			trace.push({
+				round,
+				tool_calls: [],
+				tokens: {
+					input: 0,
+					output: 0
+				}
+			});
+			await saveSession();
+			return {
+				status: "error",
+				error: `LLM call failed: ${errMsg}`,
+				rounds: round,
+				total_actions: totalActions,
+				total_tokens: totalTokens,
+				trace
+			};
+		}
+		const data = llmResult.data;
+		const inputTokens = data.inputTokens ?? 0;
+		const outputTokens = data.outputTokens ?? 0;
+		totalTokens += inputTokens + outputTokens;
+		const text = data.text;
+		const rawToolCalls = data.toolCalls;
+		if (!rawToolCalls || rawToolCalls.length === 0) {
+			trace.push({
+				round,
+				tool_calls: [],
+				tokens: {
+					input: inputTokens,
+					output: outputTokens
+				}
+			});
+			messages.push({
+				role: "assistant",
+				content: text ?? ""
+			});
+			await saveSession();
+			return {
+				status: "completed",
+				result: text ?? "",
+				rounds: round,
+				total_actions: totalActions,
+				total_tokens: totalTokens,
+				trace
+			};
+		}
+		if (totalTokens > tokenBudget) {
+			trace.push({
+				round,
+				tool_calls: [],
+				tokens: {
+					input: inputTokens,
+					output: outputTokens
+				}
+			});
+			await saveSession();
+			return {
+				status: "budget_exhausted",
+				result: text,
+				rounds: round,
+				total_actions: totalActions,
+				total_tokens: totalTokens,
+				trace
+			};
+		}
+		const toolCalls = rawToolCalls.map(normalizeToolCall);
+		messages.push({
+			role: "assistant",
+			content: text ?? "",
+			toolCalls: rawToolCalls
+		});
+		const roundCalls = toolCalls.slice(0, actionsPerRound);
+		const droppedCalls = toolCalls.slice(actionsPerRound);
+		const traceEntries = [];
+		const validatedCalls = [];
+		for (const call of roundCalls) {
+			const op = toolNameToOp(call.toolName);
+			if (!op) {
+				validatedCalls.push({
+					call,
+					op: "unknown",
+					valid: false,
+					reason: `Unknown tool: ${call.toolName}`
+				});
+				continue;
+			}
+			if (call.toolName.startsWith("afs_action_")) fixPerActionPath(call, schemasByAction);
+			const path = call.args.path;
+			if (!path) {
+				validatedCalls.push({
+					call,
+					op,
+					valid: false,
+					reason: "Missing path argument"
+				});
+				continue;
+			}
+			const validation = validateToolCall(path, op, params.tools);
+			if (!validation.allowed) {
+				validatedCalls.push({
+					call,
+					op,
+					valid: false,
+					reason: validation.reason
+				});
+				continue;
+			}
+			const missingArg = REQUIRED_ARGS[op]?.find((arg) => !(arg in call.args));
+			if (missingArg) {
+				validatedCalls.push({
+					call,
+					op,
+					valid: false,
+					reason: `Missing required argument '${missingArg}' for ${op}`
+				});
+				continue;
+			}
+			validatedCalls.push({
+				call,
+				op,
+				valid: true
+			});
+		}
+		const ashCalls = [];
+		const directCalls = [];
+		const errorResults = [];
+		for (const { call, op, valid, reason } of validatedCalls) {
+			if (!valid) {
+				errorResults.push({
+					id: call.toolCallId,
+					error: reason ?? "Validation failed"
+				});
+				traceEntries.push({
+					id: call.toolCallId,
+					name: call.toolName,
+					path: String(call.args.path ?? ""),
+					status: "error",
+					error: reason
+				});
+				continue;
+			}
+			const path = call.args.path;
+			if (ASH_OPS.has(op)) ashCalls.push({
+				id: call.toolCallId,
+				op,
+				path,
+				args: extractExecArgs(call.args)
+			});
+			else directCalls.push({
+				call,
+				op
+			});
+			traceEntries.push({
+				id: call.toolCallId,
+				name: call.toolName,
+				path,
+				status: "ok"
+			});
+		}
+		const ashResults = {};
+		if (ashCalls.length > 0) {
+			const source = generateAsh(ashCalls, round);
+			const ashResult = await deps.runAsh(source, {
+				returnWrittenData: true,
+				skipWritePrefix: RESULTS_PREFIX
+			});
+			if (ashResult.success && ashResult.data?.writtenData) {
+				const writtenData = ashResult.data.writtenData;
+				for (const call of ashCalls) {
+					const data$1 = writtenData[`${RESULTS_PREFIX}${call.id}`];
+					ashResults[call.id] = data$1 ? JSON.stringify(data$1) : "No result";
+				}
+			} else for (const call of ashCalls) ashResults[call.id] = `ASH execution error: ${ashResult.data?.error ?? "unknown"}`;
+		}
+		const directResults = {};
+		for (const { call, op } of directCalls) {
+			const path = call.args.path;
+			const directArgs = { ...call.args };
+			delete directArgs.path;
+			try {
+				const result = await deps.callAFS(op, path, directArgs);
+				directResults[call.toolCallId] = result.success ? JSON.stringify(result.data) : `Error: ${result.data?.error ?? "failed"}`;
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				directResults[call.toolCallId] = `Error: ${msg}`;
+			}
+		}
+		for (const call of roundCalls) {
+			const errorEntry = errorResults.find((e) => e.id === call.toolCallId);
+			if (errorEntry) messages.push({
+				role: "tool",
+				tool_call_id: call.toolCallId,
+				content: `Error: ${errorEntry.error}`
+			});
+			else if (ashResults[call.toolCallId] !== void 0) messages.push({
+				role: "tool",
+				tool_call_id: call.toolCallId,
+				content: ashResults[call.toolCallId]
+			});
+			else if (directResults[call.toolCallId] !== void 0) messages.push({
+				role: "tool",
+				tool_call_id: call.toolCallId,
+				content: directResults[call.toolCallId]
+			});
+			else messages.push({
+				role: "tool",
+				tool_call_id: call.toolCallId,
+				content: "Error: No result returned for this tool call"
+			});
+		}
+		for (const call of droppedCalls) messages.push({
+			role: "tool",
+			tool_call_id: call.toolCallId,
+			content: `Error: Tool call dropped — exceeded actions_per_round limit (${actionsPerRound}). Retry in next round.`
+		});
+		totalActions += roundCalls.length - errorResults.length;
+		trace.push({
+			round,
+			tool_calls: traceEntries,
+			tokens: {
+				input: inputTokens,
+				output: outputTokens
+			}
+		});
+	}
+	await saveSession();
+	return {
+		status: "budget_exhausted",
+		rounds: maxRounds,
+		total_actions: totalActions,
+		total_tokens: totalTokens,
+		trace
+	};
+}
+
+//#endregion
+export { runAgentLoop };
+//# sourceMappingURL=agent-run-CXJQ0jPV.mjs.map