@oh-my-pi/pi-coding-agent 17.0.4 → 17.0.6

package/src/modes/rpc/rpc-frame.ts

@@ -0,0 +1,156 @@
+import { isDeepStrictEqual } from "node:util";
+import { isRecord } from "@oh-my-pi/pi-utils";
+
+/** Maximum UTF-8 size of one newline-delimited RPC frame, including the newline. */
+export const MAX_RPC_FRAME_BYTES = 1024 * 1024;
+
+interface ShrinkPass {
+	stringCap: number;
+	arrayLimit: number;
+	objectLimit: number;
+}
+
+const SHRINK_PASSES: readonly ShrinkPass[] = [
+	{ stringCap: 256 * 1024, arrayLimit: 512, objectLimit: 512 },
+	{ stringCap: 64 * 1024, arrayLimit: 256, objectLimit: 256 },
+	{ stringCap: 16 * 1024, arrayLimit: 128, objectLimit: 128 },
+	{ stringCap: 4 * 1024, arrayLimit: 64, objectLimit: 64 },
+	{ stringCap: 1024, arrayLimit: 32, objectLimit: 32 },
+	{ stringCap: 256, arrayLimit: 8, objectLimit: 16 },
+	{ stringCap: 64, arrayLimit: 1, objectLimit: 8 },
+];
+
+const STRING_ELISION_RESERVE = 80;
+const METADATA_STRING_CAP = 1024;
+
+function serializedFrameBytes(json: string): number {
+	return Buffer.byteLength(json, "utf8") + 1;
+}
+
+function shrinkString(value: string, cap: number): string {
+	if (value.length <= cap) return value;
+	const headLength = Math.max(0, cap - STRING_ELISION_RESERVE);
+	return `${value.slice(0, headLength)}\n…[${value.length - headLength} chars elided for RPC frame]`;
+}
+
+function shrinkValue(value: unknown, pass: ShrinkPass): unknown {
+	if (typeof value === "string") return shrinkString(value, pass.stringCap);
+	if (Array.isArray(value)) {
+		const keep = Math.min(value.length, pass.arrayLimit);
+		const output: unknown[] = new Array(keep + (keep < value.length ? 1 : 0));
+		for (let index = 0; index < keep; index++) output[index] = shrinkValue(value[index], pass);
+		if (keep < value.length) output[keep] = `…[${value.length - keep} items elided for RPC frame]`;
+		return output;
+	}
+	if (isRecord(value)) {
+		const entries = Object.entries(value);
+		const keep = Math.min(entries.length, pass.objectLimit);
+		const output: Record<string, unknown> = {};
+		for (let index = 0; index < keep; index++) {
+			const [key, item] = entries[index];
+			output[key] = shrinkValue(item, pass);
+		}
+		if (keep < entries.length) output.rpcFrameElidedKeys = entries.length - keep;
+		return output;
+	}
+	return value;
+}
+
+function jsonSnapshot(value: unknown): unknown {
+	const json = JSON.stringify(value);
+	return json === undefined ? undefined : JSON.parse(json);
+}
+
+function encodedMessageSnapshot(encoded: string): { message: unknown } | undefined {
+	const frame = JSON.parse(encoded);
+	return isRecord(frame) && frame.type === "message_end" && Object.hasOwn(frame, "message")
+		? { message: frame.message }
+		: undefined;
+}
+
+function compactTerminalFrame(
+	frame: object,
+	streamedMessageCount: number,
+	streamedMessages?: readonly unknown[],
+): object {
+	if (!isRecord(frame) || frame.type !== "agent_end" || !Array.isArray(frame.messages)) return frame;
+	let streamed = Number.isSafeInteger(streamedMessageCount)
+		? Math.min(Math.max(0, streamedMessageCount), frame.messages.length)
+		: 0;
+	if (streamedMessages) {
+		streamed = 0;
+		const limit = Math.min(streamedMessages.length, frame.messages.length);
+		while (
+			streamed < limit &&
+			isDeepStrictEqual(streamedMessages[streamed], jsonSnapshot(frame.messages[streamed]))
+		) {
+			streamed++;
+		}
+	}
+	return {
+		...frame,
+		messages: frame.messages.slice(streamed),
+		messageCount: frame.messages.length,
+	};
+}
+
+function overflowFrame(frame: object): object {
+	if (!isRecord(frame)) return { type: "rpc_frame_error", error: "RPC frame exceeded the transport limit" };
+	if (frame.type === "response") {
+		return {
+			id: typeof frame.id === "string" ? shrinkString(frame.id, METADATA_STRING_CAP) : undefined,
+			type: "response",
+			command: typeof frame.command === "string" ? shrinkString(frame.command, METADATA_STRING_CAP) : "unknown",
+			success: false,
+			error: "RPC response exceeded the transport limit",
+		};
+	}
+	if (frame.type === "agent_end") {
+		return {
+			type: "agent_end",
+			messages: [],
+			messageCount: typeof frame.messageCount === "number" ? frame.messageCount : 0,
+		};
+	}
+	return {
+		type: "rpc_frame_error",
+		originalType: typeof frame.type === "string" ? shrinkString(frame.type, METADATA_STRING_CAP) : undefined,
+		error: "RPC frame exceeded the transport limit",
+	};
+}
+
+/** Serialize a complete JSONL frame while enforcing the transport byte ceiling. */
+export function encodeRpcFrame(frame: object, streamedMessageCount = 0, streamedMessages?: readonly unknown[]): string {
+	let json = JSON.stringify(frame);
+	if (serializedFrameBytes(json) <= MAX_RPC_FRAME_BYTES) return `${json}\n`;
+	if (isRecord(frame) && frame.type === "response") {
+		return `${JSON.stringify(overflowFrame(frame))}\n`;
+	}
+
+	const compacted = compactTerminalFrame(frame, streamedMessageCount, streamedMessages);
+	json = JSON.stringify(compacted);
+	if (serializedFrameBytes(json) <= MAX_RPC_FRAME_BYTES) return `${json}\n`;
+
+	for (const pass of SHRINK_PASSES) {
+		json = JSON.stringify(shrinkValue(compacted, pass));
+		if (serializedFrameBytes(json) <= MAX_RPC_FRAME_BYTES) return `${json}\n`;
+	}
+
+	return `${JSON.stringify(overflowFrame(compacted))}\n`;
+}
+
+/** Stateful encoder that tracks which messages a client has already received. */
+export class RpcFrameEncoder {
+	#streamedMessages: unknown[] = [];
+
+	encode(frame: object): string {
+		if (isRecord(frame) && frame.type === "agent_start") this.#streamedMessages = [];
+		const encoded = encodeRpcFrame(frame, this.#streamedMessages.length, this.#streamedMessages);
+		if (!isRecord(frame)) return encoded;
+		if (frame.type === "message_end") {
+			const snapshot = encodedMessageSnapshot(encoded);
+			if (snapshot) this.#streamedMessages.push(snapshot.message);
+		} else if (frame.type === "agent_end" && frame.willContinue !== true) this.#streamedMessages = [];
+		return encoded;
+	}
+}

package/src/modes/rpc/rpc-input.ts

@@ -0,0 +1,38 @@
+/**
+ * Claims Bun's singleton stdin reader immediately and exposes a separately readable stream.
+ * RPC startup uses this before extension discovery so in-process modules cannot steal protocol input.
+ */
+export function claimRpcInput(): ReadableStream<Uint8Array> {
+	const reader = Bun.stdin.stream().getReader();
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		try {
+			reader.releaseLock();
+		} catch {}
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await reader.read();
+				if (result.done) {
+					release();
+					controller.close();
+				} else {
+					controller.enqueue(result.value);
+				}
+			} catch (error) {
+				release();
+				controller.error(error);
+			}
+		},
+		async cancel() {
+			try {
+				await reader.cancel();
+			} finally {
+				release();
+			}
+		},
+	});
+}

