@narumitw/pi-subagents 1.0.0 → 1.0.2

package/src/subagents.ts

@@ -21,11 +21,24 @@ import type {
 	DelegationCwdPolicy,
 	SubagentSettings,
 } from "./agents/types.js";
-import { registerSubagentAutomation } from "./automation.js";
-import { registerSubagentConfigCommand, registerSubagentConfigLifecycle } from "./config-ui.js";
-import { registerSubagentConsult } from "./consult.js";
-import { executeSubagent } from "./execution.js";
-import { registerSubagentInspect } from "./inspect.js";
+import {
+	type AutomationRegistrationDependencies,
+	registerSubagentAutomation,
+} from "./automation-registration.js";
+import { cachedModuleLoader, throwIfAborted } from "./cached-module-loader.js";
+import {
+	type ConfigRegistrationDependencies,
+	registerSubagentConfigCommand,
+	registerSubagentConfigLifecycle,
+} from "./config-registration.js";
+import {
+	type ConsultRegistrationDependencies,
+	registerSubagentConsult,
+} from "./consult-registration.js";
+import {
+	type InspectRegistrationDependencies,
+	registerSubagentInspect,
+} from "./inspect-registration.js";
 import { MAX_BLOCKING_PARALLEL_CONCURRENCY } from "./limits.js";
 import { SubagentParams } from "./params.js";
 import { renderSubagentCall, renderSubagentResult } from "./render.js";
@@ -40,17 +53,34 @@ import {
 	resolveBlockingMaxParallelTasks,
 } from "./settings.js";
 import { registerStatefulSubagents } from "./stateful.js";
+import type { SubagentTransport } from "./transport.js";
+
+type BlockingExecutionModule = Pick<typeof import("./execution.js"), "executeSubagent">;
+
+export interface SubagentsDependencies {
+	loadBlockingExecution?: () => Promise<BlockingExecutionModule>;
+	loadStatefulTransport?: () => Promise<SubagentTransport>;
+	automation?: AutomationRegistrationDependencies;
+	config?: ConfigRegistrationDependencies;
+	consult?: ConsultRegistrationDependencies;
+	inspect?: InspectRegistrationDependencies;
+}
 
