@aigne/agent-runtime 1.12.0-beta.5

package/dist/program/agent-runner-registry.cjs

@@ -0,0 +1,314 @@
+const require_budget = require('../agent-runners/budget.cjs');
+const require_memory_archive = require('../agent-runners/memory-archive.cjs');
+const require_ash_runner = require('../agent-runners/ash-runner.cjs');
+const require_scratchpad_afs = require('../agent-runners/scratchpad-afs.cjs');
+const require_hooks = require('../agent-runners/hooks.cjs');
+const require_memory_afs = require('../agent-runners/memory-afs.cjs');
+const require_agent_messages_tools = require('./agent-messages-tools.cjs');
+const require_scoped_afs = require('./scoped-afs.cjs');
+require('./session-hierarchy.cjs');
+const require_code_runner = require('../agent-runners/code-runner.cjs');
+const require_stream_router = require('../agent-runners/stream-router.cjs');
+const require_system_prompt = require('../agent-runners/system-prompt.cjs');
+const require_team_runner = require('../agent-runners/team-runner.cjs');
+const require_agent_action = require('./agent-action.cjs');
+const require_orchestrator_runner = require('../agent-runners/orchestrator-runner.cjs');
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_agent = require("@aigne/afs-agent");
+
+//#region src/program/agent-runner-registry.ts
+const log = (0, _aigne_afs.makeNsLog)("agent-runtime");
+/**
+* B10 — extract a filesystem-safe scratch key from a raw session id.
+*
+* The AI runner accepts either a bare id (`abc`) or a full session path
+* (`/instance/.sessions/agent/abc`). Scratch paths must not contain separators,
+* so we take the last non-empty path component.
+*/
+function scratchKeyFromSession(sessionId) {
+	const trimmed = sessionId.replace(/\/+$/, "");
+	const idx = trimmed.lastIndexOf("/");
+	return idx >= 0 ? trimmed.slice(idx + 1) : trimmed;
+}
+async function maybeProvisionScratch(afs, manifest, sessionId, runId) {
+	if (!manifest.scratch || !sessionId) return null;
+	const key = scratchKeyFromSession(sessionId);
+	if (!key) return null;
+	try {
+		return await require_scratchpad_afs.provisionScratchViaAFS(afs, key, runId);
+	} catch (err) {
+		log.warn(`[agent-runner] scratchpad provisioning failed for session=${key} runId=${runId}:`, err instanceof Error ? err.message : err);
+		return null;
+	}
+}
+function injectScratchPath(result, layout) {
+	const data = result.data ?? {};
+	data.scratch_path = layout.basePath;
+	const meta = data._meta && typeof data._meta === "object" ? data._meta : {};
+	meta.scratch_path = layout.basePath;
+	data._meta = meta;
+	result.data = data;
+	return result;
+}
+/**
+* Resolve the effective tool whitelist for a runner. Phase 6 collapsed the
+* parent-tools fallback: `ctx.afs.scope.allowedTools` is the single source
+* of truth (computed by `projectForChild`). Callers without a scope fall
+* back to the manifest's own tools.
+*/
+function resolveEffectiveTools(context, childTools) {
+	const scope = context.afs.scope;
+	if (scope) return [...scope.allowedTools];
+	return childTools;
+}
+function withLifecycleHooks(runner) {
+	return async (input, context) => {
+		const blockletId = require_system_prompt.extractBlockletId(context.mountPath);
+		const scope = context.afs.scope;
+		const chainDepth = scope?.chainDepth ?? 0;
+		const dispatcher = require_hooks.createHookDispatcher(context.afs, context.manifest.hooks, {
+			mountPath: context.mountPath,
+			blockletId,
+			session: scope?.session ?? context.session,
+			chainDepth
+		});
+		const enrichedContext = {
+			...context,
+			hookDispatcher: dispatcher
+		};
+		await dispatcher.fireOnStart(input);
+		try {
+			const result = await runner(input, enrichedContext);
+			await dispatcher.fireOnSuccess(result);
+			return result;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			await dispatcher.fireOnError({
+				code: "RUNNER_ERROR",
+				message
+			});
+			throw err;
+		}
+	};
+}
+const aiRunner = async (input, context) => {
+	const { manifest } = context;
+	const effectiveAfs = require_memory_afs.mountManifestMemory(context.afs, manifest.memory, context.mountPath);
+	const inputKey = manifest.inputKey ?? "message";
+	const task = String(input[inputKey] ?? "");
+	const callerBlockletId = require_system_prompt.extractBlockletId(context.mountPath);
+	const chain = context.chain ?? [];
+	(0, _aigne_afs_agent.checkSpawnDepth)(chain, manifest.maxSpawnDepth);
+	const { session: sessionId, parentSession: scopedParentSession } = require_scoped_afs.resolveChildSession(context.afs, context, _aigne_afs_agent.deriveChildSession);
+	const tools = resolveEffectiveTools(context, require_scoped_afs.normalizeManifestTools(manifest)).map((t) => ({
+		path: t.path,
+		...t.ops ? { ops: t.ops } : {},
+		...t.maxDepth != null ? { maxDepth: t.maxDepth } : {},
+		...t.exclude_actions ? { exclude_actions: t.exclude_actions } : {}
+	}));
+	const messagingPath = require_agent_messages_tools.MESSAGING_TOOLS_GLOB;
+	if (!tools.some((t) => t.path === messagingPath || t.path === require_agent_messages_tools.MESSAGING_TOOLS_ROOT)) tools.push({
+		path: messagingPath,
+		ops: ["exec"]
+	});
+	if (manifest.memory) {
+		if (!tools.some((t) => t.path === "/memory/**" || t.path === "/memory" || t.path.startsWith("/memory/"))) tools.push({
+			path: "/memory/**",
+			ops: [
+				"read",
+				"list",
+				"exec"
+			]
+		});
+	}
+	const model = typeof manifest.model === "string" ? manifest.model : manifest.model ? `${manifest.model.provider}/${manifest.model.name}` : "/dev/ai/.actions/chat";
+	const session = sessionId ? sessionId.startsWith("/") ? sessionId : `/instance/.sessions/agent/${sessionId}` : void 0;
+	const scopeBudget = context.afs.scope?.budget;
+	const resolved = require_budget.resolveBudget({
+		manifest: manifest.budget,
+		parentRemaining: scopeBudget ? Math.max(0, scopeBudget.limit - scopeBudget.consumed) : void 0
+	});
+	const tracker = require_budget.createBudgetTracker(resolved);
+	let system;
+	if (manifest.instructions) try {
+		const instrPath = manifest.instructions.startsWith("/") ? manifest.instructions : `/packages/${manifest.instructions}`;
+		const r = await effectiveAfs.read(instrPath);
+		system = String(r?.data?.content ?? "");
+		if (!system.trim()) system = void 0;
+	} catch {}
+	if (context.systemAppend) system = system ? `${system}\n\n${context.systemAppend}` : context.systemAppend;
+	else if (require_memory_archive.isHandoffReadThroughEnabled(manifest.memory) && !context.afs?.scope?.memoryDomain) {
+		const manifestDomain = manifest.memory && typeof manifest.memory === "object" ? manifest.memory.domain : void 0;
+		if (manifestDomain) {
+			const appendix = require_memory_archive.formatRecallForPrompt(await require_memory_archive.recallForHandoff({
+				afs: effectiveAfs,
+				domain: manifestDomain
+			}));
+			if (appendix) system = system ? `${system}\n\n${appendix}` : appendix;
+		}
+	}
+	const execArgs = {
+		task,
+		model,
+		tools,
+		budget: {
+			max_rounds: resolved.maxRounds,
+			total_tokens: resolved.totalTokens
+		},
+		session,
+		system,
+		skill_paths: manifest.skillPaths,
+		tool_choice: manifest.toolChoice,
+		exec_context: callerBlockletId ? { from: callerBlockletId } : void 0,
+		_scope_afs: effectiveAfs,
+		_parent_session: scopedParentSession,
+		_chain: [...chain, sessionId ?? "root"],
+		_abort_signal: tracker.signal
+	};
+	const streamNodeId = typeof input._stream_node_id === "string" ? input._stream_node_id : void 0;
+	const autoRouter = !input._on_tool_progress ? require_stream_router.createStreamProgressRouter({
+		afs: effectiveAfs,
+		sessionPath: require_stream_router.detectUISessionPath(session),
+		nodeId: streamNodeId
+	}) : null;
+	const baseProgress = input._on_tool_progress;
+	const skillStarts = !!(context.hookDispatcher && (manifest.hooks?.onSkillStart || manifest.hooks?.onSkillEnd)) ? /* @__PURE__ */ new Map() : null;
+	const fireSkillHooks = skillStarts ? (event) => {
+		const dispatcher = context.hookDispatcher;
+		const calls = event.calls;
+		if (!calls) return;
+		if (event.type === "tool_start") for (const c of calls) {
+			skillStarts.set(c.id, Date.now());
+			dispatcher.fireOnSkillStart(c.tool, c.args ?? {});
+		}
+		else if (event.type === "tool_result") for (const c of calls) {
+			const started = skillStarts.get(c.id);
+			const durationMs = started ? Date.now() - started : 0;
+			skillStarts.delete(c.id);
+			dispatcher.fireOnSkillEnd(c.tool, {
+				status: c.status === "error" ? "error" : "ok",
+				...c.result !== void 0 ? { result: c.result } : {},
+				...c.error !== void 0 ? { error: c.error } : {},
+				durationMs
+			});
+		}
+	} : null;
+	const listeners = [];
+	if (fireSkillHooks) listeners.push(fireSkillHooks);
+	if (baseProgress) listeners.push(baseProgress);
+	else if (autoRouter) listeners.push((event) => autoRouter.onProgress(event));
+	let composedProgress;
+	if (listeners.length === 1) composedProgress = listeners[0];
+	else if (listeners.length > 1) composedProgress = (event) => {
+		for (const l of listeners) l(event);
+	};
+	if (require_memory_archive.isMemoryArchiveEnabled(manifest.memory)) composedProgress = require_memory_archive.wrapToolProgress(composedProgress, {
+		afs: effectiveAfs,
+		session: sessionId ?? "default"
+	});
+	if (composedProgress) execArgs._on_tool_progress = composedProgress;
+	if (input.on_progress) execArgs.on_progress = input.on_progress;
+	if (typeof input._ui_session === "string") execArgs._ui_session = input._ui_session;
+	for (const [key, value] of Object.entries(input)) {
+		if (key === inputKey) continue;
+		if (key.startsWith("_")) continue;
+		if (key in execArgs) continue;
+		execArgs[key] = value;
+	}
+	const runId = crypto.randomUUID();
+	const scratchLayout = await maybeProvisionScratch(effectiveAfs, manifest, sessionId, runId);
+	if (scratchLayout) {
+		execArgs._scratch_path = scratchLayout.basePath;
+		execArgs._scratch_run_id = runId;
+	}
+	const result = await effectiveAfs.exec("/dev/agent/.actions/run", execArgs, {});
+	if (autoRouter) await autoRouter.flush();
+	const tokensUsed = result?.data?.total_tokens ?? result?.data?._meta?.tokens_used ?? 0;
+	tracker.consumeTokens(tokensUsed);
+	if (resolved.warnings.length > 0) {
+		const data = result?.data ?? {};
+		const meta = data._meta ?? {};
+		meta.warnings = [...Array.isArray(meta.warnings) ? meta.warnings : [], ...resolved.warnings];
+		data._meta = meta;
+	}
+	if (scratchLayout) injectScratchPath(result, scratchLayout);
+	return result;
+};
+const ashRunner = async (input, context) => {
+	const { manifest } = context;
+	const effectiveAfs = context.afs;
+	const chain = context.chain ?? [];
+	(0, _aigne_afs_agent.checkSpawnDepth)(chain, manifest.maxSpawnDepth);
+	const { session: sessionId, parentSession: scopedParentSession } = require_scoped_afs.resolveChildSession(context.afs, context, _aigne_afs_agent.deriveChildSession);
+	return await require_ash_runner.runAshAgent({
+		afs: effectiveAfs,
+		manifest,
+		input,
+		session: sessionId,
+		parentSession: scopedParentSession,
+		chain: [...chain, sessionId ?? "root"],
+		mountPath: context.mountPath
+	});
+};
+const teamRunner = async (input, context) => {
+	const { manifest } = context;
+	const chain = context.chain ?? [];
+	(0, _aigne_afs_agent.checkSpawnDepth)(chain, manifest.maxSpawnDepth);
+	const { session: sessionId, parentSession: scopedParentSession } = require_scoped_afs.resolveChildSession(context.afs, context, _aigne_afs_agent.deriveChildSession);
+	return await require_team_runner.runTeamAgent(input, {
+		...context,
+		session: sessionId,
+		parentSession: scopedParentSession,
+		chain: [...chain, sessionId ?? "root"]
+	});
+};
+const orchestratorRunner = async (input, context) => {
+	const { manifest } = context;
+	const chain = context.chain ?? [];
+	(0, _aigne_afs_agent.checkSpawnDepth)(chain, manifest.maxSpawnDepth);
+	const { session: sessionId, parentSession: scopedParentSession } = require_scoped_afs.resolveChildSession(context.afs, context, _aigne_afs_agent.deriveChildSession);
+	return await require_orchestrator_runner.runOrchestratorAgent(input, {
+		...context,
+		session: sessionId,
+		parentSession: scopedParentSession,
+		chain: [...chain, sessionId ?? "root"]
+	});
+};
+const runners = {
+	ai: withLifecycleHooks(aiRunner),
+	ash: withLifecycleHooks(ashRunner),
+	team: withLifecycleHooks(teamRunner),
+	orchestrator: withLifecycleHooks(orchestratorRunner),
+	code: withLifecycleHooks(require_code_runner.codeRunner)
+};
+function getRunnerForType(type) {
+	const runner = runners[type];
+	if (!runner) throw new Error(`RUNNER_NOT_IMPLEMENTED: agent type "${type}" is not yet supported`);
+	return runner;
+}
+function registerAgentActions(runtimeAFS, manifest, mountPath, options) {
+	const handlers = require_agent_action.createAgentActionHandlers(manifest, mountPath, { actionPrefix: options?.actionPrefix });
+	const afs = runtimeAFS;
+	if (typeof afs.registerCustomAction !== "function") return;
+	const prefix = options?.actionPrefix;
+	const runKey = prefix ? `${prefix}-run` : "run";
+	const cancelKey = prefix ? `${prefix}-cancel` : "cancel";
+	const statusKey = prefix ? `${prefix}-status` : "status";
+	afs.registerCustomAction(runKey, handlers.run.entry, async (args) => {
+		return handlers.run.handler(args, {
+			afs: runtimeAFS,
+			mountPath,
+			manifest
+		});
+	});
+	afs.registerCustomAction(cancelKey, handlers.cancel.entry, async (args) => {
+		return handlers.cancel.handler(args);
+	});
+	afs.registerCustomAction(statusKey, handlers.status.entry, async (args) => {
+		return handlers.status.handler(args);
+	});
+}
+
+//#endregion
+exports.getRunnerForType = getRunnerForType;
+exports.registerAgentActions = registerAgentActions;