package/src/modes/rpc/rpc-mode.ts

@@ -34,6 +34,8 @@ import type { EventBus } from "../../utils/event-bus";
 import { initializeExtensions } from "../runtime-init";
 import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
 import { isRpcHostUriResult, RpcHostUriBridge } from "./host-uris";
+import { RpcFrameEncoder } from "./rpc-frame";
+import { claimRpcInput } from "./rpc-input";
 import { RpcSubagentRegistry, readRpcSubagentTranscript } from "./rpc-subagents";
 import type {
 	RpcCommand,
@@ -607,6 +609,7 @@ export async function runRpcMode(
 	session: AgentSession,
 	setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
 	eventBus?: EventBus,
+	input: ReadableStream<Uint8Array> = claimRpcInput(),
 ): Promise<never> {
 	// Signal to RPC clients that the server is ready to accept commands
 	// Suppress terminal notifications: they write \x07 (BEL) or OSC sequences directly to
@@ -615,9 +618,10 @@ export async function runRpcMode(
 	// may write there.
 	process.env.PI_NOTIFICATIONS = "off";
 
-	process.stdout.write(`${JSON.stringify({ type: "ready" })}\n`);
+	const frameEncoder = new RpcFrameEncoder();
+	process.stdout.write(frameEncoder.encode({ type: "ready" }));
 	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
-		process.stdout.write(`${JSON.stringify(obj)}\n`);
+		process.stdout.write(frameEncoder.encode(obj));
 	};
 	const emitRpcTitles = shouldEmitRpcTitles();
 
@@ -1327,7 +1331,10 @@ export async function runRpcMode(
 							return (await uiCtx.input(prompt.message, prompt.placeholder, { timeout: 600_000 })) ?? "";
 						},
 					});
