@tshu-w/pi-agents 0.0.0-stage → 0.1.0

package/src/agents/registry.ts

@@ -0,0 +1,257 @@
+/** The Agents loaded in this process, shared across trees: who sees whom, how targets resolve, and how messages are addressed. */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Agents } from "./agents.ts";
+import { TreeScheduler } from "./scheduler.ts";
+
+export const MESSAGE_TYPE = "pi-agents";
+export const TREE_ENTRY = "pi-agents-tree";
+
+export type AgentState = "running" | "waiting" | "queued" | "idle";
+export type Delivery = "followUp" | "steer" | "write";
+
+/** An Agent loaded in this process: a root Session or an owned child Session. */
+export interface AgentNode {
+	id: string;
+	rootId: string;
+	/** The node whose tree this node sees: its root, or the Program its Agents belong to. */
+	scopeId: string;
+	ownerId?: string;
+	/** A Program that owns Agents; no Agent sees it, but the user sees it in the task panel and the Agent viewer. */
+	program?: boolean;
+	/** Whether a Program runs in the background. */
+	background?: boolean;
+	/** When a Program started. */
+	createdAt?: string;
+	name(): string | undefined;
+	cwd(): string;
+	busy(): boolean;
+	sessionFile(): string | undefined;
+	agents: Agents;
+	/** Delivers a message to this node; used only for root Agents. */
+	receive(text: string, delivery: Delivery, messageId?: string): void;
+}
+
+export interface Entry {
+	id: string;
+	name?: string;
+	ownerId?: string;
+	cwd: string;
+	state: AgentState;
+	sessionFile?: string;
+	/** When an owned Agent was spawned. */
+	createdAt?: string;
+	/** A root Agent loaded in another process. */
+	remote?: boolean;
+}
+
+interface Shared {
+	scheduler: TreeScheduler;
+	nodes: Map<string, AgentNode>;
+	listeners?: Set<() => void>;
+	/** Work that keeps a tree busy, by the ID of its root. */
+	work?: Map<symbol, string>;
+	/** The other root Agents last listed, for short IDs shown to a root Agent. */
+	rootIds?: string[];
+}
+
+const shared = ((globalThis as Record<symbol, unknown>)[Symbol.for("pi-agents:runtime")] ??= {
+	scheduler: new TreeScheduler(),
+	nodes: new Map(),
+}) as Shared;
+// Child Sessions load their own copy of this module; keep shared state but adopt current methods.
+Object.setPrototypeOf(shared.scheduler, TreeScheduler.prototype);
+const listeners = shared.listeners ??= new Set();
+const work = shared.work ??= new Map();
+
+export const nodes = shared.nodes;
+export const scheduler = shared.scheduler;
+
+/** Calls `listener` when an Agent's state or inputs change in any tree of this process. */
+export function onTreeChange(listener: () => void): () => void {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+
+export function treeChanged(): void {
+	for (const listener of listeners) listener();
+}
+
+/** Keeps a tree busy until the returned function is called. */
+export function trackTreeWork(rootId: string): () => void {
+	const token = Symbol(rootId);
+	work.set(token, rootId);
+	treeChanged();
+	return () => {
+		if (work.delete(token)) treeChanged();
+	};
+}
+
+/** The Programs a node runs, oldest first. */
+export function programsOf(node: AgentNode): AgentNode[] {
+	return [...shared.nodes.values()]
+		.filter((program) => program.program && program.ownerId === node.id)
+		.sort((a, b) => (a.createdAt ?? "").localeCompare(b.createdAt ?? ""));
+}
+
+/** The node's running owned Agents and background Programs, with those under them. */
+export function liveWork(node: AgentNode): number {
+	let count = 0;
+	for (const entry of node.agents.owned()) {
+		if (entry.state !== "idle") count += 1;
+		const loaded = shared.nodes.get(entry.id);
+		if (loaded) count += liveWork(loaded);
+	}
+	for (const program of programsOf(node)) {
+		if (program.background) count += 1;
+		count += liveWork(program);
+	}
+	return count;
+}
+
+/** `Program <short ID>`, unique among its caller's running Programs. */
+export function programLabel(program: AgentNode): string {
+	const owner = program.ownerId === undefined ? undefined : shared.nodes.get(program.ownerId);
+	return `Program ${shortId(program.id, owner ? programsOf(owner).map((other) => other.id) : [])}`;
+}
+
+/** The shortest prefix of `id`, at least 8 characters, that none of the other `ids` starts with. */
+export function shortId(id: string, ids: Iterable<string>): string {
+	let length = Math.min(8, id.length);
+	for (const other of ids) {
+		while (other !== id && length < id.length && other.startsWith(id.slice(0, length))) length++;
+	}
+	return id.slice(0, length);
+}
+
+/** An Agent's name and short ID among `ids`, the IDs of the Agents visible to the reader. */
+export function label(agent: { id: string; name?: string }, ids: Iterable<string>): string {
+	const id = shortId(agent.id, ids);
+	return agent.name ? `${agent.name} (${id})` : id;
+}
+
+export function entryLine(entry: Entry, ids: Iterable<string>): string {
+	return `${label(entry, ids)}  ${entry.state}  ${entry.cwd}`;
+}
+
+export function rememberRoots(ids: string[]): void {
+	shared.rootIds = ids;
+}
+
+/** IDs of the Agents visible to an Agent with the given scope; a root Agent also sees the other roots. */
+export function visibleIds(scopeId: string, root: boolean): string[] {
+	const ids = treeEntries(scopeId).map((entry) => entry.id);
+	return root ? [...ids, ...(shared.rootIds ?? [])] : ids;
+}
+
+/** IDs of the Agents visible to `target`. */
+function recipientIds(target: Entry): string[] {
+	if (target.ownerId === undefined) return visibleIds(target.id, true);
+	const owner = shared.nodes.get(target.ownerId);
+	return visibleIds(owner?.program ? target.id : owner?.scopeId ?? target.id, false);
+}
+
+export interface TreeMetadata {
+	rootId: string;
+	ownerId: string;
+	scopeId?: string;
+}
+
+/** Owner, root, and scope recorded in an owned Agent's Session. */
+export function treeMetadata(ctx: ExtensionContext): TreeMetadata | undefined {
+	let metadata: TreeMetadata | undefined;
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.type === "custom" && entry.customType === TREE_ENTRY) metadata = entry.data as typeof metadata;
+	}
+	return metadata;
+}
+
+/** Visible Agents of a scope, its root first, then owned Agents depth-first. */
+export function treeEntries(scopeId: string): Entry[] {
+	const root = shared.nodes.get(scopeId);
+	if (!root) return [];
+	const entries: Entry[] = root.program ? [] : [{
+		id: root.id,
+		name: root.name(),
+		cwd: root.cwd(),
+		state: root.busy() || !treeIdle(root.rootId) ? "running" : "idle",
+		sessionFile: root.sessionFile(),
+	}];
+	const visit = (node: AgentNode) => {
+		for (const agent of node.agents.owned()) {
+			entries.push({ ...agent, ownerId: node.id });
+			const loaded = shared.nodes.get(agent.id);
+			if (loaded) visit(loaded);
+		}
+	};
+	visit(root);
+	return entries;
+}
+
+export function resolveTarget(scopeId: string, target: string): Entry {
+	return resolveIn(treeEntries(scopeId), target);
+}
+
+/** Resolves an ID, a name, or a unique ID prefix among the given visible Agents. */
+export function resolveIn(entries: Entry[], target: string): Entry {
+	const byId = entries.find((entry) => entry.id === target);
+	if (byId) return byId;
+	let matches = entries.filter((entry) => entry.name === target);
+	if (matches.length === 0) matches = entries.filter((entry) => entry.id.startsWith(target));
+	if (matches.length === 0) throw new Error(`No visible Agent matches "${target}". Use list to find Agents.`);
+	if (matches.length > 1) {
+		const ids = entries.map((entry) => entry.id);
+		throw new Error(`"${target}" matches several Agents:\n${matches.map((entry) => entryLine(entry, ids)).join("\n")}\n\nRetry with a longer ID prefix.`);
+	}
+	return matches[0]!;
+}
+
+/** Sends a message from one Agent to another visible Agent. */
+export function deliver(
+	from: { id: string; name?: string } | undefined,
+	target: Entry,
+	delivery: Delivery,
+	body: string,
+): { queued: boolean } {
+	const fromOwner = from !== undefined && target.ownerId === from.id;
+	const ids = recipientIds(target);
+	const text = from === undefined ? body : messageText(from, fromOwner, delivery, body, ids);
+	if (target.ownerId === undefined) {
+		const node = shared.nodes.get(target.id);
+		if (!node) throw new Error(`${label(target, ids)} is offline.`);
+		node.receive(text, delivery);
+		return { queued: false };
+	}
+	const owner = shared.nodes.get(target.ownerId);
+	if (!owner) throw new Error(`${label(target, ids)} is offline.`);
+	return owner.agents.accept(target.id, text, delivery, { fromOwner, notification: from === undefined });
+}
+
+export const MESSAGE_TAG = "agent-message";
+
+/** A message in an element naming its sender; an input from a sender other than the owner asks for a reply. */
+export function messageText(from: { id: string; name?: string }, fromOwner: boolean, delivery: Delivery, body: string, ids: Iterable<string>): string {
+	const note = !fromOwner && delivery !== "write" ? ' note="Reply with send"' : "";
+	return `<${MESSAGE_TAG} from="${from.name ?? shortId(from.id, ids)}" id="${shortId(from.id, ids)}"${note}>\n${body}\n</${MESSAGE_TAG}>`;
+}
+
+/**
+ * `messageId` marks a message from a root Agent in another process, so it is added once; `user`
+ * marks the user's input from the Agent viewer.
+ */
+export function customMessage(text: string, delivery: Delivery, messageId?: string, user?: boolean) {
+	return { customType: MESSAGE_TYPE, content: text, display: true, details: { delivery, ...(messageId ? { messageId } : {}), ...(user ? { user } : {}) } };
+}
+
+export function receivedMessageIds(ctx: ExtensionContext): string[] {
+	return ctx.sessionManager.getEntries().flatMap((entry) =>
+		entry.type === "custom_message" && entry.customType === MESSAGE_TYPE && typeof (entry.details as { messageId?: unknown })?.messageId === "string"
+			? [(entry.details as { messageId: string }).messageId]
+			: []);
+}
+
+/** Whether a tree has no live work: unended inputs, owned Agents that are not idle, background Programs, or undelivered notifications. */
+export function treeIdle(rootId: string): boolean {
+	return shared.scheduler.outstanding(rootId) === 0 &&
+		![...work.values()].includes(rootId) &&
+		![...shared.nodes.values()].some((node) => node.rootId === rootId && node.agents.live());
+}