-export default function (pi: ExtensionAPI) {
+export default function (pi: ExtensionAPI, dependencies: SubagentsDependencies = {}) {
+	const loadBlockingExecution = cachedModuleLoader(
+		dependencies.loadBlockingExecution ?? (() => import("./execution.js")),
+	);
 	const configOwner = registerSubagentConfigLifecycle(pi);
 	const settings = readSubagentSettings();
 	let currentSettings: SubagentSettings | undefined = settings;
 	let currentCatalog = "";
 	const blockingEnabled = settings?.blocking?.enabled !== false;
 	const refreshBlockingCatalog = blockingEnabled
-		? registerBlockingSubagent(pi, () => currentSettings)
+		? registerBlockingSubagent(pi, () => currentSettings, loadBlockingExecution)
 		: () => undefined;
-	if (blockingEnabled) registerSubagentAutomation(pi, { getSettings: () => currentSettings });
+	if (blockingEnabled) {
+		registerSubagentAutomation(pi, { getSettings: () => currentSettings }, dependencies.automation);
+	}
 	let refreshStatefulCatalog: (catalog: string) => void = () => undefined;
 	let refreshConsultCatalog: (catalog: string) => void = () => undefined;
 
@@ -78,6 +108,7 @@ export default function (pi: ExtensionAPI) {
 		blockingEnabled,
 		settings: settings?.stateful,
 		getSettings: () => currentSettings,
+		loadTransport: dependencies.loadStatefulTransport,
 	});
 	refreshStatefulCatalog = statefulRuntime.setAgentCatalog;
 	const getBlockingEnabled = () => blockingEnabled;
@@ -88,18 +119,24 @@ export default function (pi: ExtensionAPI) {
 		currentSettings?.cwdPolicy?.consultation ?? DEFAULT_CONSULTATION_CWD_POLICY;
 	const getDelegationCwdPolicy = () =>
 		currentSettings?.cwdPolicy?.delegation ?? DEFAULT_DELEGATION_CWD_POLICY;
-	registerSubagentInspect(pi, {
-		...statefulRuntime,
-		getBlockingEnabled,
-		getMaxParallelTasks,
-		getConsultResourcePolicy,
-		getConsultationCwdPolicy,
-		getDelegationCwdPolicy,
-	});
+	registerSubagentInspect(
+		pi,
+		{
+			...statefulRuntime,
+			getBlockingEnabled,
+			getMaxParallelTasks,
+			getConsultResourcePolicy,
+			getConsultationCwdPolicy,
+			getDelegationCwdPolicy,
+		},
+		dependencies.inspect,
+	);
 	if (blockingEnabled) {
-		refreshConsultCatalog = registerSubagentConsult(pi, {
-			getSettings: () => currentSettings,
-		});
+		refreshConsultCatalog = registerSubagentConsult(
+			pi,
+			{ getSettings: () => currentSettings },
+			dependencies.consult,
+		);
 	}
 	registerSubagentConfigCommand(
 		pi,
@@ -155,12 +192,14 @@ export default function (pi: ExtensionAPI) {
 			},
 		},
 		configOwner,
+		dependencies.config,
 	);
 }
 
 function registerBlockingSubagent(
 	pi: ExtensionAPI,
 	getSettings: () => SubagentSettings | undefined,
+	loadExecution: () => Promise<BlockingExecutionModule>,
 ): (catalog: string) => void {
 	let catalog = "";
 	const activeControllers = new Set<AbortController>();
@@ -212,14 +251,28 @@ function registerBlockingSubagent(
 			const effectiveSignal = signal
 				? AbortSignal.any([signal, lifecycleController.signal])
 				: lifecycleController.signal;
-			const work = executeSubagent(
-				toolCallId,
-				params,
-				effectiveSignal,
-				onUpdate,
-				ctx,
-				getSettings(),
-			);
+			const work = (async () => {
+				throwIfAborted(effectiveSignal, "Blocking subagent execution was cancelled");
+				let executionModule: BlockingExecutionModule;
+				try {
+					executionModule = await loadExecution();
+				} catch (error) {
+					throwIfAborted(
+						effectiveSignal,
+						"Blocking subagent execution was cancelled while loading",
+					);
+					throw error;
+				}
+				throwIfAborted(effectiveSignal, "Blocking subagent execution was cancelled while loading");
+				return executionModule.executeSubagent(
+					toolCallId,
+					params,
+					effectiveSignal,
+					onUpdate,
+					ctx,
+					getSettings(),
+				);
+			})();
 			activeWork.add(work);
 			try {
 				return await work;
@@ -256,8 +309,7 @@ function appendAgentCatalog(baseDescription: string, catalog: string): string {
 }
 
 export { parsePositiveInteger } from "./execution/runtime-policy.js";
-export { formatTokens, formatUsageStats } from "./render.js";
-export { buildPiArgs } from "./runner.js";
+export { buildPiArgs } from "./pi-args.js";
 export {
 	DEFAULT_CONSULT_RESOURCE_POLICY,
 	DEFAULT_CONSULTATION_CWD_POLICY,
@@ -286,3 +338,4 @@ export {
 	updateDelegationWorkflowSetting,
 	updateStatefulLimitSetting,
 } from "./settings.js";
+export { formatTokens, formatUsageStats } from "./usage-format.js";

package/src/usage-format.ts

@@ -0,0 +1,42 @@
+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/verified-execution-contract.ts

@@ -1,41 +1,13 @@
-import { StringEnum } from "@earendil-works/pi-ai";
-import { type Static, Type } from "typebox";
 import { normalizeDelegationContract } from "./delegation-contract.js";
 import {
 	type VerificationCheckRequest,
 	validateVerificationChecks,
 } from "./verification-harness.js";
+import type { VerifiedExecutionContract } from "./verified-execution-schema.js";
 import type { ResolvedWorkflowTask } from "./workflow-planning.js";
 
-const VerificationCheckSchema = Type.Object(
-	{
-		id: Type.String({
-			minLength: 1,
-			maxLength: 256,
-			pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$",
-		}),
-		command: StringEnum(["git", "node", "npm", "npx"] as const),
-		args: Type.Optional(Type.Array(Type.String({ maxLength: 4096 }), { maxItems: 64 })),
-		cwd: Type.Optional(Type.String({ minLength: 1, maxLength: 4096 })),
-		timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: 600_000 })),
-	},
-	{ additionalProperties: false },
-);
-
-export const VerifiedExecutionContractSchema = Type.Object(
-	{
-		verifierAgent: Type.String({ minLength: 1, maxLength: 256 }),
-		maxReworkCycles: Type.Optional(Type.Integer({ minimum: 0, maximum: 1, default: 1 })),
-		checks: Type.Optional(Type.Array(VerificationCheckSchema, { maxItems: 32 })),
-	},
-	{
-		additionalProperties: false,
-		description:
-			"Explicitly gate mutating workflow success on executor-owned deterministic checks, one least-authority independent verifier, exact submitted-state identity, and managed integration acceptance.",
-	},
-);
-
-export type VerifiedExecutionContract = Static<typeof VerifiedExecutionContractSchema>;
+export type { VerifiedExecutionContract } from "./verified-execution-schema.js";
+export { VerifiedExecutionContractSchema } from "./verified-execution-schema.js";
 
 export interface PreparedVerifiedWorkflow {
 	tasks: ResolvedWorkflowTask[];

package/src/verified-execution-schema.ts

@@ -0,0 +1,32 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { type Static, Type } from "typebox";
+
+const VerificationCheckSchema = Type.Object(
+	{
+		id: Type.String({
+			minLength: 1,
+			maxLength: 256,
+			pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$",
+		}),
+		command: StringEnum(["git", "node", "npm", "npx"] as const),
+		args: Type.Optional(Type.Array(Type.String({ maxLength: 4096 }), { maxItems: 64 })),
+		cwd: Type.Optional(Type.String({ minLength: 1, maxLength: 4096 })),
+		timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: 600_000 })),
+	},
+	{ additionalProperties: false },
+);
+
+export const VerifiedExecutionContractSchema = Type.Object(
+	{
+		verifierAgent: Type.String({ minLength: 1, maxLength: 256 }),
+		maxReworkCycles: Type.Optional(Type.Integer({ minimum: 0, maximum: 1, default: 1 })),
+		checks: Type.Optional(Type.Array(VerificationCheckSchema, { maxItems: 32 })),
+	},
+	{
+		additionalProperties: false,
+		description:
+			"Explicitly gate mutating workflow success on executor-owned deterministic checks, one least-authority independent verifier, exact submitted-state identity, and managed integration acceptance.",
+	},
+);
+
+export type VerifiedExecutionContract = Static<typeof VerifiedExecutionContractSchema>;