@selesai/code 0.10.2 → 0.12.0

package/dist/extensions/context-compaction-reminder.ts

@@ -1,28 +1,28 @@
-import type { ExtensionAPI } from "@selesai/code";
-
-export const CONTEXT_COMPACTION_REMINDER_THRESHOLD = 128_000;
-export const CONTEXT_COMPACTION_REMINDER_MESSAGE =
-	`Conversation context has reached ${CONTEXT_COMPACTION_REMINDER_THRESHOLD.toLocaleString()} tokens. Run /handoff-new to summarize into a new chat, or enable Auto Handoff in Settings to do this automatically. Bigger context windows eat up tokens quickly and degrade AI quality.`;
-
-export default function contextCompactionReminderExtension(pi: ExtensionAPI): void {
-	let reminderShown = false;
-
-	pi.on("session_compact", () => {
-		reminderShown = false;
-	});
-
-	pi.on("agent_settled", (_event, ctx) => {
-		const tokens = ctx.getContextUsage()?.tokens;
-		if (tokens === undefined || tokens === null) return;
-
-		if (tokens < CONTEXT_COMPACTION_REMINDER_THRESHOLD) {
-			reminderShown = false;
-			return;
-		}
-
-		if (!reminderShown) {
-			ctx.ui.notify(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
-			reminderShown = true;
-		}
-	});
-}
+import type { ExtensionAPI } from "@selesai/code";
+
+export const CONTEXT_COMPACTION_REMINDER_THRESHOLD = 128_000;
+export const CONTEXT_COMPACTION_REMINDER_MESSAGE =
+	`Conversation context has reached ${CONTEXT_COMPACTION_REMINDER_THRESHOLD.toLocaleString()} tokens. Run /handoff-new to summarize into a new chat, or enable Auto Handoff in Settings to do this automatically. Bigger context windows eat up tokens quickly and degrade AI quality.`;
+
+export default function contextCompactionReminderExtension(pi: ExtensionAPI): void {
+	let reminderShown = false;
+
+	pi.on("session_compact", () => {
+		reminderShown = false;
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		const tokens = ctx.getContextUsage()?.tokens;
+		if (tokens === undefined || tokens === null) return;
+
+		if (tokens < CONTEXT_COMPACTION_REMINDER_THRESHOLD) {
+			reminderShown = false;
+			return;
+		}
+
+		if (!reminderShown) {
+			ctx.ui.notify(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
+			reminderShown = true;
+		}
+	});
+}

package/dist/extensions/cost-reconcile.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { extractCosts, parseCostHeader } from "./cost-reconcile.ts";
+
+describe("parseCostHeader", () => {
+	it("parses LiteLLM scientific-notation cost", () => {
+		expect(parseCostHeader("4.45284e-06")).toBe(4.45284e-6);
+	});
+
+	it("parses plain decimal cost", () => {
+		expect(parseCostHeader("0.00123")).toBe(0.00123);
+	});
+
+	it("rejects null, garbage, and negatives", () => {
+		expect(parseCostHeader(null)).toBeUndefined();
+		expect(parseCostHeader("abc")).toBeUndefined();
+		expect(parseCostHeader("-1")).toBeUndefined();
+	});
+});
+
+describe("extractCosts", () => {
+	it("reads OpenRouter chat-completions usage cost from a final SSE chunk", () => {
+		const body =
+			'Data: {"id":"gen-abc","provider":"OpenAI"}\n\n' +
+			'data: {"id":"gen-abc","usage":{"prompt_tokens":10,"cost":0.0123},"choices":[]}\n\n' +
+			"data: [DONE]\n\n";
+		const { ids, cost } = extractCosts(body);
+		expect(ids).toContain("gen-abc");
+		expect(cost).toBe(0.0123);
+	});
+
+	it("reads OpenRouter native total_cost from a JSON body", () => {
+		const { ids, cost } = extractCosts(
+			'{"id":"gen-xyz","total_cost":0.05152,"usage":{"total_tokens":330}}',
+		);
+		expect(ids).toEqual(["gen-xyz"]);
+		expect(cost).toBe(0.05152);
+	});
+
+	it("reads object-shaped cost {total} payloads", () => {
+		const { cost } = extractCosts('{"id":"gen-obj","cost":{"input":0.01,"total":0.0456}}');
+		expect(cost).toBe(0.0456);
+	});
+
+	it("keeps the last cost when multiple chunks carry usage", () => {
+		const body =
+			'data: {"id":"gen-1","usage":{"cost":0.01}}\n\ndata: {"id":"gen-1","usage":{"cost":0.02}}\n\n';
+		const { cost } = extractCosts(body);
+		expect(cost).toBe(0.02);
+	});
+
+	it("returns no cost when the payload has none", () => {
+		const { ids, cost } = extractCosts('data: {"id":"resp-1","delta":"hi"}\n\n');
+		expect(ids).toContain("resp-1");
+		expect(cost).toBeUndefined();
+	});
+
+	it("ignores negative or non-finite costs", () => {
+		const { cost } = extractCosts('{"id":"gen-neg","cost":-1}');
+		expect(cost).toBeUndefined();
+	});
+
+	it("extracts ids from anthropic-style message_start without cost", () => {
+		const body =
+			'event: message_start\ndata: {"type":"message_start","message":{"id":"msg_01ABC","usage":{}}}\n\n' +
+			'event: message_delta\ndata: {"type":"message_delta","usage":{"output_tokens":15}}\n\n';
+		const { ids, cost } = extractCosts(body);
+		expect(ids).toContain("msg_01ABC");
+		expect(cost).toBeUndefined();
+	});
+
+	it("caps captured ids", () => {
+		const body = Array.from({ length: 100 }, (_, i) => `{"id":"id-${i}"}`).join("\n");
+		const { ids } = extractCosts(body);
+		expect(ids.length).toBe(50);
+	});
+});

package/dist/extensions/cost-reconcile.ts

@@ -0,0 +1,278 @@
+/**
+ * Cost Reconcile — records the real billed cost the provider reports in its
+ * own response payload, for any provider that includes one.
+ *
+ * pi-ai reads token counts from provider payloads but discards any
+ * provider-reported `cost` field, recomputing cost from the local rate card.
+ * For gateways (OpenRouter etc.) and custom catalog entries that bill with
+ * their own tokenizers or dated pricing, the estimate diverges from the bill.
+ *
+ * Extensions cannot hook the response body through the event API
+ * (`after_provider_response` exposes only status/headers), but provider SDKs
+ * fall back to `globalThis.fetch`. This extension installs a tee-wrapping
+ * fetch once per process: LLM API responses are scanned for a
+ * provider-reported cost (LiteLLM `x-litellm-response-cost` header,
+ * OpenRouter `usage.cost`, `total_cost`, plus object-shaped `cost.total`)
+ * and its response id, then recorded as a custom session entry on
+ * `message_end`.
+ *
+ * Providers whose payloads carry no cost (first-party OpenAI/Anthropic due to
+ * their usage APIs) simply record nothing — their rate-card estimate matches
+ * their bill anyway when catalog prices are configured.
+ *
+ * The zentui footer prefers reconciled entries over the rate-card total when
+ * both exist for the same response id.
+ */
+
+import type { ExtensionAPI } from "@selesai/code";
+
+const ENTRY_TYPE = "cost-reconcile";
+const ENTRY_VERSION = 1 as const;
+
+// Guard against pathological bodies; real usage chunks arrive well under 1MB.
+const MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
+// Only LLM API paths are tee'd and scanned; unrelated fetches (web fetch tool,
+// model catalog refreshes) pass through untouched.
+const LLM_PATH_RE = /(\/chat\/completions|\/responses|\/messages\b|:streamGenerateContent)/;
+const MAX_CAPTURED_IDS = 50;
+const MAX_PENDING_LOOKUPS = 200;
+const MAX_SESSION_ENTRIES = 2_000;
+
+type ReconcileEntry = {
+	version: typeof ENTRY_VERSION;
+	provider: string;
+	model: string;
+	responseId: string;
+	/** Provider-reported billed cost in USD. */
+	cost: number;
+	reconciledAt: number;
+	source: "payload";
+};
+
+/**
+ * Scan a captured SSE/JSON body for provider-reported cost and response ids.
+ * Exported for tests.
+ *
+ * In streams, usage lands in the final chunk, so the LAST cost match wins.
+ */
+type MessageInfo = {
+	provider: string;
+	model: string;
+	responseId: string;
+};
+
+// Process-wide capture state. The fetch patch is installed once per process
+// and must not capture session-bound `pi`; per-session message_end handlers
+// read these maps and write entries through their own session's appendEntry.
+const processCaptured = new Map<string, number>();
+const processWaiting = new Map<
+	string,
+	{ info: MessageInfo; write: (info: MessageInfo, cost: number) => void }
+>();
+
+/**
+ * Scan a captured SSE/JSON body for provider-reported cost and response ids.
+ * Pure function; exported for tests.
+ *
+ * In streams, usage lands in the final chunk, so the LAST cost match wins.
+ */
+/**
+ * Parse a LiteLLM `x-litellm-response-cost` header value (a USD float,
+ * possibly in scientific notation). Exported for tests.
+ */
+export function parseCostHeader(value: string | null): number | undefined {
+	if (value === null) return undefined;
+	const cost = Number(value);
+	return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
+}
+
+export function extractCosts(
+	text: string,
+): { ids: string[]; cost?: number } {
+	const ids = new Set<string>();
+	for (const match of text.matchAll(/"id"\s*:\s*"([^"]{1,200})"/g)) {
+		ids.add(match[1]);
+		if (ids.size >= MAX_CAPTURED_IDS) break;
+	}
+
+	// OpenRouter native API uses `total_cost`; chat-completions streams use
+	// `cost` (number or `{total}`); gateways behind the responses API have
+	// been observed with object-shaped cost too.
+	let cost: number | undefined;
+	for (const match of text.matchAll(
+		/"total_cost"\s*:\s*(-?[\d.eE+]+)|"cost"\s*:\s*(-?[\d.eE+]+)|"cost"\s*:\s*\{[^}]*?"total"\s*:\s*(-?[\d.eE+]+)/g,
+	)) {
+		const value = Number(match[1] ?? match[2] ?? match[3]);
+		if (Number.isFinite(value) && value >= 0) cost = value;
+	}
+
+	return { ids: [...ids], cost };
+}
+
+function isLlmUrl(input: unknown): boolean {
+	try {
+		const url =
+			typeof input === "string"
+				? input
+				: input instanceof URL
+					? input.href
+					: input instanceof Request
+						? input.url
+						: undefined;
+		if (!url) return false;
+		if (!/^https?:/i.test(url)) return false;
+		return LLM_PATH_RE.test(url);
+	} catch {
+		return false;
+	}
+}
+
+/** Install the capture fetch once per process, across extension reloads. */
+const FETCH_PATCHED = Symbol.for("selesai.cost-reconcile.fetch-patched");
+
+export default function costReconcileExtension(pi: ExtensionAPI): void {
+	/** Response ids already written to this session's file. */
+	const seen = new Set<string>();
+	let entriesWritten = 0;
+
+	const writeEntry = (info: MessageInfo, cost: number): void => {
+		if (seen.has(info.responseId) || entriesWritten >= MAX_SESSION_ENTRIES) return;
+		seen.add(info.responseId);
+		entriesWritten += 1;
+		const entry: ReconcileEntry = {
+			version: ENTRY_VERSION,
+			provider: info.provider,
+			model: info.model,
+			responseId: info.responseId,
+			cost,
+			reconciledAt: Date.now(),
+			source: "payload",
+		};
+		try {
+			pi.appendEntry(ENTRY_TYPE, entry);
+		} catch {
+			// transcript persistence failure must not break the session
+		}
+	};
+
+	const finishCapture = (rawBody: string, headerCost?: number): void => {
+		// ponytail: one naive regex pass over the whole body; a streaming
+		// parser only matters if bodies grow past the 4MB cap.
+		const { ids, cost } = extractCosts(rawBody);
+		// LiteLLM's header is the amount the gateway billed; prefer it over
+		// any cost the upstream payload reports.
+		const effectiveCost = headerCost ?? cost;
+		if (effectiveCost === undefined) return;
+		for (const responseId of ids) {
+			processCaptured.set(responseId, effectiveCost);
+			const waiting = processWaiting.get(responseId);
+			if (waiting) {
+				processWaiting.delete(responseId);
+				waiting.write(waiting.info, effectiveCost);
+			}
+		}
+		if (processCaptured.size > 500) {
+			for (const key of [...processCaptured.keys()].slice(0, processCaptured.size - 500))
+				processCaptured.delete(key);
+		}
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		try {
+			const entries =
+				(
+					ctx.sessionManager as {
+						getEntries?: () => readonly { type?: string; customType?: string; data?: ReconcileEntry }[];
+					}
+				).getEntries?.() ?? [];
+			for (const entry of entries) {
+				if (entry?.type !== "custom" || entry?.customType !== ENTRY_TYPE) continue;
+				const responseId = entry?.data?.responseId;
+				if (typeof responseId === "string") seen.add(responseId);
+			}
+		} catch {
+			// best effort only
+		}
+
+		const globalFetch = globalThis as typeof globalThis & { [FETCH_PATCHED]?: boolean };
+		if (globalFetch[FETCH_PATCHED]) return;
+		globalFetch[FETCH_PATCHED] = true;
+		const realFetch = globalThis.fetch.bind(globalThis);
+		globalThis.fetch = async (input, init) => {
+			const response = await realFetch(input as Parameters<typeof realFetch>[0], init);
+			try {
+				if (!isLlmUrl(input)) return response;
+				const contentType = response.headers.get("content-type") ?? "";
+				if (!contentType.includes("json") && !contentType.includes("event-stream")) return response;
+				if (!response.body) return response;
+				const headerCost = parseCostHeader(response.headers.get("x-litellm-response-cost"));
+				const [main, tee] = response.body.tee();
+				void (async () => {
+					let raw = "";
+					try {
+						const reader = tee.getReader();
+						const decoder = new TextDecoder();
+						for (;;) {
+							const { done, value } = await reader.read();
+							if (done) break;
+							raw += decoder.decode(value, { stream: true });
+							if (raw.length > MAX_CAPTURE_BYTES) break;
+						}
+					} catch {
+						// capture is best-effort; the main branch is unaffected
+					}
+					finishCapture(raw, headerCost);
+				})();
+				// Preserve response identity as seen by the SDK: body swapped, rest identical.
+				return new Response(main, {
+					status: response.status,
+					statusText: response.statusText,
+					headers: response.headers,
+				});
+			} catch {
+				return response;
+			}
+		};
+	});
+
+	pi.on("message_end", (event) => {
+		const message = event.message as
+			| {
+					role?: string;
+					provider?: string;
+					model?: string;
+					responseId?: string;
+					stopReason?: string;
+				}
+			| undefined;
+		if (!message || message.role !== "assistant") return;
+		if (message.stopReason === "error" || message.stopReason === "aborted") return;
+		const responseId = message.responseId;
+		if (typeof responseId !== "string" || responseId.length === 0) return;
+
+		const info: MessageInfo = {
+			provider: message.provider ?? "",
+			model: message.responseModel ?? message.model ?? "",
+			responseId,
+		};
+		const cost = processCaptured.get(responseId);
+		if (cost !== undefined) {
+			writeEntry(info, cost);
+			return;
+		}
+		// The tee branch may finish after message_end; remember the message so
+		// the capture can match it on completion and write via this session.
+		if (!seen.has(responseId) && !processWaiting.has(responseId)) {
+			waitingLimitGuard();
+			processWaiting.set(responseId, { info, write: writeEntry });
+		}
+	});
+}
+
+// Trim oldest waiting entries so unclaimed captures cannot grow unbounded.
+function waitingLimitGuard(): void {
+	if (processWaiting.size >= MAX_PENDING_LOOKUPS) {
+		for (const key of [...processWaiting.keys()].slice(0, processWaiting.size - MAX_PENDING_LOOKUPS + 1))
+			processWaiting.delete(key);
+	}
+}

