@oh-my-pi/pi-coding-agent 14.8.1 → 14.9.1

package/src/index.ts

@@ -16,7 +16,6 @@ export type * from "./config/prompt-templates";
 export * from "./config/prompt-templates";
 export type { RetrySettings, SkillsSettings } from "./config/settings";
 export { Settings, settings } from "./config/settings";
-export * from "./edit/modes/hashline";
 // Custom commands
 export type * from "./extensibility/custom-commands/types";
 export type * from "./extensibility/custom-tools";
@@ -30,6 +29,7 @@ export * from "./extensibility/extensions";
 export * from "./extensibility/skills";
 // Slash commands
 export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./extensibility/slash-commands";
+export * from "./hashline";
 export type * from "./lsp";
 // Main entry point
 export * from "./main";

package/src/lsp/index.ts

@@ -1340,7 +1340,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				if (!detailed && targets.length === 1) {
 					if (uniqueDiagnostics.length === 0) {
 						return {
-							content: [{ type: "text", text: "No diagnostics" }],
+							content: [{ type: "text", text: "OK" }],
 							details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 						};
 					}

package/src/lsp/render.ts

@@ -163,6 +163,10 @@ export function renderResult(
 			} else if (symbolsMatch) {
 				label = "Symbols";
 				bodyLines = renderSymbols(symbolsMatch, lines, expanded, theme);
+			} else if (result.details?.action === "diagnostics" && text === "OK") {
+				label = "Diagnostics";
+				state = "success";
+				bodyLines = [`${theme.styledSymbol("status.success", "success")} ${theme.fg("dim", "OK")}`];
 			} else {
 				label = "Response";
 				bodyLines = renderGeneric(text, lines, expanded, theme);

package/src/memories/index.ts

@@ -236,7 +236,7 @@ async function runPhase1(options: {
 			logger.debug("Phase1 skipped: no model available");
 			return;
 		}
-		const phase1ApiKey = await modelRegistry.getApiKey(phase1Model, session.sessionManager.getSessionId());
+		const phase1ApiKey = await modelRegistry.getApiKey(phase1Model, session.sessionId);
 		if (!phase1ApiKey) {
 			logger.debug("Phase1 skipped: no API key for phase1 model", {
 				provider: phase1Model.provider,
@@ -274,6 +274,7 @@ async function runPhase1(options: {
 				apiKey: phase1ApiKey,
 				modelMaxTokens: computeModelTokenBudget(phase1Model, config),
 				config,
+				metadata: session.agent?.metadataForProvider(phase1Model.provider),
 			});
 
 			if (result.kind === "failed") {
@@ -397,7 +398,7 @@ async function runPhase2(options: {
 			});
 			return;
 		}
-		const phase2ApiKey = await modelRegistry.getApiKey(phase2Model, session.sessionManager.getSessionId());
+		const phase2ApiKey = await modelRegistry.getApiKey(phase2Model, session.sessionId);
 		if (!phase2ApiKey) {
 			markPhase2FailureWithFallback(db, {
 				claim,
@@ -428,6 +429,7 @@ async function runPhase2(options: {
 				memoryRoot,
 				model: phase2Model,
 				apiKey: phase2ApiKey,
+				metadata: session.agent?.metadataForProvider(phase2Model.provider),
 			});
 			await applyConsolidation(memoryRoot, consolidated);
 			if (heartbeatLostOwnership) {
@@ -575,6 +577,7 @@ async function runStage1Job(options: {
 	apiKey: string;
 	modelMaxTokens: number;
 	config: MemoryRuntimeConfig;
+	metadata?: Record<string, unknown>;
 }): Promise<
 	| {
 			kind: "output";
@@ -607,6 +610,7 @@ async function runStage1Job(options: {
 			},
 			{
 				apiKey,
+				metadata: options.metadata,
 				maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))),
 				reasoning: Effort.Low,
 			},
@@ -711,7 +715,12 @@ async function readRolloutSummaries(memoryRoot: string): Promise<string> {
 	return blocks.join("\n\n");
 }
 
-async function runConsolidationModel(options: { memoryRoot: string; model: Model; apiKey: string }): Promise<{
+async function runConsolidationModel(options: {
+	memoryRoot: string;
+	model: Model;
+	apiKey: string;
+	metadata?: Record<string, unknown>;
+}): Promise<{
 	memoryMd: string;
 	memorySummary: string;
 	skills: Array<{
@@ -735,7 +744,7 @@ async function runConsolidationModel(options: { memoryRoot: string; model: Model
 		{
 			messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
 		},
-		{ apiKey, maxTokens: 8192, reasoning: Effort.Medium },
+		{ apiKey, metadata: options.metadata, maxTokens: 8192, reasoning: Effort.Medium },
 	);
 	if (response.stopReason === "error") {
 		throw new Error(response.errorMessage || "phase2 model error");

package/src/modes/components/assistant-message.ts

@@ -4,6 +4,7 @@ import { formatNumber } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { resolveImageOptions } from "../../tools/render-utils";
+import { convertToPng } from "../../utils/image-convert";
 
 /**
  * Component that renders a complete assistant message
@@ -13,10 +14,13 @@ export class AssistantMessageComponent extends Container {
 	#lastMessage?: AssistantMessage;
 	#toolImagesByCallId = new Map<string, ImageContent[]>();
 	#usageInfo?: Usage;
+	#convertedKittyImages = new Map<string, ImageContent>();
+	#kittyConversionsInFlight = new Set<string>();
 
 	constructor(
 		message?: AssistantMessage,
 		private hideThinkingBlock = false,
+		private readonly onImageUpdate?: () => void,
 	) {
 		super();
 
@@ -43,16 +47,55 @@ export class AssistantMessageComponent extends Container {
 	setToolResultImages(toolCallId: string, images: ImageContent[]): void {
 		if (!toolCallId) return;
 		const validImages = images.filter(img => img.type === "image" && img.data && img.mimeType);
+		for (const key of Array.from(this.#convertedKittyImages.keys())) {
+			if (key.startsWith(`${toolCallId}:`)) {
+				this.#convertedKittyImages.delete(key);
+			}
+		}
+		for (const key of Array.from(this.#kittyConversionsInFlight)) {
+			if (key.startsWith(`${toolCallId}:`)) {
+				this.#kittyConversionsInFlight.delete(key);
+			}
+		}
 		if (validImages.length === 0) {
 			this.#toolImagesByCallId.delete(toolCallId);
 		} else {
 			this.#toolImagesByCallId.set(toolCallId, validImages);
+			this.#convertToolImagesForKitty(toolCallId, validImages);
 		}
 		if (this.#lastMessage) {
 			this.updateContent(this.#lastMessage);
 		}
 	}
 
+	#convertToolImagesForKitty(toolCallId: string, images: ImageContent[]): void {
+		if (TERMINAL.imageProtocol !== ImageProtocol.Kitty) return;
+		for (let index = 0; index < images.length; index++) {
+			const image = images[index];
+			if (!image || image.mimeType === "image/png") continue;
+			const key = `${toolCallId}:${index}`;
+			if (this.#convertedKittyImages.has(key) || this.#kittyConversionsInFlight.has(key)) continue;
+			this.#kittyConversionsInFlight.add(key);
+			convertToPng(image.data, image.mimeType)
+				.then(converted => {
+					this.#kittyConversionsInFlight.delete(key);
+					if (!converted) return;
+					this.#convertedKittyImages.set(key, {
+						type: "image",
+						data: converted.data,
+						mimeType: converted.mimeType,
+					});
+					if (this.#lastMessage) {
+						this.updateContent(this.#lastMessage);
+					}
+					this.onImageUpdate?.();
+				})
+				.catch(() => {
+					this.#kittyConversionsInFlight.delete(key);
+				});
+		}
+	}
+
 	setUsageInfo(usage: Usage): void {
 		this.#usageInfo = usage;
 		if (this.#lastMessage) {
@@ -61,19 +104,22 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	#renderToolImages(): void {
-		const images = Array.from(this.#toolImagesByCallId.values()).flat();
-		if (images.length === 0) return;
+		const imageEntries = Array.from(this.#toolImagesByCallId.entries()).flatMap(([toolCallId, images]) =>
+			images.map((image, index) => ({ image, key: `${toolCallId}:${index}` })),
+		);
+		if (imageEntries.length === 0) return;
 
 		this.#contentContainer.addChild(new Spacer(1));
-		for (const image of images) {
-			if (
-				TERMINAL.imageProtocol &&
-				(TERMINAL.imageProtocol !== ImageProtocol.Kitty || image.mimeType === "image/png")
-			) {
+		for (const { image, key } of imageEntries) {
+			const displayImage =
+				TERMINAL.imageProtocol === ImageProtocol.Kitty && image.mimeType !== "image/png"
+					? this.#convertedKittyImages.get(key)
+					: image;
+			if (TERMINAL.imageProtocol && displayImage) {
 				this.#contentContainer.addChild(
 					new Image(
-						image.data,
-						image.mimeType,
+						displayImage.data,
+						displayImage.mimeType,
 						{ fallbackColor: (text: string) => theme.fg("toolOutput", text) },
 						resolveImageOptions(),
 					),

package/src/modes/components/welcome.ts

@@ -1,4 +1,4 @@
-import { type Component, padding, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { type Component, padding, TERMINAL, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { APP_NAME } from "@oh-my-pi/pi-utils";
 import { theme } from "../../modes/theme/theme";
 
@@ -17,6 +17,9 @@ export interface LspServerInfo {
  * Premium welcome screen with block-based OMP logo and two-column layout.
  */
 export class WelcomeComponent implements Component {
+	#animStart: number | null = null;
+	#animTimer: ReturnType<typeof setInterval> | null = null;
+
 	constructor(
 		private readonly version: string,
 		private modelName: string,
@@ -27,6 +30,32 @@ export class WelcomeComponent implements Component {
 
 	invalidate(): void {}
 
+	/**
+	 * Play a one-shot intro that sweeps the gradient through every phase
+	 * before settling on the resting frame. Safe to call multiple times —
+	 * subsequent calls reset and replay.
+	 */
+	playIntro(requestRender: () => void): void {
+		this.#stopAnimation();
+		this.#animStart = performance.now();
+		requestRender();
+		this.#animTimer = setInterval(() => {
+			const elapsed = performance.now() - (this.#animStart ?? 0);
+			if (elapsed >= INTRO_MS) {
+				this.#stopAnimation();
+			}
+			requestRender();
+		}, INTRO_MS / INTRO_PHASES);
+	}
+
+	#stopAnimation(): void {
+		if (this.#animTimer != null) {
+			clearInterval(this.#animTimer);
+			this.#animTimer = null;
+		}
+		this.#animStart = null;
+	}
+
 	setModel(modelName: string, providerName: string): void {
 		this.modelName = modelName;
 		this.providerName = providerName;
@@ -49,7 +78,7 @@ export class WelcomeComponent implements Component {
 		}
 		const dualContentWidth = boxWidth - 3; // 3 = │ + │ + │
 		const preferredLeftCol = 26;
-		const minLeftCol = 14; // logo width
+		const minLeftCol = 12; // logo width
 		const minRightCol = 20;
 		const leftMinContentWidth = Math.max(
 			minLeftCol,
@@ -67,12 +96,8 @@ export class WelcomeComponent implements Component {
 		const leftCol = showRightColumn ? dualLeftCol : boxWidth - 2;
 		const rightCol = showRightColumn ? dualRightCol : 0;
 
-		// Block-based OMP logo (gradient: magenta → cyan)
-		// biome-ignore format: preserve ASCII art layout
-		const piLogo = ["▀████████████▀", " ╘███    ███  ", "  ███    ███  ", "  ███    ███  ", " ▄███▄  ▄███▄ "];
-
-		// Apply gradient to logo
-		const logoColored = piLogo.map(line => this.#gradientLine(line));
+		// Logo: pick a frame from the intro animation if active, else the resting frame.
+		const logoColored = this.#currentLogoFrame();
 
 		// Left column - centered content
 		const leftLines = [
@@ -201,36 +226,6 @@ export class WelcomeComponent implements Component {
 		return padding(leftPad) + text + padding(rightPad);
 	}
 
-	/** Apply magenta→cyan gradient to a string */
-	#gradientLine(line: string): string {
-		const colors = [
-			"\x1b[38;5;199m", // bright magenta
-			"\x1b[38;5;171m", // magenta-purple
-			"\x1b[38;5;135m", // purple
-			"\x1b[38;5;99m", // purple-blue
-			"\x1b[38;5;75m", // cyan-blue
-			"\x1b[38;5;51m", // bright cyan
-		];
-		const reset = "\x1b[0m";
-
-		let result = "";
-		let colorIdx = 0;
-		const step = Math.max(1, Math.floor(line.length / colors.length));
-
-		for (let i = 0; i < line.length; i++) {
-			if (i > 0 && i % step === 0 && colorIdx < colors.length - 1) {
-				colorIdx++;
-			}
-			const char = line[i];
-			if (char !== " ") {
-				result += colors[colorIdx] + char + reset;
-			} else {
-				result += char;
-			}
-		}
-		return result;
-	}
-
 	/** Fit string to exact width with ANSI-aware truncation/padding */
 	#fitToWidth(str: string, width: number): string {
 		const visLen = visibleWidth(str);
@@ -255,4 +250,85 @@ export class WelcomeComponent implements Component {
 		}
 		return str + padding(width - visLen);
 	}
+
+	/** Pick the logo frame for the current intro phase, or the resting frame. */
+	#currentLogoFrame(): readonly string[] {
+		if (this.#animStart == null) return LOGO_FRAMES[0];
+		const elapsed = performance.now() - this.#animStart;
+		if (elapsed >= INTRO_MS) return LOGO_FRAMES[0];
+		// Ease-out cubic so the sweep settles into the resting frame instead of
+		// stopping abruptly. Sweeps backward through the phase ring → lands on 0.
+		const progress = elapsed / INTRO_MS;
+		const eased = 1 - (1 - progress) ** 3;
+		const stepsDone = Math.min(INTRO_PHASES - 1, Math.floor(eased * INTRO_PHASES));
+		const idx = (INTRO_PHASES - stepsDone) % INTRO_PHASES;
+		return LOGO_FRAMES[idx];
+	}
+}
+
+// biome-ignore format: preserve ASCII art layout
+const PI_LOGO = ["▀██████████▀", " ╘██    ██  ", "  ██    ██  ", "  ██    ██  ", " ▄██▄  ▄██▄ "];
+
+/**
+ * Apply magenta→cyan diagonal gradient (bottom-left → top-right) across multi-line art.
+ * `phase` (0..1) shifts the gradient along the diagonal, wrapping at 1.
+ */
+function gradientLogo(lines: readonly string[], phase = 0): string[] {
+	const reset = "\x1b[0m";
+	const rows = lines.length;
+	const cols = Math.max(...lines.map(l => l.length));
+	// span+1 so `base` stays strictly < 1: avoids the wrap-around at the
+	// far corner mapping back to t=0 (magenta) on the resting frame.
+	const span = Math.max(1, cols + rows - 1);
+	const colorAt = TERMINAL.trueColor
+		? (t: number): string => {
+				// Multi-stop gradient: hot magenta → light violet → bright cyan.
+				// Picked stops avoid the deep-blue valley a naive HSL lerp falls into.
+				const stops: [number, number, number][] = [
+					[255, 62, 201], // hot magenta-pink
+					[180, 120, 255], // light violet
+					[62, 230, 255], // bright cyan
+				];
+				const seg = t * (stops.length - 1);
+				const i = Math.min(stops.length - 2, Math.floor(seg));
+				const f = seg - i;
+				const a = stops[i];
+				const b = stops[i + 1];
+				const r = Math.round(a[0] + (b[0] - a[0]) * f);
+				const g = Math.round(a[1] + (b[1] - a[1]) * f);
+				const bl = Math.round(a[2] + (b[2] - a[2]) * f);
+				return `\x1b[38;2;${r};${g};${bl}m`;
+			}
+		: (t: number): string => {
+				const ramp = [199, 171, 135, 99, 75, 51];
+				const idx = Math.min(ramp.length - 1, Math.max(0, Math.floor(t * (ramp.length - 1) + 0.5)));
+				return `\x1b[38;5;${ramp[idx]}m`;
+			};
+	return lines.map((line, y) => {
+		let result = "";
+		for (let x = 0; x < line.length; x++) {
+			const char = line[x];
+			if (char === " ") {
+				result += char;
+				continue;
+			}
+			// Diagonal: bottom-left (x=0, y=rows-1) → top-right (x=cols-1, y=0)
+			const base = (x + (rows - 1 - y)) / span;
+			const t = (((base + phase) % 1) + 1) % 1;
+			result += colorAt(t) + char + reset;
+		}
+		return result;
+	});
 }
+
+/** Intro animation: how many discrete gradient phases and total duration. */
+const INTRO_PHASES = 60;
+const INTRO_MS = 2000;
+
+/**
+ * Pre-rendered logo frames, one per phase. Frame 0 is the resting state;
+ * the intro sweeps frames in reverse so it lands on frame 0.
+ */
+const LOGO_FRAMES: readonly (readonly string[])[] = Array.from({ length: INTRO_PHASES }, (_, i) =>
+	gradientLogo(PI_LOGO, i / INTRO_PHASES),
+);

package/src/modes/controllers/event-controller.ts

@@ -205,7 +205,9 @@ export class EventController {
 		} else if (event.message.role === "assistant") {
 			this.#lastThinkingCount = 0;
 			this.#resetReadGroup();
-			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock);
+			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock, () =>
+				this.ctx.ui.requestRender(),
+			);
 			this.ctx.streamingMessage = event.message;
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
 			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);

package/src/modes/controllers/input-controller.ts

@@ -362,7 +362,14 @@ export class InputController {
 			const hasUserMessages = this.ctx.session.messages.some((m: AgentMessage) => m.role === "user");
 			if (!hasUserMessages && !this.ctx.sessionManager.getSessionName() && !$env.PI_NO_TITLE) {
 				const registry = this.ctx.session.modelRegistry;
-				generateSessionTitle(text, registry, this.ctx.settings, this.ctx.session.sessionId, this.ctx.session.model)
+				generateSessionTitle(
+					text,
+					registry,
+					this.ctx.settings,
+					this.ctx.session.sessionId,
+					this.ctx.session.model,
+					provider => this.ctx.session.agent.metadataForProvider(provider),
+				)
 					.then(async title => {
 						if (title) {
 							const applied = await this.ctx.sessionManager.setSessionName(title, "auto");

package/src/modes/interactive-mode.ts

@@ -394,6 +394,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.ui.addChild(new Spacer(1));
 			this.ui.addChild(this.#welcomeComponent);
 			this.ui.addChild(new Spacer(1));
+			this.#welcomeComponent.playIntro(() => this.ui.requestRender());
 
 			// Add changelog if provided
 			if (this.#changelogMarkdown) {
@@ -1011,13 +1012,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 	}
 
-	#renderPlanPreview(planContent: string): void {
-		const planReviewContainer = this.#planReviewContainer ?? new Container();
-		if (this.#planReviewContainer) {
-			// Re-append the preview so repeated plan-review refreshes stay adjacent to the
-			// active selector instead of updating an older off-screen preview in place.
-			this.chatContainer.removeChild(this.#planReviewContainer);
-		}
+	#renderPlanPreview(planContent: string, options?: { append?: boolean }): void {
+		const existingContainer = this.#planReviewContainer;
+		const replaceExisting = options?.append !== true && existingContainer !== undefined;
+		const planReviewContainer = replaceExisting ? existingContainer : new Container();
 		planReviewContainer.clear();
 		planReviewContainer.addChild(new Spacer(1));
 		planReviewContainer.addChild(new DynamicBorder());
@@ -1025,7 +1023,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		planReviewContainer.addChild(new Spacer(1));
 		planReviewContainer.addChild(new Markdown(planContent, 1, 1, getMarkdownTheme()));
 		planReviewContainer.addChild(new DynamicBorder());
-		this.chatContainer.addChild(planReviewContainer);
+		if (!replaceExisting) {
+			this.chatContainer.addChild(planReviewContainer);
+		}
 		this.#planReviewContainer = planReviewContainer;
 		this.ui.requestRender();
 	}
@@ -1182,7 +1182,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		}
 
-		this.#renderPlanPreview(planContent);
+		this.#renderPlanPreview(planContent, { append: true });
 		const choice = await this.showHookSelector(
 			"Plan mode - next step",
 			["Approve and execute", "Approve and keep context", "Refine plan", "Stay in plan mode"],

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

@@ -11,6 +11,7 @@ import type { SessionStats } from "../../session/agent-session";
 import type { CompactionResult } from "../../session/compaction";
 import type {
 	RpcCommand,
+	RpcExtensionUIRequest,
 	RpcHandoffResult,
 	RpcHostToolCallRequest,
 	RpcHostToolCancelRequest,
@@ -124,6 +125,11 @@ function isRpcHostToolCancelRequest(value: unknown): value is RpcHostToolCancelR
 	return value.type === "host_tool_cancel" && typeof value.id === "string" && typeof value.targetId === "string";
 }
 
+function isRpcExtensionUiRequest(value: unknown): value is RpcExtensionUIRequest {
+	if (!isRecord(value)) return false;
+	return value.type === "extension_ui_request" && typeof value.id === "string" && typeof value.method === "string";
+}
+
 function normalizeToolResult<TDetails>(result: RpcClientToolResult<TDetails>): AgentToolResult<TDetails> {
 	if (typeof result === "string") {
 		return {
@@ -145,6 +151,7 @@ export class RpcClient {
 	#customTools: RpcClientCustomTool[] = [];
 	#pendingHostToolCalls = new Map<string, { controller: AbortController }>();
 	#requestId = 0;
+	#extensionUiListeners: Set<(req: RpcExtensionUIRequest) => void> = new Set();
 	#abortController = new AbortController();
 
 	constructor(private options: RpcClientOptions = {}) {
@@ -516,6 +523,43 @@ export class RpcClient {
 		return this.#getData<{ messages: AgentMessage[] }>(response).messages;
 	}
 
+	/**
+	 * Get list of OAuth providers available for login, with their current authentication status.
+	 */
+	async getLoginProviders(): Promise<Array<{ id: string; name: string; available: boolean; authenticated: boolean }>> {
+		const response = await this.#send({ type: "get_login_providers" });
+		return this.#getData<{
+			providers: Array<{ id: string; name: string; available: boolean; authenticated: boolean }>;
+		}>(response).providers;
+	}
+
+	/**
+	 * Trigger OAuth login for the given provider.
+	 * The server will emit an `open_url` extension_ui_request for the auth URL.
+	 * Resolves when login completes or rejects on failure.
+	 *
+	 * @param onOpenUrl Called when the server emits the auth URL. The host must open
+	 *   it in a browser for the callback-server OAuth flow to complete.
+	 */
+	async login(
+		providerId: string,
+		options?: { onOpenUrl?: (url: string, instructions?: string) => void },
+	): Promise<{ providerId: string }> {
+		const { onOpenUrl } = options ?? {};
+		const listener = onOpenUrl
+			? (req: RpcExtensionUIRequest) => {
+					if (req.method === "open_url") onOpenUrl(req.url, req.instructions);
+				}
+			: undefined;
+		if (listener) this.#extensionUiListeners.add(listener);
+		try {
+			const response = await this.#send({ type: "login", providerId }, 600_000);
+			return this.#getData<{ providerId: string }>(response);
+		} finally {
+			if (listener) this.#extensionUiListeners.delete(listener);
+		}
+	}
+
 	/**
 	 * Replace the host-owned custom tools exposed to the RPC session.
 	 * Changes take effect before the next model call.
@@ -621,6 +665,13 @@ export class RpcClient {
 			return;
 		}
 
+		if (isRpcExtensionUiRequest(data)) {
+			for (const listener of this.#extensionUiListeners) {
+				listener(data);
+			}
+			return;
+		}
+
 		if (isRpcHostToolCancelRequest(data)) {
 			this.#pendingHostToolCalls.get(data.targetId)?.controller.abort();
 			return;
@@ -634,7 +685,7 @@ export class RpcClient {
 		}
 	}
 
-	#send(command: RpcCommandBody): Promise<RpcResponse> {
+	#send(command: RpcCommandBody, timeoutMs = 30_000): Promise<RpcResponse> {
 		if (!this.#process?.stdin) {
 			throw new Error("Client not started");
 		}
@@ -643,7 +694,7 @@ export class RpcClient {
 		const fullCommand = { ...command, id } as RpcCommand;
 		const { promise, resolve, reject } = Promise.withResolvers<RpcResponse>();
 		let settled = false;
-		const timeoutId = this.#startTimeout(30000, () => {
+		const timeoutId = this.#startTimeout(timeoutMs, () => {
 			if (settled) return;
 			this.#pendingRequests.delete(id);
 			settled = true;

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

@@ -10,6 +10,7 @@
  * - Events: AgentSessionEvent objects streamed as they occur
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
+import { getOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import { $env, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
 import type {
 	ExtensionUIContext,
@@ -149,7 +150,6 @@ export function requestRpcEditor(
 	} as RpcExtensionUIRequest);
 	return promise;
 }
-
 /**
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
@@ -755,6 +755,72 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				return success(id, "get_messages", { messages: session.messages });
 			}
 
+			// =================================================================
+			// Login
+			// =================================================================
+
+			case "get_login_providers": {
+				const providers = getOAuthProviders().map(provider => ({
+					id: provider.id,
+					name: provider.name,
+					available: provider.available,
+					authenticated: session.modelRegistry.authStorage.hasAuth(provider.id),
+				}));
+				return success(id, "get_login_providers", { providers });
+			}
+
+			case "login": {
+				const knownProvider = getOAuthProviders().find(p => p.id === command.providerId);
+				if (!knownProvider) {
+					return error(id, "login", `Unknown OAuth provider: ${command.providerId}`);
+				}
+				const uiCtx = new RpcExtensionUIContext(pendingExtensionRequests, output);
+				// Track whether onAuth has fired. Providers that use OAuthCallbackFlow
+				// always call onAuth first (emit browser URL), then onManualCodeInput as
+				// a fallback. Providers that require interactive input (API-key paste,
+				// GitHub Enterprise URL, device-code entry) call onPrompt before onAuth.
+				// We use this ordering to self-classify at runtime — no static allowlist.
+				let authEmitted = false;
+				try {
+					await session.modelRegistry.authStorage.login(command.providerId, {
+						onAuth: info => {
+							authEmitted = true;
+							output({
+								type: "extension_ui_request",
+								id: Snowflake.next() as string,
+								method: "open_url",
+								url: info.url,
+								instructions: info.instructions,
+							} as RpcExtensionUIRequest);
+						},
+						onProgress: message => {
+							uiCtx.notify(message, "info");
+						},
+						onPrompt: () => {
+							if (!authEmitted) {
+								// onPrompt called before any auth URL — provider requires
+								// interactive input that cannot be satisfied headlessly.
+								return Promise.reject(
+									new Error(
+										`Provider '${command.providerId}' requires interactive prompts ` +
+											"which are not supported in RPC mode. Use the terminal UI to log in.",
+									),
+								);
+							}
+							// onAuth has already fired — we are inside OAuthCallbackFlow's
+							// manual-redirect fallback race. Returning a never-settling promise
+							// lets the race block until the callback server wins; a rejection
+							// would be caught as null and spin the while(true) loop.
+							return new Promise<string>(() => {});
+						},
+					});
+					await session.modelRegistry.refresh();
+					return success(id, "login", { providerId: command.providerId });
+				} catch (err: unknown) {
+					return error(id, "login", err instanceof Error ? err.message : String(err));
+				}
+			}
+
 			default: {
 				const unknownCommand = command as { type: string };
 				return error(undefined, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);