-					await session.modelRegistry.refresh();
+					// Provider-scoped online refresh so the just-persisted credential
+					// re-runs discovery instead of reusing a fresh authoritative cache
+					// row (#5780).
+					await session.modelRegistry.refreshProvider(command.providerId, "online");
 					return success(id, "login", { providerId: command.providerId });
 				} catch (err: unknown) {
 					return error(id, "login", err instanceof Error ? err.message : String(err));
@@ -1381,7 +1388,7 @@ export async function runRpcMode(
 	// line is reported as an error frame and the loop keeps running instead of
 	// throwing out of the generator and killing the whole process (issue #5194).
 	const decoder = new TextDecoder();
-	for await (const line of readLines(Bun.stdin.stream())) {
+	for await (const line of readLines(input ?? Bun.stdin.stream())) {
 		const text = decoder.decode(line).trim();
 		if (!text) continue;
 		let parsed: unknown;

package/src/modes/setup-wizard/index.ts

@@ -2,6 +2,7 @@ import type { Settings } from "../../config/settings";
 import { CURRENT_SETUP_VERSION } from "../setup-version";
 import type { InteractiveModeContext } from "../types";
 import { glyphSetupScene } from "./scenes/glyph";
+import { modelSetupScene } from "./scenes/model";
 import { providersSetupScene } from "./scenes/providers";
 import { themeSetupScene } from "./scenes/theme";
 import type { SetupScene } from "./scenes/types";
@@ -14,6 +15,7 @@ export { CURRENT_SETUP_VERSION };
 
 export const ALL_SCENES = [
 	providersSetupScene,
+	modelSetupScene,
 	glyphSetupScene,
 	themeSetupScene,
 ] as const satisfies readonly SetupScene[];

package/src/modes/setup-wizard/scenes/model.ts

@@ -0,0 +1,134 @@
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { SgrMouseEvent } from "@oh-my-pi/pi-tui";
+import {
+	buildBrowserItems,
+	ModelBrowser,
+	resolveRoleAssignments,
+	sortModelItems,
+} from "../../components/model-browser";
+import { theme } from "../../theme/theme";
+import type { SetupScene, SetupSceneController, SetupSceneHost } from "./types";
+
+const MAX_VISIBLE_MODELS = 10;
+const WIZARD_SCREEN_RESERVE = 22;
+
+class ModelSceneController implements SetupSceneController {
+	title = "Choose your default model";
+	subtitle = "Search configured models and save the model used for new sessions.";
+	#browser: ModelBrowser;
+	#status: string | undefined;
+	#selecting = false;
+	#disposed = false;
+	#browserRowStart = 2;
+
+	constructor(private readonly host: SetupSceneHost) {
+		this.#browser = new ModelBrowser(host.ctx.settings);
+		this.#browser.onActivate = item => {
+			void this.#select(item.model, item.selector);
+		};
+		this.#browser.onCancel = () => host.finish("skipped");
+		this.#syncModels();
+	}
+
+	async onMount(): Promise<void> {
+		this.#status = theme.fg("muted", "Discovering available models…");
+		this.host.requestRender();
+		await this.#refreshModels();
+	}
+
+	dispose(): void {
+		this.#disposed = true;
+	}
+
+	invalidate(): void {
+		this.#browser.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (this.#selecting) return;
+		this.#browser.handleInput(data);
+	}
+
+	routeMouse(event: SgrMouseEvent, line: number): void {
+		if (this.#selecting) return;
+		this.#browser.routeMouse(event, line - this.#browserRowStart);
+	}
+
+	render(width: number): readonly string[] {
+		const visibleRows = Math.max(
+			1,
+			Math.min(MAX_VISIBLE_MODELS, this.host.ctx.ui.terminal.rows - WIZARD_SCREEN_RESERVE),
+		);
+		this.#browser.setMaxVisible(visibleRows);
+		const lines = [
+			this.#status ?? theme.fg("muted", "Type to search. Enter saves the highlighted model as your default."),
+			"",
+		];
+		this.#browserRowStart = lines.length;
+		lines.push(...this.#browser.render(width));
+		return lines;
+	}
+
+	#syncModels(): void {
+		const registry = this.host.ctx.session.modelRegistry;
+		const available = registry.getAvailable();
+		const roles = resolveRoleAssignments(this.host.ctx.settings, registry.getAll(), available);
+		const storage = this.host.ctx.settings.getStorage();
+		const items = buildBrowserItems(available);
+		sortModelItems(items, { roles, mruOrder: storage?.getModelUsageOrder() ?? [] });
+		this.#browser.setRoles(roles);
+		this.#browser.setMruOrder(storage?.getModelUsageOrder() ?? []);
+		this.#browser.setPerfStats(storage?.getModelPerf() ?? new Map());
+		this.#browser.setItems(items);
+
+		const current = this.host.ctx.session.model;
+		if (current) {
+			const selector = `${current.provider}/${current.id}`;
+			this.#browser.setCurrentSelector(selector);
+			this.#browser.selectSelector(selector);
+		}
+	}
+
+	async #refreshModels(): Promise<void> {
+		try {
+			await this.host.ctx.session.modelRegistry.refresh("online-if-uncached");
+			if (this.#disposed) return;
+			this.#syncModels();
+			this.#status = undefined;
+			this.host.requestRender();
+		} catch (error) {
+			if (this.#disposed) return;
+			this.#status = theme.fg("error", error instanceof Error ? error.message : String(error));
+			this.host.requestRender();
+		}
+	}
+
+	async #select(model: Model, selector: string): Promise<void> {
+		if (this.#selecting) return;
+		this.#selecting = true;
+		this.#status = theme.fg("muted", `Saving ${selector} as the default model…`);
+		this.host.requestRender();
+		try {
+			const projectScope = this.host.ctx.settings.get("modelRoleStorage") === "project";
+			await this.host.ctx.session.setModel(model, "default", { selector, persist: !projectScope });
+			if (projectScope) {
+				this.host.ctx.settings.setProjectModelRole("default", selector);
+			}
+			await this.host.ctx.settings.flush();
+			if (!this.#disposed) this.host.finish("done");
+		} catch (error) {
+			if (this.#disposed) return;
+			this.#selecting = false;
+			this.#status = theme.fg("error", error instanceof Error ? error.message : String(error));
+			this.host.requestRender();
+		}
+	}
+}
+
+/** Setup step that assigns one available model to the persisted default role. */
+export const modelSetupScene: SetupScene = {
+	id: "model",
+	title: "Choose your default model",
+	minVersion: 1,
+	mount: host => new ModelSceneController(host),
+};

package/src/modes/setup-wizard/scenes/sign-in.ts

@@ -224,7 +224,9 @@ export class SignInTab implements SetupTab {
 				onManualCodeInput: () =>
 					this.#showPrompt({ message: "Paste the authorization code (or full redirect URL):" }),
 			});
-			await this.host.ctx.session.modelRegistry.refresh();
+			// Provider-scoped online refresh so the just-persisted credential re-runs
+			// discovery instead of reusing a fresh authoritative cache row (#5780).
+			await this.host.ctx.session.modelRegistry.refreshProvider(providerId, "online");
 			if (this.#disposed) return;
 			this.#statusLines = [
 				theme.fg("success", `${theme.status.success} Signed in to ${providerId}`),

package/src/modes/types.ts

@@ -159,6 +159,7 @@ export interface InteractiveModeContext {
 	goalModeEnabled: boolean;
 	goalModePaused: boolean;
 	loopModeEnabled: boolean;
+	loopModePaused: boolean;
 	loopPrompt?: string;
 	loopLimit?: LoopLimitRuntime;
 	planModePlanFilePath?: string;
@@ -413,6 +414,7 @@ export interface InteractiveModeContext {
 	handleGoalModeCommand(rest?: string): Promise<void>;
 	handleGuidedGoalCommand(rest?: string): Promise<void>;
 	handleLoopCommand(args?: string): Promise<string | undefined>;
+	setLoopPrompt(prompt: string): void;
 	disableLoopMode(): void;
 	pauseLoop(): void;
 	handlePlanApproval(details: PlanApprovalDetails): Promise<void>;

package/src/modes/utils/ui-helpers.ts

@@ -301,14 +301,18 @@ export class UiHelpers {
 		let pendingUsage: Usage | undefined;
 		let pendingUsageDuration: number | undefined;
 		let pendingUsageTtft: number | undefined;
+		let pendingUsageTimestamp: number | undefined;
 		const flushPendingUsage = () => {
 			if (!pendingUsage) return;
 			readGroup?.seal();
 			readGroup = null;
-			this.ctx.chatContainer.addChild(createUsageRowBlock(pendingUsage, pendingUsageDuration, pendingUsageTtft));
+			this.ctx.chatContainer.addChild(
+				createUsageRowBlock(pendingUsage, pendingUsageDuration, pendingUsageTtft, pendingUsageTimestamp),
+			);
 			pendingUsage = undefined;
 			pendingUsageDuration = undefined;
 			pendingUsageTtft = undefined;
+			pendingUsageTimestamp = undefined;
 		};
 		// Rebuild-time mirror of the event controller's displaceable-poll
 		// bookkeeping: a `hub` wait that found every watched job still running is
@@ -509,6 +513,7 @@ export class UiHelpers {
 						: undefined;
 				pendingUsageDuration = message.duration;
 				pendingUsageTtft = message.ttft;
+				pendingUsageTimestamp = message.timestamp;
 			} else if (message.role === "toolResult") {
 				const pendingReadComponent = this.ctx.pendingTools.get(message.toolCallId);
 				const isReadGroupResult =
@@ -519,10 +524,10 @@ export class UiHelpers {
 					const images: ImageContent[] = message.content.filter(
 						(content): content is ImageContent => content.type === "image",
 					);
-					if (images.length > 0 && assistantComponent && settings.get("terminal.showImages")) {
+					if (images.length > 0 && assistantComponent) {
 						assistantComponent.setToolResultImages(message.toolCallId, images);
 						const hasText = message.content.some(c => c.type === "text");
-						if (!hasText) {
+						if (!hasText && settings.get("terminal.showImages")) {
 							readToolCallArgs.delete(message.toolCallId);
 							readToolCallAssistantComponents.delete(message.toolCallId);
 							continue;
@@ -746,6 +751,7 @@ export class UiHelpers {
 			const hintText = theme.fg("dim", `  ${theme.tree.hook} ${dequeueKey} to edit`);
 			this.ctx.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
 		}
+		this.ctx.ui.requestComponentRender(this.ctx.pendingMessagesContainer);
 	}
 
 	queueCompactionMessage(text: string, mode: "steer" | "followUp", images?: ImageContent[]): void {