package/dist/extensions/enable-readonly-tools.test.ts

@@ -22,6 +22,7 @@ function setup() {
 			handler = registeredHandler;
 		}),
 		registerTool: vi.fn((tool: { name: string }) => active.add(tool.name)),
+		getAllTools: vi.fn(() => [...active].map((name) => ({ name }))),
 	};
 	enableReadonlyTools(pi as any);
 	return { active, handler, pi };
@@ -49,4 +50,14 @@ describe("enable-readonly-tools", () => {
 		expect(pi.registerTool).toHaveBeenCalledTimes(3);
 		expect(createGrepToolDefinition).toHaveBeenCalledWith("/project");
 	});
+
+	it("does not replace a display extension's existing readonly renderers", () => {
+		const { active, handler, pi } = setup();
+		active.add("grep");
+		active.add("find");
+		active.add("ls");
+
+		handler({ toolName: "read", isError: false }, { cwd: "/project" });
+		expect(pi.registerTool).not.toHaveBeenCalled();
+	});
 });

package/dist/extensions/enable-readonly-tools.ts

@@ -13,8 +13,12 @@ export default function (pi: ExtensionAPI) {
 	pi.on("tool_execution_end", (event, ctx) => {
 		if (enabled || event.isError || !bootstrapTools.has(event.toolName)) return;
 		enabled = true;
-		pi.registerTool(createGrepToolDefinition(ctx.cwd));
-		pi.registerTool(createFindToolDefinition(ctx.cwd));
-		pi.registerTool(createLsToolDefinition(ctx.cwd));
+
+		// pi-tool-display may already own these renderer definitions. Re-registering
+		// Pi's plain built-ins here silently discarded its boxed grep/find/ls views.
+		const active = new Set(pi.getAllTools().map((tool) => tool.name));
+		if (!active.has("grep")) pi.registerTool(createGrepToolDefinition(ctx.cwd));
+		if (!active.has("find")) pi.registerTool(createFindToolDefinition(ctx.cwd));
+		if (!active.has("ls")) pi.registerTool(createLsToolDefinition(ctx.cwd));
 	});
 }

package/dist/extensions/package.json

@@ -6,8 +6,10 @@
 	"pi": {
 		"extensions": [
 			"./agent-browser.ts",
+		"./auto-session-name.ts",
 			"./copy-turn.ts",
 			"./context-compaction-reminder.ts",
+			"./cost-reconcile.ts",
 			"./enable-readonly-tools.ts",
 			"./pi-intercom/index.ts",
 			"./ponytail/index.js",
@@ -20,6 +22,7 @@
 			"./tokenin-onboarding.ts",
 			"./undo.ts",
 			"./pi-subagents",
+			"./pi-tool-display",
 			"./pi-web-agent",
 			"./web-agent-onboarding.ts",
 			"./tps.ts",

package/dist/extensions/pi-intercom/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Nico Bailon
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Nico Bailon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.