package/src/agents/scheduler.ts

@@ -0,0 +1,204 @@
+/** Execution slots and outstanding-input permits shared by the owned Agents of each root. */
+interface SuspendedOwner {
+	count: number;
+	resuming: boolean;
+}
+
+interface CapacityWaiter {
+	id: string;
+	resolve(): void;
+	reject(error: unknown): void;
+	signal?: AbortSignal;
+	onAbort?: () => void;
+}
+
+export class TreeScheduler {
+	private runningByRoot = new Map<string, Set<string>>();
+	private waitersByRoot = new Map<string, CapacityWaiter[]>();
+	private resumeWaitersByRoot = new Map<string, CapacityWaiter[]>();
+	private suspendedByRoot = new Map<string, Map<string, SuspendedOwner>>();
+	private outstandingByRoot = new Map<string, Set<symbol>>();
+	private maximumByRoot = new Map<string, number>();
+
+	hasCapacity(rootId: string, maximum: number): boolean {
+		return (this.runningByRoot.get(rootId)?.size ?? 0) < maximum;
+	}
+
+	acquire(rootId: string, id: string, maximum: number): boolean {
+		this.rememberMaximum(rootId, maximum);
+		const running = this.runningByRoot.get(rootId) ?? new Set<string>();
+		if (running.has(id)) return true;
+		if (running.size >= maximum) return false;
+		running.add(id);
+		this.runningByRoot.set(rootId, running);
+		return true;
+	}
+
+	acquireQueued(rootId: string, id: string, maximum: number, signal?: AbortSignal, resume = false): Promise<void> {
+		this.rememberMaximum(rootId, maximum);
+		return new Promise<void>((resolve, reject) => {
+			if (signal?.aborted) {
+				reject(new DOMException("Capacity wait aborted", "AbortError"));
+				return;
+			}
+			const queueMap = resume ? this.resumeWaitersByRoot : this.waitersByRoot;
+			const queue = queueMap.get(rootId) ?? [];
+			const waiter: CapacityWaiter = { id, resolve, reject, signal };
+			waiter.onAbort = () => {
+				const index = queue.indexOf(waiter);
+				if (index >= 0) queue.splice(index, 1);
+				if (queue.length === 0) queueMap.delete(rootId);
+				reject(new DOMException("Capacity wait aborted", "AbortError"));
+				this.drain(rootId, maximum);
+			};
+			queue.push(waiter);
+			queueMap.set(rootId, queue);
+			signal?.addEventListener("abort", waiter.onAbort, { once: true });
+			this.drain(rootId, maximum);
+		});
+	}
+
+	release(rootId: string, id: string): void {
+		const running = this.runningByRoot.get(rootId);
+		if (running?.delete(id) && running.size === 0) this.runningByRoot.delete(rootId);
+		const suspended = this.suspendedByRoot.get(rootId);
+		if (suspended?.delete(id) && suspended.size === 0) this.suspendedByRoot.delete(rootId);
+		this.rejectWaiters(rootId, id);
+		this.drain(rootId, this.maximum(rootId));
+		this.cleanupRoot(rootId);
+	}
+
+	suspend(rootId: string, id: string): boolean {
+		const suspended = this.suspendedByRoot.get(rootId) ?? new Map<string, SuspendedOwner>();
+		const existing = suspended.get(id);
+		if (existing) {
+			existing.count += 1;
+			return true;
+		}
+		const running = this.runningByRoot.get(rootId);
+		if (!running?.delete(id)) return false;
+		if (running.size === 0) this.runningByRoot.delete(rootId);
+		suspended.set(id, { count: 1, resuming: false });
+		this.suspendedByRoot.set(rootId, suspended);
+		this.drain(rootId, this.maximum(rootId));
+		return true;
+	}
+
+	async resume(rootId: string, id: string, maximum: number, signal?: AbortSignal): Promise<void> {
+		const suspended = this.suspendedByRoot.get(rootId);
+		const state = suspended?.get(id);
+		if (!state) return;
+		state.count -= 1;
+		if (state.count > 0 || state.resuming) return;
+		if (signal?.aborted) {
+			suspended!.delete(id);
+			if (suspended!.size === 0) this.suspendedByRoot.delete(rootId);
+			return;
+		}
+		state.resuming = true;
+		try {
+			await this.acquireQueued(rootId, id, maximum, signal, true);
+		} catch (error) {
+			state.resuming = false;
+			if (signal?.aborted || suspended?.get(id) !== state) {
+				suspended?.delete(id);
+				if (suspended?.size === 0) this.suspendedByRoot.delete(rootId);
+				return;
+			}
+			throw error;
+		}
+		if (suspended?.get(id) !== state) {
+			this.dropRunning(rootId, id);
+			this.drain(rootId, maximum);
+			return;
+		}
+		if (state.count === 0) {
+			suspended.delete(id);
+			if (suspended.size === 0) this.suspendedByRoot.delete(rootId);
+			return;
+		}
+		this.dropRunning(rootId, id);
+		state.resuming = false;
+		this.drain(rootId, maximum);
+	}
+
+	reserveOutstanding(rootId: string, maximum: number): symbol | undefined {
+		const outstanding = this.outstandingByRoot.get(rootId) ?? new Set<symbol>();
+		if (outstanding.size >= maximum) return undefined;
+		const permit = Symbol(rootId);
+		outstanding.add(permit);
+		this.outstandingByRoot.set(rootId, outstanding);
+		return permit;
+	}
+
+	outstanding(rootId: string): number {
+		return this.outstandingByRoot.get(rootId)?.size ?? 0;
+	}
+
+	releaseOutstanding(rootId: string, permit: symbol): void {
+		const outstanding = this.outstandingByRoot.get(rootId);
+		if (!outstanding?.delete(permit)) return;
+		if (outstanding.size === 0) this.outstandingByRoot.delete(rootId);
+		this.cleanupRoot(rootId);
+	}
+
+	private rememberMaximum(rootId: string, maximum: number): void {
+		this.maximumByRoot.set(rootId, maximum);
+	}
+
+	private maximum(rootId: string): number {
+		return this.maximumByRoot.get(rootId) ?? 0;
+	}
+
+	private drain(rootId: string, maximum: number): void {
+		const running = this.runningByRoot.get(rootId) ?? new Set<string>();
+		while (running.size < maximum) {
+			const resumeQueue = this.resumeWaitersByRoot.get(rootId);
+			const normalQueue = this.waitersByRoot.get(rootId);
+			const queue = resumeQueue?.length ? resumeQueue : normalQueue;
+			const waiter = queue?.shift();
+			if (!waiter) break;
+			if (queue!.length === 0) {
+				if (queue === resumeQueue) this.resumeWaitersByRoot.delete(rootId);
+				else this.waitersByRoot.delete(rootId);
+			}
+			waiter.signal?.removeEventListener("abort", waiter.onAbort!);
+			if (waiter.signal?.aborted) {
+				waiter.reject(new DOMException("Capacity wait aborted", "AbortError"));
+				continue;
+			}
+			running.add(waiter.id);
+			this.runningByRoot.set(rootId, running);
+			waiter.resolve();
+		}
+		if (running.size === 0) this.runningByRoot.delete(rootId);
+	}
+
+	private dropRunning(rootId: string, id: string): void {
+		const running = this.runningByRoot.get(rootId);
+		if (!running?.delete(id)) return;
+		if (running.size === 0) this.runningByRoot.delete(rootId);
+	}
+
+	private cleanupRoot(rootId: string): void {
+		if (this.runningByRoot.has(rootId) || this.waitersByRoot.has(rootId) ||
+			this.resumeWaitersByRoot.has(rootId) || this.suspendedByRoot.has(rootId) ||
+			this.outstandingByRoot.has(rootId)) return;
+		this.maximumByRoot.delete(rootId);
+	}
+
+	private rejectWaiters(rootId: string, id: string): void {
+		for (const queues of [this.waitersByRoot, this.resumeWaitersByRoot]) {
+			const queue = queues.get(rootId);
+			if (!queue) continue;
+			for (let index = queue.length - 1; index >= 0; index -= 1) {
+				const waiter = queue[index]!;
+				if (waiter.id !== id) continue;
+				queue.splice(index, 1);
+				waiter.signal?.removeEventListener("abort", waiter.onAbort!);
+				waiter.reject(new DOMException("Capacity wait released", "AbortError"));
+			}
+			if (queue.length === 0) queues.delete(rootId);
+		}
+	}
+}

