@diegopetrucci/pi-extensions 0.1.57 → 0.1.59

package/extensions/triage-comments/index.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
 import type { AgentSession, ExecResult, ExtensionAPI, ExtensionCommandContext, ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import type { Usage } from "@earendil-works/pi-ai";
 import {
 	DefaultResourceLoader,
 	SessionManager,
@@ -91,6 +92,13 @@ const MUTATING_GH_API_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
 
 type TriageStatus = "running" | "done" | "error" | "aborted";
 
+type CreateAgentSessionOptions = NonNullable<Parameters<typeof createAgentSession>[0]>;
+
+function getModelRuntimeOption(ctx: { modelRegistry?: unknown }): Pick<CreateAgentSessionOptions, "modelRuntime"> {
+	const modelRuntime = (ctx.modelRegistry as { runtime?: CreateAgentSessionOptions["modelRuntime"] } | undefined)?.runtime;
+	return modelRuntime ? { modelRuntime } : {};
+}
+
 type ToolCall = {
 	id: string;
 	name: string;
@@ -322,26 +330,72 @@ function ensureImplementationNote(text: string): string {
 	return `${trimmed}\n\n---\n${IMPLEMENTATION_NOTE}`;
 }
 
-function extractLastAssistantText(messages: unknown[]): string {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const message = messages[i] as { role?: string; content?: unknown };
-		if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
-		const parts: string[] = [];
-		for (const part of message.content) {
-			if (part && typeof part === "object" && (part as { type?: string }).type === "text") {
-				const text = (part as { text?: unknown }).text;
-				if (typeof text === "string") parts.push(text);
-			}
-		}
-		if (parts.length) return parts.join("").trim();
+function createEmptyUsage(): Usage {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+}
+
+function addUsage(total: Usage, usage: Usage): void {
+	total.input += usage.input || 0;
+	total.output += usage.output || 0;
+	total.cacheRead += usage.cacheRead || 0;
+	total.cacheWrite += usage.cacheWrite || 0;
+	if (usage.cacheWrite1h !== undefined) total.cacheWrite1h = (total.cacheWrite1h ?? 0) + usage.cacheWrite1h;
+	if (usage.reasoning !== undefined) total.reasoning = (total.reasoning ?? 0) + usage.reasoning;
+	total.totalTokens += usage.totalTokens || 0;
+	total.cost.input += usage.cost?.input || 0;
+	total.cost.output += usage.cost?.output || 0;
+	total.cost.cacheRead += usage.cost?.cacheRead || 0;
+	total.cost.cacheWrite += usage.cost?.cacheWrite || 0;
+	total.cost.total += usage.cost?.total || 0;
+}
+
+type AssistantLikeMessage = { role?: string; content?: unknown; stopReason?: unknown; errorMessage?: unknown; usage?: unknown };
+
+function addAssistantMessageUsage(total: Usage, message: unknown): void {
+	const assistant = message as AssistantLikeMessage;
+	if (assistant?.role !== "assistant" || !assistant.usage || typeof assistant.usage !== "object") return;
+	addUsage(total, assistant.usage as Usage);
+}
+
+function aggregateAssistantUsage(messages: unknown[]): Usage {
+	const total = createEmptyUsage();
+	for (const message of messages) addAssistantMessageUsage(total, message);
+	return total;
+}
+
+function addSessionEventUsage(total: Usage, event: unknown): void {
+	const sessionEvent = event as { type?: string; message?: unknown; result?: { usage?: Usage } };
+	if (sessionEvent?.type === "message_end") return void addAssistantMessageUsage(total, sessionEvent.message);
+	if (sessionEvent?.type === "compaction_end" && sessionEvent.result?.usage) addUsage(total, sessionEvent.result.usage);
+}
+
+function inspectFinalAssistant(messages: unknown[]):
+	| { ok: true; answer: string; stopReason?: string }
+	| { ok: false; reason: string; stopReason?: string; errorMessage?: string } {
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const message = messages[i] as AssistantLikeMessage;
+		if (message?.role !== "assistant") continue;
+		const stopReason = typeof message.stopReason === "string" ? message.stopReason.trim() : "";
+		const errorMessage = typeof message.errorMessage === "string" ? message.errorMessage.trim() : "";
+		const answer = Array.isArray(message.content)
+			? message.content
+				.map((part) => (part && typeof part === "object" && (part as { type?: string }).type === "text" && typeof (part as { text?: unknown }).text === "string"
+					? (part as { text: string }).text
+					: ""))
+				.join("")
+				.trim()
+			: "";
+		if (stopReason === "error") return { ok: false, reason: `triage_comments subagent error: ${errorMessage || "provider/model error"}`, stopReason, errorMessage };
+		if (stopReason === "aborted") return { ok: false, reason: "triage_comments subagent aborted before producing a usable answer", stopReason };
+		if (answer) return { ok: true, answer, stopReason: stopReason || undefined };
+		return { ok: false, reason: stopReason ? `triage_comments subagent produced no final assistant text (stopReason: ${stopReason})` : "triage_comments subagent produced no final assistant text", stopReason: stopReason || undefined, errorMessage: errorMessage || undefined };
 	}
-	return "";
+	return { ok: false, reason: "triage_comments subagent produced no assistant message" };
 }
 
-function isAbortLikeError(error: unknown): boolean {
-	if (error && typeof error === "object" && (error as { name?: unknown }).name === "AbortError") return true;
-	const message = error instanceof Error ? error.message : String(error);
-	return /aborted|cancelled|canceled/i.test(message);
+function classifyRunFailure(error: unknown, aborted: boolean): { status: "aborted" | "error"; message: string; error?: string } {
+	const message = aborted ? "Aborted" : error instanceof Error ? error.message : String(error);
+	return { status: aborted ? "aborted" : "error", message, error: aborted ? undefined : message };
 }
 
 function isInside(parent: string, child: string): boolean {
@@ -1897,9 +1951,21 @@ export const __test__ = {
 	parseSelectionList,
 	parseTriageCommandArgs,
 	prepareArguments,
+	aggregateAssistantUsage,
+	addAssistantMessageUsage,
+	addSessionEventUsage,
+	inspectFinalAssistant,
+	classifyRunFailure,
 };
 
 export default function triageCommentsExtension(pi: ExtensionAPI) {
+	pi.on("tool_result", async (event) => {
+		if (event.toolName !== "triage_comments") return undefined;
+		const details = event.details as { status?: unknown } | undefined;
+		if (details?.status !== "error") return undefined;
+		return { isError: true };
+	});
+
 	pi.registerCommand("triage-comments", {
 		description: "Collect pasted feedback or PR comments, then start a triage_comments investigation",
 		getArgumentCompletions: (prefix) => {
@@ -1981,24 +2047,29 @@ export default function triageCommentsExtension(pi: ExtensionAPI) {
 			let unsubscribe: (() => void) | undefined;
 			let runTimeout: NodeJS.Timeout | undefined;
 			let abortListenerAdded = false;
-			let aborted = Boolean(signal?.aborted);
+			let callerAborted = Boolean(signal?.aborted);
+			const usage = createEmptyUsage();
 
 			const emit = () => {
 				onUpdate?.({ content: [{ type: "text", text: lastContent }], details });
 			};
 
-			const abort = () => {
-				aborted = true;
+			const abortForCleanup = () => {
+				void session?.abort();
+			};
+
+			const abortFromCaller = () => {
+				callerAborted = true;
 				details.status = "aborted";
 				details.endedAt = Date.now();
 				lastContent = "Aborted";
 				emit();
-				void session?.abort();
+				abortForCleanup();
 			};
 
-			if (signal?.aborted) abort();
+			if (signal?.aborted) abortFromCaller();
 			if (signal && !signal.aborted) {
-				signal.addEventListener("abort", abort);
+				signal.addEventListener("abort", abortFromCaller);
 				abortListenerAdded = true;
 			}
 
@@ -2035,7 +2106,7 @@ export default function triageCommentsExtension(pi: ExtensionAPI) {
 
 				const created = await createAgentSession({
 					cwd,
-					modelRegistry: ctx.modelRegistry,
+					...getModelRuntimeOption(ctx),
 					resourceLoader,
 					settingsManager: isolatedSettingsManager,
 					sessionManager: SessionManager.inMemory(cwd),
@@ -2046,6 +2117,7 @@ export default function triageCommentsExtension(pi: ExtensionAPI) {
 
 				session = created.session;
 				unsubscribe = session.subscribe((event) => {
+					addSessionEventUsage(usage, event);
 					switch (event.type) {
 						case "turn_end":
 							details.turns += 1;
@@ -2075,32 +2147,40 @@ export default function triageCommentsExtension(pi: ExtensionAPI) {
 					}
 				});
 
-				if (!aborted) {
+				if (!callerAborted) {
 					const promptPromise = session.prompt(buildUserPrompt(input, cwd), { expandPromptTemplates: false });
 					const timeoutPromise = new Promise<never>((_resolve, reject) => {
 						runTimeout = setTimeout(() => {
-							abort();
+							abortForCleanup();
 							reject(new Error(`triage_comments timed out after ${Math.round(MAX_RUN_MS / 1000)} seconds.`));
 						}, MAX_RUN_MS);
 					});
 					await Promise.race([promptPromise, timeoutPromise]);
 				}
 
-				const answer = session ? extractLastAssistantText(session.state.messages) : "";
-				lastContent = answer ? ensureImplementationNote(answer) : aborted ? "Aborted" : "(no output)";
-				details.status = aborted ? "aborted" : "done";
+				const outcome = session ? inspectFinalAssistant(session.state.messages) : { ok: false as const, reason: "the isolated triage_comments session produced no assistant message" };
+				if (outcome.ok) {
+					lastContent = ensureImplementationNote(outcome.answer);
+					details.status = "done";
+				} else if (callerAborted) {
+					lastContent = "Aborted";
+					details.status = "aborted";
+				} else {
+					throw new Error(outcome.reason);
+				}
 				details.endedAt = Date.now();
 				emit();
 
 				return {
 					content: [{ type: "text", text: lastContent }],
 					details,
+					usage,
 				};
 			} catch (error) {
-				const wasAbort = aborted || isAbortLikeError(error);
-				const message = wasAbort ? "Aborted" : error instanceof Error ? error.message : String(error);
-				details.status = wasAbort ? "aborted" : "error";
-				details.error = wasAbort ? undefined : message;
+				const failure = classifyRunFailure(error, callerAborted);
+				const { message } = failure;
+				details.status = failure.status;
+				details.error = failure.error;
 				details.endedAt = Date.now();
 				lastContent = message;
 				emit();
@@ -2108,10 +2188,11 @@ export default function triageCommentsExtension(pi: ExtensionAPI) {
 				return {
 					content: [{ type: "text", text: message }],
 					details,
+					usage,
 				};
 			} finally {
 				if (runTimeout) clearTimeout(runTimeout);
-				if (signal && abortListenerAdded) signal.removeEventListener("abort", abort);
+				if (signal && abortListenerAdded) signal.removeEventListener("abort", abortFromCaller);
 				unsubscribe?.();
 				session?.dispose();
 			}

package/extensions/triage-comments/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-triage-comments",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "A pi extension that adds /triage-comments and a read-only triage_comments subagent tool for review-comment triage.",
   "keywords": [
     "pi-package",
@@ -33,5 +33,9 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "description": "A collection of pi extensions and skills for annotation UIs, context management, workflow audits, contrarian review, review-comment triage, notifications, brrr push alerts, safety guards, GitHub research, repo-local knowledge, todos, tool rendering, model/provider helpers, and Xiaohei-style article illustrations.",
   "keywords": [
     "pi-package",
@@ -17,7 +17,8 @@
     "ci": "npm run preflight:install-state && npm run typecheck && npm test",
     "preflight:install-state": "node scripts/check-install-state.mjs",
     "test": "node --test test/*.test.mjs",
-    "typecheck": "npx tsc --noEmit --module NodeNext --moduleResolution NodeNext --target ES2022 --skipLibCheck $(git ls-files '*.ts')"
+    "typecheck": "tsc -p tsconfig.json",
+    "prepare-release": "node scripts/prepare-release.mjs"
   },
   "files": [
     "extensions",
@@ -71,9 +72,9 @@
     ]
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.80.6",
-    "@earendil-works/pi-coding-agent": "^0.80.6",
-    "@earendil-works/pi-tui": "^0.80.6",
+    "@earendil-works/pi-ai": "^0.81.1",
+    "@earendil-works/pi-coding-agent": "^0.81.1",
+    "@earendil-works/pi-tui": "^0.81.1",
     "@types/node": "^25.9.1",
     "husky": "^9.1.7",
     "typebox": "^1.3.6",
@@ -85,6 +86,9 @@
     "monaco-editor": "0.52.2"
   },
   "overrides": {
-    "protobufjs": "^7.6.4"
+    "protobufjs": "^7.6.5"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   }
 }