@oh-my-pi/pi-coding-agent 16.2.12 → 16.3.0

package/src/collab/host.ts

@@ -13,7 +13,14 @@ import { timingSafeEqual } from "node:crypto";
 import * as fs from "node:fs/promises";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
-import type { BusChannel, AgentEvent as WireAgentEvent, SessionEntry as WireSessionEntry } from "@oh-my-pi/pi-wire";
+import type {
+	BusChannel,
+	CollabUiRequest,
+	CollabUiRequestDraft,
+	CollabUiResponseValue,
+	AgentEvent as WireAgentEvent,
+	SessionEntry as WireSessionEntry,
+} from "@oh-my-pi/pi-wire";
 import type { InteractiveModeContext } from "../modes/types";
 import { AgentLifecycleManager } from "../registry/agent-lifecycle";
 import { type AgentRef, AgentRegistry } from "../registry/agent-registry";
@@ -94,7 +101,8 @@ function isWireSessionEntry(entry: StoredSessionEntry): entry is StoredSessionEn
 }
 const CONNECT_TIMEOUT_MS = 15_000;
 /** Max bytes served per fetch-transcript reply (guest re-requests from `newSize`). */
-const TRANSCRIPT_READ_CAP = 4 * 1024 * 1024;
+export const TRANSCRIPT_READ_CAP = 4 * 1024 * 1024;
+const TRANSCRIPT_ENTRY_TOO_LARGE_ERROR = `transcript entry exceeds transcript fetch cap (${TRANSCRIPT_READ_CAP} bytes)`;
 /**
  * Soft byte cap per `snapshot-chunk` frame. The first MB of a snapshot takes
  * ~3s through the default relay, so a 512 KB chunk lands well under the
@@ -102,6 +110,13 @@ const TRANSCRIPT_READ_CAP = 4 * 1024 * 1024;
  * ship in a chunk of their own.
  */
 const SNAPSHOT_CHUNK_BYTES = 512 * 1024;