package/src/agents/search.ts

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { entryLine, MESSAGE_TAG, MESSAGE_TYPE, type Entry } from "./registry.ts";
+
+interface SearchText {
+	time: number;
+	text: string;
+}
+
+/** Parsed texts by Session file, reused while the file is unchanged. */
+const cache = new Map<string, { stamp: string; texts: SearchText[] }>();
+
+function sessionTexts(sessionFile: string | undefined): SearchText[] {
+	if (!sessionFile) return [];
+	const stats = statSync(sessionFile, { throwIfNoEntry: false });
+	if (!stats) {
+		cache.delete(sessionFile);
+		return [];
+	}
+	const stamp = `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
+	const cached = cache.get(sessionFile);
+	if (cached?.stamp === stamp) return cached.texts;
+	const texts: SearchText[] = [];
+	for (const line of readFileSync(sessionFile, "utf8").split("\n")) {
+		if (!line) continue;
+		let entry: Record<string, any>;
+		try { entry = JSON.parse(line); } catch { continue; }
+		const time = Date.parse(entry.timestamp ?? "") || 0;
+		if (entry.type === "compaction" || entry.type === "branch_summary") {
+			if (typeof entry.summary === "string") texts.push({ time, text: entry.summary });
+		} else if (entry.type === "message" && entry.message?.role === "user") {
+			const content = entry.message.content;
+			const text = typeof content === "string"
+				? content
+				: Array.isArray(content) ? content.flatMap((part: any) => part?.type === "text" ? [part.text] : []).join("\n") : "";
+			if (text) texts.push({ time, text });
+		} else if (entry.type === "custom_message" && entry.customType === MESSAGE_TYPE && typeof entry.content === "string") {
+			texts.push({ time, text: entry.content });
+		}
+	}
+	cache.set(sessionFile, { stamp, texts });
+	return texts;
+}
+
+function matcher(query: string): (text: string) => string[] | undefined {
+	const groups = query.toLowerCase().split("|").map((group) => group.trim().split(/\s+/).filter(Boolean)).filter((group) => group.length > 0);
+	return (text) => {
+		const lower = text.toLowerCase();
+		return groups.find((terms) => terms.every((term) => lower.includes(term)));
+	};
+}
+
+function excerpt(text: string, term: string): string {
+	const flat = text.replace(/\s+/g, " ");
+	const index = Math.max(0, flat.toLowerCase().indexOf(term));
+	const start = Math.max(0, index - 40);
+	const end = Math.min(flat.length, index + term.length + 80);
+	return `${start > 0 ? "…" : ""}${flat.slice(start, end)}${end < flat.length ? "…" : ""}`;
+}
+
+function formatTime(time: number): string {
+	const date = new Date(time);
+	const pad = (value: number) => String(value).padStart(2, "0");
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+export interface ListItem {
+	entry: Entry;
+	match?: SearchText & { excerpt: string };
+}
+
+/** Filters entries by a query over ID, name, cwd, summaries, and user messages, most recent match first. */
+export function searchEntries(entries: Entry[], query: string | undefined): ListItem[] {
+	if (!query?.trim()) return entries.map((entry) => ({ entry }));
+	const match = matcher(query);
+	const items: Array<ListItem & { time: number }> = [];
+	for (const entry of entries) {
+		let latest: ListItem["match"];
+		for (const text of sessionTexts(entry.sessionFile)) {
+			const terms = match(text.text);
+			if (terms && (!latest || text.time >= latest.time)) latest = { ...text, excerpt: excerpt(text.text, terms[0]!) };
+		}
+		if (latest) items.push({ entry, match: latest, time: latest.time });
+		else if (match([entry.id, entry.name ?? "", entry.cwd].join("\n"))) items.push({ entry, time: 0 });
+	}
+	return items.sort((left, right) => right.time - left.time).map(({ time: _time, ...item }) => item);
+}
+
+export function listLine(item: ListItem, ids: Iterable<string>): string {
+	const line = entryLine(item.entry, ids);
+	return item.match ? `${line}\n  ${formatTime(item.match.time)}  ${item.match.excerpt}` : line;
+}
+
+/**
+ * An Agent's latest activity on one line: its last tool call, as `$ <command>` for bash, the tool and
+ * its path for file tools, or the `agent` action and its targets; or the last line of its last reply; before it has any, its first input without the sender header. A forked
+ * conversation is not its input.
+ */
+export function latestActivity(sessionFile: string | undefined): string | undefined {
+	if (!sessionFile || !existsSync(sessionFile)) return undefined;
+	let input: string | undefined;
+	let activity: string | undefined;
+	for (const line of readFileSync(sessionFile, "utf8").split("\n")) {
+		let entry: Record<string, any>;
+		try { entry = JSON.parse(line); } catch { continue; }
+		if (input === undefined && entry.type === "custom_message" && entry.customType === MESSAGE_TYPE && typeof entry.content === "string") {
+			input = entry.content.startsWith(`<${MESSAGE_TAG} `) ? entry.content.slice(entry.content.indexOf("\n") + 1, entry.content.lastIndexOf("\n")) : entry.content;
+		}
+		if (input !== undefined && entry.type === "message" && entry.message?.role === "assistant" && Array.isArray(entry.message.content)) {
+			activity = replyActivity(entry.message.content) ?? activity;
+		}
+	}
+	return (activity ?? input)?.replace(/\s+/g, " ").trim();
+}
+
+function toolActivity(name: string, args: Record<string, any>): string {
+	if (name === "bash" && typeof args.command === "string") return `$ ${args.command}`;
+	if (typeof args.path === "string") return `${name} ${args.path}`;
+	if (name === "agent" && typeof args.action === "string") {
+		const targets = [args.target, args.name].flat().filter((target) => typeof target === "string");
+		return [args.action, targets.join(", ")].filter(Boolean).join(" ");
+	}
+	return name;
+}
+
+function replyActivity(content: Array<Record<string, any>>): string | undefined {
+	for (const block of [...content].reverse()) {
+		if (block.type === "toolCall") return toolActivity(block.name, block.arguments ?? {});
+		if (block.type === "text" && typeof block.text === "string" && block.text.trim()) return block.text.trim().split("\n").at(-1);
+	}
+	return undefined;
+}