package/dist/program/agent-runner-registry.d.cts

@@ -0,0 +1,52 @@
+import { HookDispatcher } from "../agent-runners/hooks.cjs";
+import { AFSExecResult, AFSRoot, AgentManifest } from "@aigne/afs";
+
+//#region src/program/agent-runner-registry.d.ts
+/**
+ * Runner context — shape consumed by every agent runner.
+ *
+ * Phase 6 collapsed the grab-bag of parent-projection fields now that
+ * `AgentScope` carries the equivalent state:
+ *
+ *   - `context.afs.scope.allowedTools`   — tool whitelist
+ *   - `context.afs.scope.budget`         — per-scope budget limit/consumed
+ *   - `context.afs.scope.memoryDomain`   — per-scope memory provider
+ *   - `context.afs.scope.chainDepth`     — spawn-chain depth counter
+ *
+ * The remaining `mountPath` / `session` / `parentSession` / `chain` /
+ * `systemAppend` fields still live on the context because their natural
+ * home on `AgentScope` hasn't been added yet — see the follow-up note in
+ * `planning/agent-runtime-afs-first/tasks.md` (P7: scope schema additions).
+ */
+interface RunnerContext {
+  afs: AFSRoot;
+  /** Blocklet mount root — used for instructions / script path resolution. */
+  mountPath: string;
+  manifest: AgentManifest;
+  /** @deprecated (P7) read from `ctx.afs.scope.session` once scope.session is the only source. */
+  session?: string;
+  /** @deprecated (P7) read from `ctx.afs.scope.parentSession`. */
+  parentSession?: string;
+  /** @deprecated (P7) derive from `ctx.afs.scope.chainDepth`. */
+  chain?: string[];
+  hookDispatcher?: HookDispatcher;
+  /** @deprecated (P7) caller-supplied system-prompt suffix; moves to scope in P7. */
+  systemAppend?: string;
+}
+type AgentRunner = (input: Record<string, unknown>, context: RunnerContext) => Promise<AFSExecResult>;
+declare function getRunnerForType(type: string): AgentRunner;
+/**
+ * Options for `registerAgentActions`.
+ *
+ * `actionPrefix` lets one blocklet's runtime AFS host many independent
+ * agents (e.g. nested manifests under `agents/<n>/`). Each prefix
+ * registers its own `${prefix}-run`/`${prefix}-cancel`/`${prefix}-status`
+ * customAction keys, so they coexist without colliding on the bare names.
+ */
+interface RegisterAgentActionsOptions {
+  actionPrefix?: string;
+}
+declare function registerAgentActions(runtimeAFS: AFSRoot, manifest: AgentManifest, mountPath: string, options?: RegisterAgentActionsOptions): void;
+//#endregion
+export { AgentRunner, RegisterAgentActionsOptions, RunnerContext, getRunnerForType, registerAgentActions };
+//# sourceMappingURL=agent-runner-registry.d.cts.map