+/**
+ * Outcome of {@link CollabHost.requestGuestUi}. `answered` carries the guest's
+ * response (an `undefined` value is a genuine guest cancel); `unavailable`
+ * means the collab channel went away (teardown, relay drop) or the request was
+ * aborted before any guest answered — callers MUST NOT treat it as a cancel.
+ */
+export type CollabGuestUiResult = { kind: "answered"; value: CollabUiResponseValue } | { kind: "unavailable" };
 
 export class CollabHost {
 	#ctx: InteractiveModeContext;
@@ -114,6 +129,8 @@ export class CollabHost {
 	#sessionId = "";
 	#unsubscribe?: () => void;
 	#peers = new Map<number, { name: string; canWrite: boolean }>();
+	#uiReqSeq = 0;
+	#pendingUi = new Map<number, { request: CollabUiRequest; settle(result: CollabGuestUiResult): void }>();
 	#lastStateJson = "";
 	#stateDebounce: Timer | null = null;
 	#streamingInterval: Timer | null = null;
@@ -153,6 +170,43 @@ export class CollabHost {
 		return list;
 	}
 
+	requestGuestUi(request: CollabUiRequestDraft, signal?: AbortSignal): Promise<CollabGuestUiResult> | null {
+		if (!this.#socket || !this.#hasWritablePeers()) return null;
+		const reqId = ++this.#uiReqSeq;
+		const fullRequest: CollabUiRequest = { ...request, reqId };
+		const { promise, resolve } = Promise.withResolvers<CollabGuestUiResult>();
+		let settled = false;
+		const settle = (result: CollabGuestUiResult): void => {
+			if (settled) return;
+			settled = true;
+			signal?.removeEventListener("abort", onAbort);
+			this.#pendingUi.delete(reqId);
+			this.#sendWritablePeers({ t: "ui-request-end", reqId });
+			resolve(result);
+		};
+		const onAbort = (): void => settle({ kind: "unavailable" });
+		if (signal?.aborted) return Promise.resolve({ kind: "unavailable" });
+		signal?.addEventListener("abort", onAbort, { once: true });
+		this.#pendingUi.set(reqId, { request: fullRequest, settle });
+		this.#sendWritablePeers({ t: "ui-request", request: fullRequest });
+		return promise;
+	}
+
+	#hasWritablePeers(): boolean {
+		for (const peer of this.#peers.values()) {
+			if (peer.canWrite) return true;
+		}
+		return false;
+	}
+
+	#sendWritablePeers(frame: CollabFrame): void {
+		const socket = this.#socket;
+		if (!socket) return;
+		for (const [peerId, peer] of this.#peers) {
+			if (peer.canWrite) socket.send(frame, peerId);
+		}
+	}
+
 	async start(relayUrl: string, webUrl = ""): Promise<void> {
 		const rawKey = generateRoomKey();
 		const writeToken = generateWriteToken();
@@ -255,6 +309,8 @@ export class CollabHost {
 		this.#agentsDebounce = null;
 		clearInterval(this.#streamingInterval ?? undefined);
 		this.#streamingInterval = null;
+		for (const pending of this.#pendingUi.values()) pending.settle({ kind: "unavailable" });
+		this.#pendingUi.clear();
 		this.#peers.clear();
 		this.#socket?.close();
 		this.#socket = null;
@@ -287,6 +343,9 @@ export class CollabHost {
 			case "agent-cmd":
 				this.#handleAgentCmd(frame.cmd, frame.agentId, frame.text, fromPeer);
 				break;
+			case "ui-response":
+				this.#handleUiResponse(frame.reqId, frame.value, fromPeer);
+				break;
 			case "fetch-transcript":
 				void this.#handleFetchTranscript(frame.reqId, frame.agentId, frame.fromByte, fromPeer);
 				break;
@@ -348,6 +407,11 @@ export class CollabHost {
 			fromPeer,
 		);
 		this.#sendSnapshotChunks(entries, fromPeer);
+		if (canWrite) {
+			for (const pending of this.#pendingUi.values()) {
+				socket.send({ t: "ui-request", request: pending.request }, fromPeer);
+			}
+		}
 		this.#ctx.session.emitNotice(
 			"info",
 			`${cleanName} joined the collab session${canWrite ? "" : " (read-only)"}`,
@@ -392,6 +456,15 @@ export class CollabHost {
 		}
 	}
 
+	#handleUiResponse(reqId: number, value: CollabUiResponseValue, fromPeer: number): void {
+		const peer = this.#peers.get(fromPeer);
+		if (!peer?.canWrite) {
+			this.#rejectReadOnly("responding to ask", fromPeer);
+			return;
+		}
+		this.#pendingUi.get(reqId)?.settle({ kind: "answered", value });
+	}
+
 	#handlePrompt(text: string, images: ImageContent[] | undefined, fromPeer: number): void {
 		const peer = this.#peers.get(fromPeer);
 		if (!peer?.canWrite) {
@@ -584,7 +657,11 @@ export class CollabHost {
 			if (!reachedEof) {
 				// Trim to the last complete JSONL line so no line or UTF-8 char is split.
 				const lastNewline = slice.lastIndexOf(0x0a);
-				slice = slice.subarray(0, lastNewline >= 0 ? lastNewline + 1 : 0);
+				if (lastNewline < 0) {
+					reply("", fromByte, TRANSCRIPT_ENTRY_TOO_LARGE_ERROR);
+					return;
+				}
+				slice = slice.subarray(0, lastNewline + 1);
 			}
 			reply(slice.toString("utf-8"), reachedEof ? stat.size : fromByte + slice.byteLength);
 		} catch (err) {

package/src/collab/protocol.ts

@@ -10,6 +10,7 @@
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type {
 	BusChannel,
+	CollabUiRequest,
 	GuestFrame,
 	ParsedCollabLink,
 	Participant,
@@ -29,6 +30,10 @@ import type { SessionEntry, SessionHeader } from "../session/session-entries";
 
 export type {
 	CollabPromptDetails,
+	CollabUiRequest,
+	CollabUiRequestDraft,
+	CollabUiResponseValue,
+	CollabUiSelectItem,
 	ParsedCollabLink,
 	RelayControlMessage,
 	RelayControlToGuest,
@@ -57,7 +62,7 @@ export type CollabSessionState = SessionState & {
  * that serialize into those shapes.
  */
 export type CollabFrame =
-	// guest -> host (hello/abort/agent-cmd/fetch-transcript are taken verbatim from the wire grammar)
+	// guest -> host (hello/abort/agent-cmd/fetch-transcript/ui-response are taken verbatim from the wire grammar)
 	| Exclude<GuestFrame, { t: "prompt" }>
 	| { t: "prompt"; text: string; images?: ImageContent[] }
 	// host -> guest
@@ -93,7 +98,9 @@ export type CollabFrame =
 	| { t: "bus"; channel: BusChannel; data: unknown }
 	/** Full agent-registry snapshot (debounced on registry change). */
 	| { t: "agents"; agents: AgentSnapshot[] }
-	/** Targeted reply to fetch-transcript; `text` is decoded JSONL from `fromByte`, `newSize` the next offset base. */
+	| { t: "ui-request"; request: CollabUiRequest }
+	| { t: "ui-request-end"; reqId: number }
+	/** Targeted reply to fetch-transcript; `error` marks a terminal read failure that guests must surface without hot retrying. */
 	| { t: "transcript"; reqId: number; text: string; newSize: number; error?: string }
 	| { t: "bye"; reason: string }
 	| { t: "error"; message: string };

package/src/commit/model-selection.ts

@@ -11,6 +11,7 @@ import {
 import { MODEL_ROLE_IDS } from "../config/model-roles";
 import type { Settings } from "../config/settings";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
+import { concreteThinkingLevel } from "../thinking";
 
 export interface ResolvedCommitModel {
 	model: Model<Api>;
@@ -20,6 +21,11 @@ export interface ResolvedCommitModel {
 	 * central force-refresh + account-rotation policy.
 	 */
 	apiKey: ApiKey;
+	/**
+	 * Commit-time inference is stateless: session-level auto classification
+	 * isn't available, so an explicit `:auto` selector collapses to "no
+	 * override" and the model's own default level fills in.
+	 */
 	thinkingLevel?: ThinkingLevel;
 }
 
@@ -49,7 +55,7 @@ export async function resolvePrimaryModel(
 	return {
 		model,
 		apiKey: modelRegistry.resolver(model),
-		thinkingLevel: resolved?.thinkingLevel,
+		thinkingLevel: concreteThinkingLevel(resolved?.thinkingLevel),
 	};
 }
 
@@ -67,7 +73,7 @@ export async function resolveSmolModel(
 			return {
 				model: resolvedSmol.model,
 				apiKey: modelRegistry.resolver(resolvedSmol.model),
-				thinkingLevel: resolvedSmol.thinkingLevel,
+				thinkingLevel: concreteThinkingLevel(resolvedSmol.thinkingLevel),
 			};
 		}
 	}

package/src/config/keybindings.ts

@@ -65,7 +65,9 @@ declare module "@oh-my-pi/pi-tui" {
  * Resolve default image-paste shortcuts for the current terminal platform.
  */
 export function getDefaultPasteImageKeys(platform: NodeJS.Platform = process.platform): KeyId[] {
-	return platform === "win32" ? ["ctrl+v", "alt+v"] : ["ctrl+v"];
+	if (platform === "win32") return ["ctrl+v", "alt+v"];
+	if (platform === "darwin") return ["ctrl+v", "super+v"];
+	return ["ctrl+v"];
 }
 
 /**

package/src/config/model-discovery.ts

@@ -158,6 +158,15 @@ type LlamaCppDiscoveredModelRuntimeMetadata = {
 type LlamaCppModelListEntry = {
 	id: string;
 	runtimeContextWindow?: number;
+	/**
+	 * `--ctx-size` extracted from the entry's `status.args` (rendered CLI arg
+	 * vector) or `status.preset` INI. Populated for llama-server router-mode
+	 * presets so unloaded models surface the user's configured window instead
+	 * of falling through to the 128K default — the router-level `/props`
+	 * reports a dummy `n_ctx: 0` and `meta.n_ctx` is only merged in after a
+	 * child instance loads (issue #4190).
+	 */
+	configuredContextWindow?: number;
 	trainingContextWindow?: number;
 };
 
@@ -274,10 +283,60 @@ function parseLlamaCppModelList(payload: unknown): LlamaCppModelListEntry[] {
 		if (!isRecord(item) || typeof item.id !== "string" || !item.id) {
 			return [];
 		}
-		return [{ id: item.id, ...extractLlamaCppModelContextWindows(item) }];
+		return [
+			{
+				id: item.id,
+				...extractLlamaCppModelContextWindows(item),
+				configuredContextWindow: extractLlamaCppConfiguredContextWindow(item),
+			},
+		];
 	});
 }
 
+// llama-server's `to_args()` renders the long form `--ctx-size` (never `-c`),
+// but tolerate the short form and the embedded `--flag=value` shape so a
+// hand-rolled forwarder cannot silently downgrade the discovered window.
+const LLAMA_CPP_CTX_SIZE_FLAGS = new Set(["--ctx-size", "-c"]);
+
+function extractLlamaCppCtxSizeFromArgs(value: unknown): number | undefined {
+	if (!Array.isArray(value)) {
+		return undefined;
+	}
+	for (let i = 0; i < value.length; i++) {
+		const raw = value[i];
+		if (typeof raw !== "string") continue;
+		const eq = raw.indexOf("=");
+		const flag = eq >= 0 ? raw.slice(0, eq) : raw;
+		if (!LLAMA_CPP_CTX_SIZE_FLAGS.has(flag)) continue;
+		const rawValue = eq >= 0 ? raw.slice(eq + 1) : value[i + 1];
+		const parsed = toPositiveNumberOrUndefined(rawValue);
+		if (parsed !== undefined) return parsed;
+	}
+	return undefined;
+}
+
+// `common_preset::to_ini()` emits one option per line as `<long-arg-without-dashes> = <value>`,
+// so `ctx-size = 8192` is the exact wire form (issue #4190).
+function extractLlamaCppCtxSizeFromIni(value: unknown): number | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const match = value.match(/(?:^|\n)\s*ctx-size\s*=\s*(-?\d+)\s*(?:$|\n)/);
+	return match ? toPositiveNumberOrUndefined(match[1]) : undefined;
+}
+
+function extractLlamaCppConfiguredContextWindow(item: Record<string, unknown>): number | undefined {
+	const status = item.status;
+	if (!isRecord(status)) {
+		return undefined;
+	}
+	const fromArgs = extractLlamaCppCtxSizeFromArgs(status.args);
+	if (fromArgs !== undefined) {
+		return fromArgs;
+	}
+	return extractLlamaCppCtxSizeFromIni(status.preset);
+}
+
 function extractLlamaCppInputCapabilities(payload: Record<string, unknown>): ("text" | "image")[] | undefined {
 	const modalities = payload.modalities;
 	if (!isRecord(modalities)) {
@@ -473,6 +532,7 @@ export async function discoverLlamaCppModels(
 		if (!id) continue;
 		const contextWindow =
 			item.runtimeContextWindow ??
+			item.configuredContextWindow ??
 			serverMetadata?.contextWindow ??
 			item.trainingContextWindow ??
 			DISCOVERY_DEFAULT_CONTEXT_WINDOW;
@@ -529,7 +589,11 @@ export async function discoverLlamaCppModelRuntimeMetadata(
 		if (!entry) {
 			return undefined;
 		}
-		const contextWindow = entry.runtimeContextWindow ?? serverMetadata?.contextWindow ?? entry.trainingContextWindow;
+		const contextWindow =
+			entry.runtimeContextWindow ??
+			entry.configuredContextWindow ??
+			serverMetadata?.contextWindow ??
+			entry.trainingContextWindow;
 		if (contextWindow === undefined) {
 			return undefined;
 		}

package/src/config/model-registry.ts

@@ -52,7 +52,7 @@ import type { ApiKeyResolver, FetchImpl } from "@oh-my-pi/pi-ai";
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import { getBundledModelReferenceIndex, resolveModelReference } from "@oh-my-pi/pi-catalog/identity";
-import { isBunTestRuntime, isRecord, logger } from "@oh-my-pi/pi-utils";
+import { isBunTestRuntime, isRecord, logger, wrapFetchForExtraCa } from "@oh-my-pi/pi-utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
 import { type ApiKeyResolverModel, type ApiKeyResolverOptions, createApiKeyResolver } from "./api-key-resolver";
@@ -646,6 +646,7 @@ function normalizeSuppressedSelector(
 	if (!trimmed) return trimmed;
 	const parsed = parseModelString(trimmed, {
 		allowMaxAlias: true,
+		allowAutoAlias: true,
 		isLiteralModelId: (provider, id) => hasLiveModel?.(provider, id) === true,
 	});
 	if (!parsed) return trimmed;
@@ -762,7 +763,7 @@ export class ModelRegistry {
 			options?.fetch ??
 			(isBunTestRuntime()
 				? () => Promise.reject(new Error("network disabled in model-registry runtime test"))
-				: fetch);
+				: wrapFetchForExtraCa(fetch));
 		this.#modelsConfigFile = ModelsConfigFile.relocate(modelsPath);
 		this.#cacheDbPath = modelsPath ? path.join(path.dirname(modelsPath), "models.db") : undefined;
 		// Set up fallback resolver for custom provider API keys
@@ -1368,7 +1369,10 @@ export class ModelRegistry {
 			return `${providerConfig.provider}:openai-models-list-context-v2`;
 		}
 		if (providerConfig.discovery.type === "litellm") {
-			return `${providerConfig.provider}:litellm-rich-v1`;
+			// rich-v2 invalidates rows cached before reseller usage-suffix stripping
+			// (stale display names like `MiniMax-M3 (3x usage)`); keep in lockstep
+			// with the catalog package's `litellm:rich-vN` namespace.
+			return `${providerConfig.provider}:litellm-rich-v2`;
 		}
 		return providerConfig.provider;
 	}

package/src/config/model-resolver.ts

@@ -29,7 +29,13 @@ import { fuzzyMatch } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
-import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
+import {
+	AUTO_THINKING,
+	type ConfiguredThinkingLevel,
+	concreteThinkingLevel,
+	parseThinkingLevel,
+	resolveThinkingLevelForModel,
+} from "../thinking";
 import { isAuthenticated, kNoAuth, type ModelRegistry } from "./model-registry";
 import { MODEL_ROLE_IDS, type ModelRole } from "./model-roles";
 import type { Settings } from "./settings";
@@ -74,24 +80,32 @@ export interface ScopedModel {
 
 interface ThinkingSuffixOptions {
 	allowMaxAlias?: boolean;
+	allowAutoAlias?: boolean;
 }
 
 interface ModelStringParseOptions extends ThinkingSuffixOptions {
 	isLiteralModelId?: (provider: string, id: string) => boolean;
 }
-const MAX_THINKING_SUFFIX_OPTIONS: ThinkingSuffixOptions = { allowMaxAlias: true };
+// Alias-suffix recognition for the model-pattern parser: `:max` maps to xhigh
+// and `:auto` maps to the auto sentinel. Both are gated behind the alias flags
+// (and the literal-id / exact-match guards on the callers) so a real model id
+// ending in `:max` / `:auto` isn't silently reinterpreted as a thinking suffix.
+const MAX_THINKING_SUFFIX_OPTIONS: ThinkingSuffixOptions = { allowMaxAlias: true, allowAutoAlias: true };
 
-function parseThinkingSuffix(value: string, options?: ThinkingSuffixOptions): ThinkingLevel | undefined {
+function parseThinkingSuffix(value: string, options?: ThinkingSuffixOptions): ConfiguredThinkingLevel | undefined {
 	const level = parseThinkingLevel(value);
 	if (level !== undefined) return level;
-	return options?.allowMaxAlias === true && value === "max" ? ThinkingLevel.XHigh : undefined;
+	if (options?.allowMaxAlias === true && value === "max") return ThinkingLevel.XHigh;
+	if (options?.allowAutoAlias === true && value === AUTO_THINKING) return AUTO_THINKING;
+	return undefined;
 }
 
 /**
  * Split a trailing `:<level>` thinking selector off a model pattern.
  *
- * `level` is set only when the suffix parses as a valid thinking level, in
- * which case `base` has the suffix stripped; otherwise `base` is the input.
+ * `level` is set when the suffix parses as a concrete thinking level (or, when
+ * the caller opts in via `allowMaxAlias`/`allowAutoAlias`, the `:max` / `:auto`
+ * aliases); `base` then has the suffix stripped. Otherwise `base` is the input.
  * `minColonIndex` requires the colon to appear strictly after that index —
  * role-alias callers pass `PREFIX_MODEL_ROLE.length` so the base is at least
  * as long as the `pi/` prefix.
@@ -100,7 +114,7 @@ function splitThinkingSuffix(
 	pattern: string,
 	minColonIndex = -1,
 	options?: ThinkingSuffixOptions,
-): { base: string; level?: ThinkingLevel } {
+): { base: string; level?: ConfiguredThinkingLevel } {
 	const colonIdx = pattern.lastIndexOf(":");
 	if (colonIdx <= minColonIndex) return { base: pattern };
 	const level = parseThinkingSuffix(pattern.slice(colonIdx + 1), options);
@@ -119,12 +133,17 @@ function resolveGlobScopePattern(
 	pattern: string,
 	availableModels: readonly Model<Api>[],
 ): { models: Model<Api>[]; thinkingLevel?: ThinkingLevel; explicitThinkingLevel: boolean } {
+	// Glob scopes describe which models are enabled, not per-role thinking.
+	// Coerce the `auto` sentinel to a concrete-only view so scope callers stay
+	// typed on `ThinkingLevel` and `enabledModels: [\"openai/*:auto\"]` doesn't
+	// pin a stray per-model level.
 	const strictSuffix = splitThinkingSuffix(pattern);
 	if (strictSuffix.level !== undefined) {
+		const thinkingLevel = concreteThinkingLevel(strictSuffix.level);
 		return {
 			models: matchingGlobModels(strictSuffix.base, availableModels),
-			thinkingLevel: strictSuffix.level,
-			explicitThinkingLevel: true,
+			thinkingLevel,
+			explicitThinkingLevel: thinkingLevel !== undefined,
 		};
 	}
 
@@ -134,10 +153,11 @@ function resolveGlobScopePattern(
 		if (literalMatches.length > 0) {
 			return { models: literalMatches, thinkingLevel: undefined, explicitThinkingLevel: false };
 		}
+		const thinkingLevel = concreteThinkingLevel(maxSuffix.level);
 		return {
 			models: matchingGlobModels(maxSuffix.base, availableModels),
-			thinkingLevel: maxSuffix.level,
-			explicitThinkingLevel: true,
+			thinkingLevel,
+			explicitThinkingLevel: thinkingLevel !== undefined,
 		};
 	}
 
@@ -155,7 +175,7 @@ function resolveGlobScopePattern(
 export function parseModelString(
 	modelStr: string,
 	options?: ModelStringParseOptions,
-): { provider: string; id: string; thinkingLevel?: ThinkingLevel } | undefined {
+): { provider: string; id: string; thinkingLevel?: ConfiguredThinkingLevel } | undefined {
 	const slashIdx = modelStr.indexOf("/");
 	if (slashIdx <= 0) return undefined;
 	const id = modelStr.slice(slashIdx + 1);
@@ -208,7 +228,7 @@ export function formatModelStringWithRouting(model: Model<Api>): string {
 	return upstream ? `${selector}@${upstream}` : selector;
 }
 
-export function formatModelSelectorValue(selector: string, thinkingLevel: ThinkingLevel | undefined): string {
+export function formatModelSelectorValue(selector: string, thinkingLevel: ConfiguredThinkingLevel | undefined): string {
 	return thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit ? `${selector}:${thinkingLevel}` : selector;
 }
 
@@ -711,7 +731,7 @@ function matchModel(
 export interface ParsedModelResult {
 	model: Model<Api> | undefined;
 	/** Thinking level if explicitly specified in pattern, undefined otherwise */
-	thinkingLevel?: ThinkingLevel;
+	thinkingLevel?: ConfiguredThinkingLevel;
 	/** Upstream provider slug from an `@upstream` routing selector, if present. */
 	upstream?: string;
 	warning: string | undefined;
@@ -989,7 +1009,7 @@ export function resolveAgentModelPatterns(options: AgentModelPatternResolutionOp
  */
 export interface ResolvedModelRoleValue {
 	model: Model<Api> | undefined;
-	thinkingLevel?: ThinkingLevel;
+	thinkingLevel?: ConfiguredThinkingLevel;
 	explicitThinkingLevel: boolean;
 	warning: string | undefined;
 }
@@ -1021,7 +1041,9 @@ export function resolveModelRoleValue(
 			return {
 				model: resolved.model,
 				thinkingLevel: resolved.explicitThinkingLevel
-					? (resolveThinkingLevelForModel(resolved.model, resolved.thinkingLevel) ?? resolved.thinkingLevel)
+					? resolved.thinkingLevel === AUTO_THINKING
+						? AUTO_THINKING
+						: (resolveThinkingLevelForModel(resolved.model, resolved.thinkingLevel) ?? resolved.thinkingLevel)
 					: resolved.thinkingLevel,
 				explicitThinkingLevel: resolved.explicitThinkingLevel,
 				warning: resolved.warning,
@@ -1048,7 +1070,7 @@ export function extractExplicitThinkingSelector(
 	value: string | undefined,
 	settings?: Settings,
 	options?: ExplicitThinkingSelectorOptions,
-): ThinkingLevel | undefined {
+): ConfiguredThinkingLevel | undefined {
 	if (!value) return undefined;
 	const normalized = value.trim();
 	if (!normalized || normalized === DEFAULT_MODEL_ROLE) return undefined;
@@ -1127,7 +1149,7 @@ export function resolveModelOverride(
 	modelPatterns: string[],
 	modelRegistry: ModelLookupRegistry,
 	settings?: Settings,
-): { model?: Model<Api>; thinkingLevel?: ThinkingLevel; explicitThinkingLevel: boolean } {
+): { model?: Model<Api>; thinkingLevel?: ConfiguredThinkingLevel; explicitThinkingLevel: boolean } {
 	if (modelPatterns.length === 0) return { explicitThinkingLevel: false };
 	const availableModels = modelRegistry.getAvailable();
 	const matchPreferences = getModelMatchPreferences(settings);
@@ -1171,7 +1193,7 @@ export async function resolveModelOverrideWithAuthFallback(
 	settings?: Settings,
 ): Promise<{
 	model?: Model<Api>;
-	thinkingLevel?: ThinkingLevel;
+	thinkingLevel?: ConfiguredThinkingLevel;
 	explicitThinkingLevel: boolean;
 	authFallbackUsed: boolean;
 }> {
@@ -1207,7 +1229,7 @@ export function resolveRoleSelection(
 	roles: readonly string[],
 	settings: Settings,
 	availableModels: Model<Api>[],
-): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
+): { model: Model<Api>; thinkingLevel?: ConfiguredThinkingLevel } | undefined {
 	const matchPreferences = getModelMatchPreferences(settings);
 	for (const role of roles) {
 		const resolved = resolveModelRoleValue(settings.getModelRole(role), availableModels, {
@@ -1232,7 +1254,7 @@ export function resolveRoleSelection(
 export function resolveAdvisorRoleSelection(
 	settings: Settings,
 	availableModels: Model<Api>[],
-): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
+): { model: Model<Api>; thinkingLevel?: ConfiguredThinkingLevel } | undefined {
 	const resolved = resolveModelRoleValue(`${PREFIX_MODEL_ROLE}advisor`, availableModels, {
 		settings,
 		matchPreferences: getModelMatchPreferences(settings),
@@ -1307,7 +1329,13 @@ export async function resolveModelScope(
 			continue;
 		}
 
-		addScopedModel(model, thinkingLevel, explicitThinkingLevel);
+		// Scoped models (Ctrl+P cycling) carry concrete per-model overrides;
+		// `auto` lives on the session, so drop the sentinel here.
+		if (thinkingLevel === AUTO_THINKING) {
+			addScopedModel(model, undefined, false);
+		} else {
+			addScopedModel(model, thinkingLevel, explicitThinkingLevel);
+		}
 	}
 
 	return scopedModels;
@@ -1393,7 +1421,7 @@ export function filterAvailableModelsByEnabledPatterns(
 export interface ResolveCliModelResult {
 	model: Model<Api> | undefined;
 	selector?: string;
-	thinkingLevel?: ThinkingLevel;
+	thinkingLevel?: ConfiguredThinkingLevel;
 	warning: string | undefined;
 	error: string | undefined;
 }

package/src/config/models-config-schema.ts

@@ -127,6 +127,9 @@ const RemoteCompactionSchema = type({
 	"api?": ApiSchema,
 	"endpoint?": "string",
 	"model?": "string",
+	"v2StreamingEnabled?": "boolean",
+	"v2Endpoint?": "string",
+	"streamingEndpoint?": "string",
 }).narrow((value, ctx) => {
 	if (value.endpoint !== undefined && typeof value.endpoint === "string" && value.endpoint.length === 0) {
 		return ctx.mustBe("remoteCompaction.endpoint a non-empty string");
@@ -134,6 +137,16 @@ const RemoteCompactionSchema = type({
 	if (value.model !== undefined && typeof value.model === "string" && value.model.length === 0) {
 		return ctx.mustBe("remoteCompaction.model a non-empty string");
 	}
+	if (value.v2Endpoint !== undefined && typeof value.v2Endpoint === "string" && value.v2Endpoint.length === 0) {
+		return ctx.mustBe("remoteCompaction.v2Endpoint a non-empty string");
+	}
+	if (
+		value.streamingEndpoint !== undefined &&
+		typeof value.streamingEndpoint === "string" &&
+		value.streamingEndpoint.length === 0
+	) {
+		return ctx.mustBe("remoteCompaction.streamingEndpoint a non-empty string");
+	}
 	return true;
 });