@narumitw/pi-subagents 2.1.4 → 3.0.0

package/src/transport.ts

@@ -1,43 +0,0 @@
-import type { AgentMailboxMessage, ManagedAgent, TurnOutcome } from "./registry.js";
-import type { TransportProgressCallback } from "./transport-types.js";
-
-export interface SubagentTransport {
-	readonly kind: "subprocess" | "in-process" | "rpc" | "auto" | "fake";
-	runTurn(
-		agent: ManagedAgent,
-		task: string,
-		signal: AbortSignal,
-		onProgress?: TransportProgressCallback,
-	): Promise<TurnOutcome>;
-	deliverMessage?(agent: ManagedAgent, message: AgentMailboxMessage): Promise<boolean>;
-	release?(agent: ManagedAgent): Promise<void>;
-	shutdown?(): Promise<void>;
-}
-
-export type AgentTurnRunner = (
-	agent: ManagedAgent,
-	task: string,
-	signal: AbortSignal,
-	onProgress?: TransportProgressCallback,
-) => Promise<TurnOutcome>;
-
-export class FunctionTransport implements SubagentTransport {
-	readonly kind = "fake" as const;
-
-	constructor(private readonly runner: AgentTurnRunner) {}
-
-	runTurn(
-		agent: ManagedAgent,
-		task: string,
-		signal: AbortSignal,
-		onProgress?: TransportProgressCallback,
-	): Promise<TurnOutcome> {
-		return this.runner(agent, task, signal, onProgress);
-	}
-}
-
-export function normalizeTransport(
-	transport: SubagentTransport | AgentTurnRunner,
-): SubagentTransport {
-	return typeof transport === "function" ? new FunctionTransport(transport) : transport;
-}

package/src/turn-budget.ts

@@ -1,109 +0,0 @@
-import { MAX_SUBAGENT_TIMEOUT_MS } from "./limits.js";
-import type { TurnTerminationReason } from "./timeout-checkpoint.js";
-
-export const MAX_SUBAGENT_TURNS = 1_000_000;
-export const MAX_SUBAGENT_TOOL_CALLS = 1_000_000;
-
-export interface TurnLimits {
-	idleTimeoutMs?: number;
-	maxTurns?: number;
-	maxToolCalls?: number;
-}
-
-export interface TurnBudgetStop {
-	reason: Extract<TurnTerminationReason, "idle_timeout" | "turn_limit" | "tool_call_limit">;
-	limit: number;
-}
-
-export interface TurnBudgetMonitorOptions extends TurnLimits {
-	onExceeded(stop: TurnBudgetStop): void;
-}
-
-const TERMINAL_STOP_REASONS = new Set(["stop", "length", "error", "aborted"]);
-
-export function validateTurnLimits(limits: TurnLimits): TurnLimits {
-	validateOptionalInteger("idleTimeoutMs", limits.idleTimeoutMs, MAX_SUBAGENT_TIMEOUT_MS);
-	validateOptionalInteger("maxTurns", limits.maxTurns, MAX_SUBAGENT_TURNS);
-	validateOptionalInteger("maxToolCalls", limits.maxToolCalls, MAX_SUBAGENT_TOOL_CALLS);
-	return { ...limits };
-}
-
-export class TurnBudgetMonitor {
-	private readonly limits: TurnLimits;
-	private readonly onExceeded: (stop: TurnBudgetStop) => void;
-	private idleTimer?: NodeJS.Timeout;
-	private assistantTurns = 0;
-	private toolCalls = 0;
-	private stopped = false;
-
-	constructor(options: TurnBudgetMonitorOptions) {
-		this.limits = validateTurnLimits({
-			idleTimeoutMs: options.idleTimeoutMs,
-			maxTurns: options.maxTurns,
-			maxToolCalls: options.maxToolCalls,
-		});
-		this.onExceeded = options.onExceeded;
-		this.resetIdleTimer();
-	}
-
-	recordActivity(): void {
-		if (this.stopped) return;
-		this.resetIdleTimer();
-	}
-
-	recordAssistantTurn(stopReason?: string): void {
-		if (this.stopped) return;
-		this.assistantTurns++;
-		this.recordActivity();
-		if (
-			this.limits.maxTurns !== undefined &&
-			this.assistantTurns >= this.limits.maxTurns &&
-			!TERMINAL_STOP_REASONS.has(stopReason ?? "")
-		) {
-			this.exceed({ reason: "turn_limit", limit: this.limits.maxTurns });
-		}
-	}
-
-	recordToolCalls(count = 1): void {
-		if (this.stopped || count < 1) return;
-		this.toolCalls += count;
-		if (this.limits.maxToolCalls !== undefined && this.toolCalls > this.limits.maxToolCalls) {
-			this.exceed({ reason: "tool_call_limit", limit: this.limits.maxToolCalls });
-		}
-	}
-
-	dispose(): void {
-		this.stopped = true;
-		if (this.idleTimer) clearTimeout(this.idleTimer);
-		this.idleTimer = undefined;
-	}
-
-	private resetIdleTimer(): void {
-		if (this.idleTimer) clearTimeout(this.idleTimer);
-		const idleTimeoutMs = this.limits.idleTimeoutMs;
-		if (idleTimeoutMs === undefined || this.stopped) {
-			this.idleTimer = undefined;
-			return;
-		}
-		this.idleTimer = setTimeout(
-			() => this.exceed({ reason: "idle_timeout", limit: idleTimeoutMs }),
-			idleTimeoutMs,
-		);
-		this.idleTimer.unref?.();
-	}
-
-	private exceed(stop: TurnBudgetStop): void {
-		if (this.stopped) return;
-		this.stopped = true;
-		if (this.idleTimer) clearTimeout(this.idleTimer);
-		this.idleTimer = undefined;
-		this.onExceeded(stop);
-	}
-}
-
-function validateOptionalInteger(name: string, value: number | undefined, maximum: number): void {
-	if (value === undefined) return;
-	if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
-		throw new Error(`${name} must be an integer between 1 and ${maximum}`);
-	}
-}