package/dist/program/agent-runner-registry.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner-registry.d.cts","names":[],"sources":["../../src/program/agent-runner-registry.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAkDiB,aAAA;EACf,GAAA,EAAK,OAAA;EA6EgB;EA3ErB,SAAA;EACA,QAAA,EAAU,aAAA;EA4ED;EA1ET,OAAA;EA2EG;EAzEH,aAAA;EAyEU;EAvEV,KAAA;EACA,cAAA,GAAiB,cAAA;EAqER;EAnET,YAAA;AAAA;AAAA,KAiEU,WAAA,IACV,KAAA,EAAO,MAAA,mBACP,OAAA,EAAS,aAAA,KACN,OAAA,CAAQ,aAAA;AAAA,iBA6aG,gBAAA,CAAiB,IAAA,WAAe,WAAA;;AAAhD;;;;;AAgBA;;UAAiB,2BAAA;EACf,YAAA;AAAA;AAAA,iBAGc,oBAAA,CACd,UAAA,EAAY,OAAA,EACZ,QAAA,EAAU,aAAA,EACV,SAAA,UACA,OAAA,GAAU,2BAAA"}

package/dist/program/agent-runner-registry.d.mts

@@ -0,0 +1,52 @@
+import { HookDispatcher } from "../agent-runners/hooks.mjs";
+import { AFSExecResult, AFSRoot, AgentManifest } from "@aigne/afs";
+
+//#region src/program/agent-runner-registry.d.ts
+/**
+ * Runner context — shape consumed by every agent runner.
+ *
+ * Phase 6 collapsed the grab-bag of parent-projection fields now that
+ * `AgentScope` carries the equivalent state:
+ *
+ *   - `context.afs.scope.allowedTools`   — tool whitelist
+ *   - `context.afs.scope.budget`         — per-scope budget limit/consumed
+ *   - `context.afs.scope.memoryDomain`   — per-scope memory provider
+ *   - `context.afs.scope.chainDepth`     — spawn-chain depth counter
+ *
+ * The remaining `mountPath` / `session` / `parentSession` / `chain` /
+ * `systemAppend` fields still live on the context because their natural
+ * home on `AgentScope` hasn't been added yet — see the follow-up note in
+ * `planning/agent-runtime-afs-first/tasks.md` (P7: scope schema additions).
+ */
+interface RunnerContext {
+  afs: AFSRoot;
+  /** Blocklet mount root — used for instructions / script path resolution. */
+  mountPath: string;
+  manifest: AgentManifest;
+  /** @deprecated (P7) read from `ctx.afs.scope.session` once scope.session is the only source. */
+  session?: string;
+  /** @deprecated (P7) read from `ctx.afs.scope.parentSession`. */
+  parentSession?: string;
+  /** @deprecated (P7) derive from `ctx.afs.scope.chainDepth`. */
+  chain?: string[];
+  hookDispatcher?: HookDispatcher;
+  /** @deprecated (P7) caller-supplied system-prompt suffix; moves to scope in P7. */
+  systemAppend?: string;
+}
+type AgentRunner = (input: Record<string, unknown>, context: RunnerContext) => Promise<AFSExecResult>;
+declare function getRunnerForType(type: string): AgentRunner;
+/**
+ * Options for `registerAgentActions`.
+ *
+ * `actionPrefix` lets one blocklet's runtime AFS host many independent
+ * agents (e.g. nested manifests under `agents/<n>/`). Each prefix
+ * registers its own `${prefix}-run`/`${prefix}-cancel`/`${prefix}-status`
+ * customAction keys, so they coexist without colliding on the bare names.
+ */
+interface RegisterAgentActionsOptions {
+  actionPrefix?: string;
+}
+declare function registerAgentActions(runtimeAFS: AFSRoot, manifest: AgentManifest, mountPath: string, options?: RegisterAgentActionsOptions): void;
+//#endregion
+export { AgentRunner, RegisterAgentActionsOptions, RunnerContext, getRunnerForType, registerAgentActions };
+//# sourceMappingURL=agent-runner-registry.d.mts.map

package/dist/program/agent-runner-registry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner-registry.d.mts","names":[],"sources":["../../src/program/agent-runner-registry.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAkDiB,aAAA;EACf,GAAA,EAAK,OAAA;EA6EgB;EA3ErB,SAAA;EACA,QAAA,EAAU,aAAA;EA4ED;EA1ET,OAAA;EA2EG;EAzEH,aAAA;EAyEU;EAvEV,KAAA;EACA,cAAA,GAAiB,cAAA;EAqER;EAnET,YAAA;AAAA;AAAA,KAiEU,WAAA,IACV,KAAA,EAAO,MAAA,mBACP,OAAA,EAAS,aAAA,KACN,OAAA,CAAQ,aAAA;AAAA,iBA6aG,gBAAA,CAAiB,IAAA,WAAe,WAAA;;AAAhD;;;;;AAgBA;;UAAiB,2BAAA;EACf,YAAA;AAAA;AAAA,iBAGc,oBAAA,CACd,UAAA,EAAY,OAAA,EACZ,QAAA,EAAU,aAAA,EACV,SAAA,UACA,OAAA,GAAU,2BAAA"}