@leing2021/super-pi 0.22.1 → 0.23.0

package/extensions/subagent/slash-live-state.ts

@@ -1,295 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Nico Bailon
-// SPDX-License-Identifier: MIT
-// Source: https://github.com/nicobailon/pi-subagents
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import type { Message } from "@mariozechner/pi-ai";
-import type { SubagentParamsLike } from "./subagent-executor.ts";
-import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
-import { type Details, type SingleResult, type Usage, SLASH_RESULT_TYPE } from "./types.ts";
-
-export interface SlashMessageDetails {
-	requestId: string;
-	result: AgentToolResult<Details>;
-}
-
-interface SlashSnapshot {
-	result: AgentToolResult<Details>;
-	version: number;
-}
-
-interface SequentialChainStepLike {
-	agent: string;
-	task?: string;
-}
-
-interface ParallelChainStepLike {
-	parallel: Array<{ agent: string; task?: string }>;
-}
-
-type ChainStepLike = SequentialChainStepLike | ParallelChainStepLike;
-
-const liveSnapshots = new Map<string, SlashSnapshot>();
-const finalSnapshots = new Map<string, SlashSnapshot>();
-let versionCounter = 1;
-
-const EMPTY_MESSAGES: Message[] = [];
-const EMPTY_USAGE: Usage = {
-	input: 0,
-	output: 0,
-	cacheRead: 0,
-	cacheWrite: 0,
-	cost: 0,
-	turns: 0,
-};
-
-function nextVersion(): number {
-	return versionCounter++;
-}
-
-function cloneUsage(): Usage {
-	return { ...EMPTY_USAGE };
-}
-
-function createPlaceholderResult(
-	agent: string,
-	task: string,
-	status: "pending" | "running",
-	index?: number,
-): SingleResult {
-	return {
-		agent,
-		task,
-		exitCode: 0,
-		messages: EMPTY_MESSAGES,
-		usage: cloneUsage(),
-		progress: {
-			...(index !== undefined ? { index } : {}),
-			agent,
-			status,
-			task,
-			recentTools: [],
-			recentOutput: [],
-			toolCount: 0,
-			tokens: 0,
-			durationMs: 0,
-		},
-	};
-}
-
-function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
-	const tasks = params.tasks ?? [];
-	return {
-		content: [{ type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") }],
-		details: {
-			mode: "parallel",
-			...(params.context ? { context: params.context } : {}),
-			results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
-			progress: tasks.map((task, index) => ({
-				index,
-				agent: task.agent,
-				status: "running" as const,
-				task: task.task,
-				recentTools: [],
-				recentOutput: [],
-				toolCount: 0,
-				tokens: 0,
-				durationMs: 0,
-			})),
-		},
-	};
-}
-
-function isParallelChainStep(step: ChainStepLike): step is ParallelChainStepLike {
-	return "parallel" in step && Array.isArray(step.parallel);
-}
-
-function chainStepLabel(step: ChainStepLike): string {
-	if (isParallelChainStep(step)) {
-		return `[${step.parallel.map((entry) => entry.agent).join("+")}]`;
-	}
-	return step.agent;
-}
-
-function flattenChainResults(chain: ChainStepLike[], fallbackTask: string | undefined): SingleResult[] {
-	const results: SingleResult[] = [];
-	let flatIndex = 0;
-	for (const step of chain) {
-		if (isParallelChainStep(step)) {
-			for (const task of step.parallel) {
-				results.push(createPlaceholderResult(task.agent, task.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
-				flatIndex++;
-			}
-			continue;
-		}
-		results.push(createPlaceholderResult(step.agent, step.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
-		flatIndex++;
-	}
-	return results;
-}
-
-function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
-	const chain = (params.chain ?? []) as ChainStepLike[];
-	const results = flattenChainResults(chain, params.task);
-	return {
-		content: [{
-			type: "text",
-			text: results.map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`).join("\n\n"),
-		}],
-		details: {
-			mode: "chain",
-			...(params.context ? { context: params.context } : {}),
-			results,
-			progress: results.map((result, index) => ({
-				index,
-				agent: result.agent,
-				status: index === 0 ? "running" as const : "pending" as const,
-				task: result.task,
-				recentTools: [],
-				recentOutput: [],
-				toolCount: 0,
-				tokens: 0,
-				durationMs: 0,
-			})),
-			chainAgents: chain.map((step) => chainStepLabel(step)),
-			totalSteps: chain.length,
-			currentStepIndex: 0,
-		},
-	};
-}
-
-function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
-	const agent = params.agent ?? "subagent";
-	const task = params.task ?? "";
-	return {
-		content: [{ type: "text", text: task }],
-		details: {
-			mode: "single",
-			...(params.context ? { context: params.context } : {}),
-			results: [createPlaceholderResult(agent, task, "running")],
-			progress: [{
-				agent,
-				status: "running",
-				task,
-				recentTools: [],
-				recentOutput: [],
-				toolCount: 0,
-				tokens: 0,
-				durationMs: 0,
-			}],
-		},
-	};
-}
-
-export function buildSlashInitialResult(requestId: string, params: SubagentParamsLike): SlashMessageDetails {
-	const result = (params.tasks?.length ?? 0) > 0
-		? buildParallelInitialResult(params)
-		: (params.chain?.length ?? 0) > 0
-			? buildChainInitialResult(params)
-			: buildSingleInitialResult(params);
-	liveSnapshots.set(requestId, { result, version: nextVersion() });
-	finalSnapshots.delete(requestId);
-	return { requestId, result };
-}
-
-function cloneResultsWithProgress(
-	results: SingleResult[],
-	progress: NonNullable<Details["progress"]> | undefined,
-): SingleResult[] {
-	return results.map((result, index) => {
-		const nextProgress = progress?.find((entry) => entry.index === index)
-			?? progress?.[index]
-			?? result.progress;
-		return nextProgress ? { ...result, progress: nextProgress } : result;
-	});
-}
-
-export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate): void {
-	const snapshot = liveSnapshots.get(requestId);
-	if (!snapshot) return;
-	const progress = update.progress;
-	if (!progress || !snapshot.result.details) return;
-	const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
-	const nextDetails: Details = {
-		...snapshot.result.details,
-		progress,
-		results: cloneResultsWithProgress(snapshot.result.details.results, progress),
-		...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0 ? { currentStepIndex } : {}),
-	};
-	liveSnapshots.set(requestId, {
-		result: {
-			...snapshot.result,
-			details: nextDetails,
-		},
-		version: nextVersion(),
-	});
-}
-
-export function finalizeSlashResult(response: SlashSubagentResponse): SlashMessageDetails {
-	const snapshot = {
-		result: response.result,
-		version: nextVersion(),
-	};
-	finalSnapshots.set(response.requestId, snapshot);
-	liveSnapshots.delete(response.requestId);
-	return {
-		requestId: response.requestId,
-		result: response.result,
-	};
-}
-
-export function failSlashResult(requestId: string, params: SubagentParamsLike, message: string): SlashMessageDetails {
-	const initial = buildSlashInitialResult(requestId, params).result;
-	const failedResults = initial.details.results.map((result) => ({
-		...result,
-		exitCode: 1,
-		error: message,
-		progress: result.progress ? { ...result.progress, status: "failed" as const } : result.progress,
-	}));
-	const result: AgentToolResult<Details> = {
-		content: [{ type: "text", text: message }],
-		details: {
-			...initial.details,
-			results: failedResults,
-			progress: failedResults.map((entry) => entry.progress!).filter(Boolean),
-		},
-	};
-	const snapshot = { result, version: nextVersion() };
-	finalSnapshots.set(requestId, snapshot);
-	liveSnapshots.delete(requestId);
-	return { requestId, result };
-}
-
-function isSlashMessageDetails(value: unknown): value is SlashMessageDetails {
-	if (!value || typeof value !== "object") return false;
-	const v = value as { requestId?: string; result?: { content?: unknown; details?: { results?: unknown } } };
-	if (typeof v.requestId !== "string" || !v.requestId) return false;
-	if (!v.result || !Array.isArray(v.result.content)) return false;
-	return !!v.result.details && Array.isArray(v.result.details.results);
-}
-
-export function resolveSlashMessageDetails(value: unknown): SlashMessageDetails | undefined {
-	return isSlashMessageDetails(value) ? value : undefined;
-}
-
-export function getSlashRenderableSnapshot(details: SlashMessageDetails): SlashSnapshot {
-	return finalSnapshots.get(details.requestId)
-		?? liveSnapshots.get(details.requestId)
-		?? { result: details.result, version: 0 };
-}
-
-export function restoreSlashFinalSnapshots(entries: unknown[]): void {
-	liveSnapshots.clear();
-	finalSnapshots.clear();
-	for (const entry of entries) {
-		const e = entry as { type?: string; customType?: string; details?: unknown };
-		if (e?.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE) continue;
-		const details = resolveSlashMessageDetails(e.details);
-		if (!details) continue;
-		finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
-	}
-}
-
-export function clearSlashSnapshots(): void {
-	liveSnapshots.clear();
-	finalSnapshots.clear();
-}

package/extensions/subagent/subagent-control.ts

@@ -1,151 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Nico Bailon
-// SPDX-License-Identifier: MIT
-// Source: https://github.com/nicobailon/pi-subagents
-import {
-	type ActivityState,
-	type ControlConfig,
-	type ControlEvent,
-	type ControlEventType,
-	type ControlNotificationChannel,
-	type ResolvedControlConfig,
-} from "./types.ts";
-
-const CONTROL_EVENT_TYPES: ControlEventType[] = ["needs_attention"];
-const CONTROL_NOTIFICATION_CHANNELS: ControlNotificationChannel[] = ["event", "async", "intercom"];
-const DEFAULT_NOTIFY_ON: ControlEventType[] = ["needs_attention"];
-
-export const DEFAULT_CONTROL_CONFIG: ResolvedControlConfig = {
-	enabled: true,
-	needsAttentionAfterMs: 60_000,
-	notifyOn: DEFAULT_NOTIFY_ON,
-	notifyChannels: CONTROL_NOTIFICATION_CHANNELS,
-};
-
-function parsePositiveInt(value: unknown): number | undefined {
-	if (typeof value !== "number") return undefined;
-	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) return undefined;
-	return value;
-}
-
-function parseControlList<T extends string>(value: unknown, allowed: readonly T[]): T[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	if (value.length === 0) return [];
-	const allowedSet = new Set(allowed);
-	const parsed = value.filter((entry): entry is T => typeof entry === "string" && allowedSet.has(entry as T));
-	return parsed.length > 0 ? Array.from(new Set(parsed)) : undefined;
-}
-
-export function resolveControlConfig(
-	globalConfig?: ControlConfig,
-	override?: ControlConfig,
-): ResolvedControlConfig {
-	const enabled = override?.enabled ?? globalConfig?.enabled ?? DEFAULT_CONTROL_CONFIG.enabled;
-	const needsAttentionAfterMs = parsePositiveInt(override?.needsAttentionAfterMs)
-		?? parsePositiveInt(globalConfig?.needsAttentionAfterMs)
-		?? DEFAULT_CONTROL_CONFIG.needsAttentionAfterMs;
-	const notifyOn = parseControlList(override?.notifyOn, CONTROL_EVENT_TYPES)
-		?? parseControlList(globalConfig?.notifyOn, CONTROL_EVENT_TYPES)
-		?? DEFAULT_CONTROL_CONFIG.notifyOn;
-	const notifyChannels = parseControlList(override?.notifyChannels, CONTROL_NOTIFICATION_CHANNELS)
-		?? parseControlList(globalConfig?.notifyChannels, CONTROL_NOTIFICATION_CHANNELS)
-		?? DEFAULT_CONTROL_CONFIG.notifyChannels;
-	return {
-		enabled,
-		needsAttentionAfterMs,
-		notifyOn: [...notifyOn],
-		notifyChannels: [...notifyChannels],
-	};
-}
-
-export function deriveActivityState(input: {
-	config: ResolvedControlConfig;
-	startedAt: number;
-	lastActivityAt?: number;
-	now?: number;
-}): ActivityState | undefined {
-	if (!input.config.enabled) return undefined;
-	const now = input.now ?? Date.now();
-	const lastActivity = input.lastActivityAt ?? input.startedAt;
-	const ageMs = Math.max(0, now - lastActivity);
-	return ageMs > input.config.needsAttentionAfterMs ? "needs_attention" : undefined;
-}
-
-export function shouldEmitControlEvent(
-	config: ResolvedControlConfig,
-	from: ActivityState | undefined,
-	to: ActivityState | undefined,
-): boolean {
-	return config.enabled && from !== to && to === "needs_attention";
-}
-
-export function buildControlEvent(input: {
-	from?: ActivityState;
-	to: ActivityState;
-	runId: string;
-	agent: string;
-	index?: number;
-	ts?: number;
-	lastActivityAt?: number;
-}): ControlEvent {
-	const ts = input.ts ?? Date.now();
-	const elapsedMs = input.lastActivityAt ? Math.max(0, ts - input.lastActivityAt) : undefined;
-	const elapsedSeconds = elapsedMs !== undefined ? Math.floor(elapsedMs / 1000) : undefined;
-	const message = elapsedSeconds !== undefined
-		? `${input.agent} needs attention (no observed activity for ${elapsedSeconds}s)`
-		: `${input.agent} needs attention`;
-	return {
-		type: "needs_attention",
-		from: input.from,
-		to: input.to,
-		ts,
-		runId: input.runId,
-		agent: input.agent,
-		index: input.index,
-		message,
-	};
-}
-
-export function shouldNotifyControlEvent(config: ResolvedControlConfig, event: ControlEvent): boolean {
-	return config.enabled && config.notifyOn.includes(event.type);
-}
-
-export function controlNotificationKey(event: ControlEvent, childIntercomTarget?: string): string {
-	const childKey = childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
-	return `${childKey}:${event.type}`;
-}
-
-export function claimControlNotification(config: ResolvedControlConfig, event: ControlEvent, seenKeys: Set<string>, childIntercomTarget?: string): boolean {
-	if (!shouldNotifyControlEvent(config, event)) return false;
-	const key = controlNotificationKey(event, childIntercomTarget);
-	if (seenKeys.has(key)) return false;
-	seenKeys.add(key);
-	return true;
-}
-
-export function formatControlNoticeMessage(event: ControlEvent, childIntercomTarget?: string): string {
-	const runTarget = event.runId;
-	const nudgeCommand = childIntercomTarget
-		? `intercom({ action: "send", to: "${childIntercomTarget}", message: "What are you blocked on? Reply with the smallest next step or ask for a decision." })`
-		: undefined;
-	return [
-		`Subagent needs attention: ${event.agent}`,
-		`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-		`Signal: ${event.message}`,
-		"Hint: Inspect status first unless the run is clearly blocked.",
-		childIntercomTarget
-			? `Nudge: ${nudgeCommand}`
-			: "Nudge: no child message route registered",
-		`Status: subagent({ action: "status", id: "${runTarget}" })`,
-		`Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`,
-	].join("\n");
-}
-
-export function formatControlIntercomMessage(event: ControlEvent, childIntercomTarget?: string): string {
-	return [
-		"subagent needs attention",
-		"",
-		`${event.agent} needs attention in run ${event.runId}.`,
-		"",
-		formatControlNoticeMessage(event, childIntercomTarget),
-	].join("\n");
-}