package/src/usage-format.ts

@@ -1,42 +0,0 @@
-import type { SubagentThinkingLevel } from "./agents/types.js";
-import { safeLine } from "./render-common.js";
-
-export function formatTokens(count: number): string {
-	if (count < 1000) return count.toString();
-	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
-	if (count < 1000000) return `${Math.round(count / 1000)}k`;
-	return `${(count / 1000000).toFixed(1)}M`;
-}
-
-export function formatUsageStats(
-	usage: {
-		input: number;
-		output: number;
-		cacheRead: number;
-		cacheWrite: number;
-		cost: number;
-		contextTokens?: number;
-		turns?: number;
-	},
-	model?: string,
-	thinkingLevel?: SubagentThinkingLevel,
-	actualProvider?: string,
-	actualModel?: string,
-): string {
-	const parts: string[] = [];
-	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
-	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	if (usage.contextTokens && usage.contextTokens > 0)
-		parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
-	const safeProvider = actualProvider ? safeLine(actualProvider, "", 256) : undefined;
-	const safeModel = actualModel ? safeLine(actualModel, "", 256) : undefined;
-	const actual =
-		safeProvider && safeModel ? `${safeProvider}/${safeModel}` : (safeModel ?? safeProvider);
-	if (actual ?? model) parts.push(actual ?? safeLine(model, "", 256));
-	if (thinkingLevel) parts.push(`requested-thinking:${safeLine(thinkingLevel, "", 128)}`);
-	return parts.join(" ");
-}

package/src/usage-recording-config.ts

@@ -1,13 +0,0 @@
-export const USAGE_RECORDING_DIRECTORY = "pi-subagents-usage";
-export const USAGE_RECORDING_RETENTION_DAYS = 30;
-export const USAGE_RECORDING_STUDY_ID = "pi-subagents-surface-v1";
-
-export interface SubagentUsageRecordingSettings {
-	enabled?: boolean;
-}
-
-export function resolveUsageRecordingEnabled(
-	settings: SubagentUsageRecordingSettings | undefined,
-): boolean {
-	return settings?.enabled === true;
-}

package/src/usage-recording-store.ts

@@ -1,183 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { chmod, lstat, mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-
-const WRITER_PATTERN =
-	/^runtime-[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.jsonl$/u;
-const MAX_EVENT_BYTES = 8 * 1024;
-const WRITE_TIMEOUT_MS = 2_000;
-
-export interface UsageEventStorePort {
-	readonly path: string;
-	append(event: unknown): Promise<void>;
-	prune(retentionDays: number): Promise<void>;
-	close(): Promise<void>;
-}
-
-export class UsageEventStore implements UsageEventStorePort {
-	readonly path: string;
-	private readonly writerPath: string;
-	private mutationTail: Promise<void> = Promise.resolve();
-	private readonly lifecycle = new AbortController();
-	private closed = false;
-
-	constructor(rootPath: string, options: { createId?: () => string; now?: () => number } = {}) {
-		this.path = rootPath;
-		this.createId = options.createId ?? randomUUID;
-		this.now = options.now ?? Date.now;
-		this.writerPath = path.join(rootPath, `runtime-${validId(this.createId())}.jsonl`);
-	}
-
-	private readonly createId: () => string;
-	private readonly now: () => number;
-
-	append(event: unknown): Promise<void> {
-		if (this.closed) return Promise.reject(new Error("Usage recording storage is closed."));
-		const frame = encodeEvent(event);
-		return this.enqueue(() =>
-			withTimeout(
-				(signal) => this.appendFrame(frame, signal),
-				this.lifecycle.signal,
-				WRITE_TIMEOUT_MS,
-				"Usage recording write timed out",
-			),
-		);
-	}
-
-	prune(retentionDays: number): Promise<void> {
-		if (this.closed) return Promise.reject(new Error("Usage recording storage is closed."));
-		return this.enqueue(() =>
-			withTimeout(
-				async (signal) => {
-					await ensurePrivateDirectory(this.path);
-					signal.throwIfAborted();
-					const cutoff = this.now() - retentionDays * 24 * 60 * 60 * 1000;
-					for (const entry of await readdir(this.path, { withFileTypes: true })) {
-						signal.throwIfAborted();
-						if (!entry.isFile() || !WRITER_PATTERN.test(entry.name)) continue;
-						const candidate = path.join(this.path, entry.name);
-						if (candidate === this.writerPath) continue;
-						let metadata: Awaited<ReturnType<typeof lstat>>;
-						try {
-							metadata = await lstat(candidate);
-						} catch (error) {
-							if (isNodeError(error) && error.code === "ENOENT") continue;
-							throw error;
-						}
-						if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.mtimeMs >= cutoff) {
-							continue;
-						}
-						await rm(candidate, { force: true });
-					}
-				},
-				this.lifecycle.signal,
-				WRITE_TIMEOUT_MS,
-				"Usage recording retention cleanup timed out",
-			),
-		);
-	}
-
-	async close(): Promise<void> {
-		if (this.closed) return;
-		this.closed = true;
-		this.lifecycle.abort(new DOMException("Usage recording storage closed", "AbortError"));
-		await this.mutationTail;
-	}
-
-	private enqueue(operation: () => Promise<void>): Promise<void> {
-		const result = this.mutationTail.then(operation);
-		this.mutationTail = result.catch(() => undefined);
-		return result;
-	}
-
-	private async appendFrame(frame: string, signal: AbortSignal): Promise<void> {
-		await ensurePrivateDirectory(this.path);
-		signal.throwIfAborted();
-		await assertOptionalPrivateRegularFile(this.writerPath);
-		signal.throwIfAborted();
-		await writeFile(this.writerPath, frame, {
-			encoding: "utf8",
-			flag: "a",
-			mode: 0o600,
-			signal,
-		});
-		if (process.platform !== "win32") await chmod(this.writerPath, 0o600);
-	}
-}
-
-export function encodeEvent(event: unknown): string {
-	const frame = `${JSON.stringify(event)}\n`;
-	if (Buffer.byteLength(frame) > MAX_EVENT_BYTES) {
-		throw new Error("Usage recording event exceeds the storage bound.");
-	}
-	return frame;
-}
-
-async function ensurePrivateDirectory(directoryPath: string): Promise<void> {
-	try {
-		const metadata = await lstat(directoryPath);
-		if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
-			throw new Error("Usage recording storage must be a regular directory, not a link.");
-		}
-	} catch (error) {
-		if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-		await mkdir(directoryPath, { recursive: true, mode: 0o700 });
-		const metadata = await lstat(directoryPath);
-		if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
-			throw new Error("Usage recording storage must be a regular directory, not a link.");
-		}
-	}
-	if (process.platform !== "win32") await chmod(directoryPath, 0o700);
-}
-
-async function assertOptionalPrivateRegularFile(filePath: string): Promise<void> {
-	try {
-		const metadata = await lstat(filePath);
-		if (!metadata.isFile() || metadata.isSymbolicLink()) {
-			throw new Error("Usage recording writers must be regular files, not links.");
-		}
-		if (process.platform !== "win32") await chmod(filePath, 0o600);
-	} catch (error) {
-		if (isNodeError(error) && error.code === "ENOENT") return;
-		throw error;
-	}
-}
-
-async function withTimeout<T>(
-	operation: (signal: AbortSignal) => Promise<T>,
-	lifecycleSignal: AbortSignal,
-	timeoutMs: number,
-	message: string,
-): Promise<T> {
-	lifecycleSignal.throwIfAborted();
-	const controller = new AbortController();
-	const abortLifecycle = () =>
-		controller.abort(
-			lifecycleSignal.reason ?? new DOMException("Usage recording storage closed", "AbortError"),
-		);
-	lifecycleSignal.addEventListener("abort", abortLifecycle, { once: true });
-	const timer = setTimeout(
-		() => controller.abort(new DOMException(message, "TimeoutError")),
-		timeoutMs,
-	);
-	try {
-		return await operation(controller.signal);
-	} catch (error) {
-		if (controller.signal.aborted) throw controller.signal.reason;
-		throw error;
-	} finally {
-		clearTimeout(timer);
-		lifecycleSignal.removeEventListener("abort", abortLifecycle);
-	}
-}
-
-function validId(value: string): string {
-	if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(value)) {
-		throw new Error("Usage recording storage received an invalid writer identity.");
-	}
-	return value;
-}
-
-function isNodeError(error: unknown): error is NodeJS.ErrnoException {
-	return error instanceof Error && "code" in error;
-}