gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1d17f366c

package/packages/pi-coding-agent/src/core/model-registry-custom-caps.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Regression tests for #4563:
+ *   Bug 1 — custom/Anthropic-compatible models were hard-capped to 32 k output tokens
+ *   Bug 2 — custom models in models.json could not declare capabilities.supportsXhigh
+ */
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+let testDir: string;
+
+beforeEach(() => {
+	testDir = join(
+		tmpdir(),
+		`model-registry-custom-caps-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(testDir, { recursive: true });
+});
+
+afterEach(() => {
+	try {
+		rmSync(testDir, { recursive: true, force: true });
+	} catch {
+		// best-effort cleanup
+	}
+});
+
+function createRegistry(modelsJson: object): ModelRegistry {
+	const path = join(testDir, "models.json");
+	writeFileSync(path, JSON.stringify(modelsJson));
+	return new ModelRegistry(AuthStorage.inMemory(), path);
+}
+
+function writeModelsJson(obj: object): string {
+	const path = join(testDir, "models.json");
+	writeFileSync(path, JSON.stringify(obj));
+	return path;
+}
+
+// ─── Bug 1: 32 k cap must not apply to custom/OpenAI-compatible models ────────
+
+describe("Bug 1 — maxTokens cap (#4563)", () => {
+	it("custom openai-completions model with maxTokens > 32 k is not capped", () => {
+		const registry = createRegistry({
+			providers: {
+				"kimi-custom": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "kimi-k2.6-code-preview",
+							name: "Kimi K2.6 Code Preview",
+							maxTokens: 131072,
+							contextWindow: 262144,
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "kimi-k2.6-code-preview");
+		assert.ok(model, "model should be registered");
+		assert.equal(
+			model.maxTokens,
+			131072,
+			"maxTokens must be preserved as declared — not capped to 32 000",
+		);
+	});
+
+	it("custom model with maxTokens exactly 32 k is not affected", () => {
+		const registry = createRegistry({
+			providers: {
+				"custom-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [{ id: "model-32k", maxTokens: 32000, contextWindow: 128000 }],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "model-32k");
+		assert.ok(model);
+		assert.equal(model.maxTokens, 32000);
+	});
+
+	it("custom model with maxTokens 65 k is stored at full value", () => {
+		const registry = createRegistry({
+			providers: {
+				"dashscope-custom": {
+					baseUrl: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "qwen3.5-plus",
+							name: "Qwen3.5 Plus",
+							maxTokens: 65536,
+							contextWindow: 1000000,
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "qwen3.5-plus" && m.provider === "dashscope-custom");
+		assert.ok(model);
+		assert.equal(model.maxTokens, 65536);
+	});
+});
+
+// ─── Bug 2: capabilities.supportsXhigh must be declarable in models.json ──────
+
+describe("Bug 2 — capabilities.supportsXhigh in models.json (#4563)", () => {
+	it("model with capabilities.supportsXhigh: true surfaces the flag", () => {
+		const registry = createRegistry({
+			providers: {
+				"kimi-custom": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "anthropic-messages",
+					models: [
+						{
+							id: "kimi-k2.6-code-preview",
+							name: "Kimi K2.6 Code Preview",
+							maxTokens: 131072,
+							contextWindow: 262144,
+							capabilities: { supportsXhigh: true },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "kimi-k2.6-code-preview");
+		assert.ok(model, "model should be registered");
+		assert.equal(
+			model.capabilities?.supportsXhigh,
+			true,
+			"supportsXhigh must be true as declared in models.json",
+		);
+	});
+
+	it("model without capabilities declaration has no supportsXhigh", () => {
+		const registry = createRegistry({
+			providers: {
+				"plain-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [{ id: "plain-model", maxTokens: 16384, contextWindow: 128000 }],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "plain-model");
+		assert.ok(model);
+		// supportsXhigh should be absent or explicitly false — never implicitly true
+		assert.ok(
+			!model.capabilities?.supportsXhigh,
+			"supportsXhigh must not be set for models that don't declare it",
+		);
+	});
+
+	it("capabilities.supportsXhigh: false is respected", () => {
+		const registry = createRegistry({
+			providers: {
+				"explicit-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "no-xhigh-model",
+							capabilities: { supportsXhigh: false },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "no-xhigh-model");
+		assert.ok(model);
+		assert.equal(model.capabilities?.supportsXhigh, false);
+	});
+
+	it("supportsXhigh declared in models.json is not overwritten by capability patches", () => {
+		// The capability-patches system must not overwrite an explicit declaration in models.json.
+		// applyCapabilityPatches uses spread: { ...patch.caps, ...model.capabilities }
+		// so model.capabilities wins. This test verifies the precedence end-to-end.
+		const registry = createRegistry({
+			providers: {
+				"compat-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "custom-xhigh-model",
+							capabilities: { supportsXhigh: true },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "custom-xhigh-model");
+		assert.ok(model);
+		assert.equal(model.capabilities?.supportsXhigh, true);
+	});
+
+	it("modelOverrides can set capabilities.supportsXhigh on built-in models", () => {
+		// A user-facing override in models.json should be able to add supportsXhigh
+		// to a built-in model that doesn't declare it.
+		const path = writeModelsJson({
+			providers: {
+				anthropic: {
+					modelOverrides: {
+						"claude-3-5-haiku-20241022": {
+							capabilities: { supportsXhigh: true },
+						},
+					},
+				},
+			},
+		});
+
+		const registry = new ModelRegistry(AuthStorage.inMemory(), path);
+		const model = registry.getAll().find(
+			(m) => m.provider === "anthropic" && m.id === "claude-3-5-haiku-20241022",
+		);
+		assert.ok(model, "built-in model must still be present");
+		assert.equal(
+			model.capabilities?.supportsXhigh,
+			true,
+			"modelOverrides must be able to set capabilities.supportsXhigh",
+		);
+	});
+});

package/packages/pi-coding-agent/src/core/model-registry.ts

@@ -48,6 +48,14 @@ const VercelGatewayRoutingSchema = Type.Object({
 	order: Type.Optional(Type.Array(Type.String())),
 });
 
+// Schema for model capability declarations (mirrors ModelCapabilities in pi-ai types)
+const ModelCapabilitiesSchema = Type.Object({
+	supportsXhigh: Type.Optional(Type.Boolean()),
+	requiresToolCallId: Type.Optional(Type.Boolean()),
+	supportsServiceTier: Type.Optional(Type.Boolean()),
+	charsPerToken: Type.Optional(Type.Number()),
+});
+
 // Schema for OpenAI compatibility settings
 const OpenAICompletionsCompatSchema = Type.Object({
 	supportsStore: Type.Optional(Type.Boolean()),
@@ -91,6 +99,7 @@ const ModelDefinitionSchema = Type.Object({
 	maxTokens: Type.Optional(Type.Number()),
 	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
 	compat: Type.Optional(OpenAICompatSchema),
+	capabilities: Type.Optional(ModelCapabilitiesSchema),
 });
 
 // Schema for per-model overrides (all fields optional, merged with built-in model)
@@ -110,6 +119,7 @@ const ModelOverrideSchema = Type.Object({
 	maxTokens: Type.Optional(Type.Number()),
 	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
 	compat: Type.Optional(OpenAICompatSchema),
+	capabilities: Type.Optional(ModelCapabilitiesSchema),
 });
 
 type ModelOverride = Static<typeof ModelOverrideSchema>;
@@ -219,6 +229,11 @@ function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<A
 	// Deep merge compat
 	result.compat = mergeCompat(model.compat, override.compat);
 
+	// Merge capabilities (override wins per-field)
+	if (override.capabilities) {
+		result.capabilities = { ...model.capabilities, ...override.capabilities };
+	}
+
 	return result;
 }
 
@@ -514,6 +529,7 @@ export class ModelRegistry {
 					maxTokens: modelDef.maxTokens ?? 16384,
 					headers,
 					compat: modelDef.compat,
+					capabilities: modelDef.capabilities,
 				} as Model<Api>);
 			}
 		}

package/packages/pi-coding-agent/src/core/resource-loader.ts

@@ -242,7 +242,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 		this.systemPromptOverride = options.systemPromptOverride;
 		this.appendSystemPromptOverride = options.appendSystemPromptOverride;
 
-		this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
+		this.extensionsResult = { extensions: [], errors: [], warnings: [], runtime: createExtensionRuntime() };
 		this.skills = [];
 		this.skillDiagnostics = [];
 		this.prompts = [];

package/packages/pi-coding-agent/src/core/sdk.test.ts

@@ -3,7 +3,8 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { CredentialCooldownError } from "./sdk.js";
+import { canRestoreSessionModel, CredentialCooldownError } from "./sdk.js";
+import type { Model } from "@gsd/pi-ai";
 
 // ─── CredentialCooldownError ──────────────────────────────────────────────────
 
@@ -87,3 +88,26 @@ describe("CredentialCooldownError", () => {
 		assert.equal(plain.retryAfterMs, 15_000);
 	});
 });
+
+describe("canRestoreSessionModel", () => {
+	const model = {
+		provider: "claude-code",
+		id: "claude-sonnet",
+	} as Model<any>;
+
+	it("allows keyless external providers when the provider is request-ready", () => {
+		const registry = {
+			isProviderRequestReady: (provider: string) => provider === "claude-code",
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), true);
+	});
+
+	it("blocks restore when the provider is not request-ready", () => {
+		const registry = {
+			isProviderRequestReady: () => false,
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), false);
+	});
+});

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -31,6 +31,13 @@ export class CredentialCooldownError extends Error {
 		this.retryAfterMs = retryAfterMs;
 	}
 }
+
+export function canRestoreSessionModel(
+	modelRegistry: Pick<ModelRegistry, "isProviderRequestReady">,
+	model: Model<any>,
+): boolean {
+	return modelRegistry.isProviderRequestReady(model.provider);
+}
 import { Agent, type AgentMessage, type ThinkingLevel } from "@gsd/pi-agent-core";
 import type { Message, Model } from "@gsd/pi-ai";
 import { getAgentDir, getDocsPath } from "../config.js";
@@ -262,9 +269,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// If session has data, try to restore model from it
 	if (!model && hasExistingSession && existingSession.model) {
 		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
+			if (restoredModel && canRestoreSessionModel(modelRegistry, restoredModel)) {
+				model = restoredModel;
+			}
 		if (!model) {
 			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
 		}

package/packages/pi-coding-agent/src/core/session-manager.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it, afterEach } from "node:test";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -97,4 +97,33 @@ describe("SessionManager secret redaction on persistence", () => {
 			"redaction placeholder must appear in persisted JSONL",
 		);
 	});
+
+	it("scrubs secrets from JSONL rewritten by _rewriteFile() during migration", () => {
+		// Write a v1 session file (no id/parentId on entries) containing a secret.
+		// setSessionFile() will detect version < 3, run migration, and call _rewriteFile()
+		// which previously serialised entries without passing them through redaction.
+		dir = mkdtempSync(join(tmpdir(), "gsd-session-rewrite-redact-test-"));
+		const leakedKey = "sk-ant-api03-abcDEF1234567890abcDEF1234567890xYz";
+		const v1Header = JSON.stringify({ type: "session", version: 1, id: "test-session-id", timestamp: new Date().toISOString(), cwd: dir });
+		const v1UserMsg = JSON.stringify({ type: "message", message: { role: "user", content: [{ type: "text", text: `secret: ${leakedKey}` }] } });
+		const v1AssistantMsg = JSON.stringify({ type: "message", message: { role: "assistant", content: [{ type: "text", text: "ok" }], usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, total: 2, cost: { total: 0 } } } });
+		const sessionFile = join(dir, "test-session.jsonl");
+		writeFileSync(sessionFile, [v1Header, v1UserMsg, v1AssistantMsg].join("\n") + "\n", "utf8");
+
+		// Loading this file triggers migrateToCurrentVersion() which returns true (v1 → v3),
+		// causing _rewriteFile() to rewrite the file. The bug: _rewriteFile() called
+		// JSON.stringify(e) without redaction, so the secret would survive on disk.
+		const manager = SessionManager.create(dir, dir);
+		manager.setSessionFile(sessionFile);
+
+		const contents = readFileSync(sessionFile, "utf8");
+		assert.ok(
+			!contents.includes(leakedKey),
+			"raw secret must not appear in JSONL rewritten by _rewriteFile()",
+		);
+		assert.ok(
+			contents.includes("[REDACTED:anthropic]"),
+			"redaction placeholder must appear in JSONL rewritten by _rewriteFile()",
+		);
+	});
 });

package/packages/pi-coding-agent/src/core/session-manager.ts

@@ -959,7 +959,7 @@ export class SessionManager {
 
 	private _rewriteFile(): void {
 		if (!this.persist || !this.sessionFile) return;
-		const content = `${this.fileEntries.map((e) => JSON.stringify(e)).join("\n")}\n`;
+		const content = `${this.fileEntries.map((e) => JSON.stringify(prepareForPersistence(e, this.blobStore))).join("\n")}\n`;
 		let release: (() => void) | undefined;
 		try {
 			release = tryAcquireLockSync(this.sessionFile);

package/packages/pi-coding-agent/src/core/system-prompt.ts

@@ -109,9 +109,9 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	}
 
 	// Get absolute paths to documentation and examples
-	const readmePath = getReadmePath();
-	const docsPath = getDocsPath();
-	const examplesPath = getExamplesPath();
+	const readmePath = toPosixPath(getReadmePath());
+	const docsPath = toPosixPath(getDocsPath());
+	const examplesPath = toPosixPath(getExamplesPath());
 
 	// Build tools list based on selected tools.
 	// Built-ins use toolDescriptions. Custom tools can provide one-line snippets.

package/packages/pi-coding-agent/src/core/tools/path-utils.test.ts

@@ -1,11 +1,12 @@
 import { describe, it, mock, afterEach } from "node:test";
 import assert from "node:assert/strict";
+import { resolve as resolvePath } from "node:path";
 import { resolveToCwd, expandPath } from "./path-utils.js";
 
 describe("resolveToCwd", () => {
 	it("resolves relative paths against cwd", () => {
 		const result = resolveToCwd("foo/bar.txt", "/home/user/project");
-		assert.equal(result, "/home/user/project/foo/bar.txt");
+		assert.equal(result, resolvePath("/home/user/project", "foo/bar.txt"));
 	});
 
 	it("returns absolute paths unchanged", () => {

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/provider-display-name.test.ts

@@ -1,14 +1,11 @@
-// GSD-2 — Provider display name mapping tests
+// GSD-2 — Provider display name + auth badge tests
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
-import { providerDisplayName } from "../model-selector.js";
+import { providerAuthBadge, providerDisplayName } from "../model-selector.js";
 
 describe("providerDisplayName", () => {
-	test("renames 'anthropic' to 'anthropic-api'", () => {
-		assert.equal(providerDisplayName("anthropic"), "anthropic-api");
-	});
-
-	test("passes through unmapped providers unchanged", () => {
+	test("passes providers through unchanged", () => {
+		assert.equal(providerDisplayName("anthropic"), "anthropic");
 		assert.equal(providerDisplayName("claude-code"), "claude-code");
 		assert.equal(providerDisplayName("openai"), "openai");
 		assert.equal(providerDisplayName("bedrock"), "bedrock");
@@ -16,3 +13,16 @@ describe("providerDisplayName", () => {
 		assert.equal(providerDisplayName("openrouter"), "openrouter");
 	});
 });
+
+describe("providerAuthBadge", () => {
+	test("returns human-readable labels for each auth mode", () => {
+		assert.equal(providerAuthBadge("apiKey"), "API key");
+		assert.equal(providerAuthBadge("oauth"), "OAuth");
+		assert.equal(providerAuthBadge("externalCli"), "CLI");
+	});
+
+	test("returns empty string for 'none' and undefined", () => {
+		assert.equal(providerAuthBadge("none"), "");
+		assert.equal(providerAuthBadge(undefined), "");
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/components/footer.ts

@@ -2,7 +2,7 @@ import { type Component, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import type { AgentSession } from "../../../core/agent-session.js";
 import type { ReadonlyFooterDataProvider } from "../../../core/footer-data-provider.js";
 import { theme } from "../theme/theme.js";
-import { providerDisplayName } from "./model-selector.js";
+import { providerAuthBadge, providerDisplayName } from "./model-selector.js";
 
 /**
  * Sanitize text for display in a single-line status.
@@ -199,13 +199,22 @@ export class FooterComponent implements Component {
 				thinkingLevel === "off" ? `${modelName} • thinking off` : `${modelName} • ${thinkingLevel}`;
 		}
 
-		// Prepend the provider in parentheses if there are multiple providers and there's enough room
+		// Prepend the provider in parentheses if there are multiple providers and there's enough room.
+		// Include the auth mode so users can tell at a glance whether the active model is
+		// API-key-backed, OAuth-backed, or delegated to a third-party CLI.
 		let rightSide = rightSideWithoutProvider;
 		if (this.footerData.getAvailableProviderCount() > 1 && displayModel) {
-			rightSide = `(${providerDisplayName(displayModel.provider)}) ${rightSideWithoutProvider}`;
+			const authMode = this.session.modelRegistry.getProviderAuthMode(displayModel.provider);
+			const authLabel = providerAuthBadge(authMode);
+			const providerLabel = providerDisplayName(displayModel.provider);
+			const parenthetical = authLabel ? `${providerLabel} · ${authLabel}` : providerLabel;
+			rightSide = `(${parenthetical}) ${rightSideWithoutProvider}`;
 			if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
-				// Too wide, fall back
-				rightSide = rightSideWithoutProvider;
+				// Too wide: drop the auth suffix first, then fall back to no parenthetical.
+				rightSide = `(${providerLabel}) ${rightSideWithoutProvider}`;
+				if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
+					rightSide = rightSideWithoutProvider;
+				}
 			}
 		}
 

package/packages/pi-coding-agent/src/modes/interactive/components/model-selector.ts

@@ -9,19 +9,32 @@ import {
 	Text,
 	type TUI,
 } from "@gsd/pi-tui";
-import type { ModelRegistry } from "../../../core/model-registry.js";
+import type { ModelRegistry, ProviderAuthMode } from "../../../core/model-registry.js";
 import type { SettingsManager } from "../../../core/settings-manager.js";
 import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyHint } from "./keybinding-hints.js";
 
-/** Display names for providers in the model selector UI. */
-const PROVIDER_DISPLAY_NAMES: Record<string, string> = {
-	anthropic: "anthropic-api",
-};
-
 export function providerDisplayName(provider: string): string {
-	return PROVIDER_DISPLAY_NAMES[provider] ?? provider;
+	return provider;
+}
+
+/**
+ * Short, user-facing label for a provider's auth mode. Returned strings are
+ * suitable for use as a suffix/badge alongside the provider name.
+ * Returns an empty string for modes that don't need a badge (e.g. "none").
+ */
+export function providerAuthBadge(authMode?: ProviderAuthMode): string {
+	switch (authMode) {
+		case "apiKey":
+			return "API key";
+		case "oauth":
+			return "OAuth";
+		case "externalCli":
+			return "CLI";
+		default:
+			return "";
+	}
 }
 
 function formatTokenCount(count: number): string {
@@ -140,7 +153,8 @@ export class ModelSelectorComponent extends Container implements Focusable {
 			this.scopeHintText = new Text(this.getScopeHintText(), 0, 0);
 			this.addChild(this.scopeHintText);
 		} else {
-			const hintText = "Only showing models with configured API keys (see README for details)";
+			const hintText =
+				"Only showing models with configured credentials (API key, OAuth, or CLI). See README for details.";
 			this.addChild(new Text(theme.fg("warning", hintText), 0, 0));
 		}
 		this.addChild(new Spacer(1));
@@ -409,7 +423,12 @@ export class ModelSelectorComponent extends Container implements Focusable {
 
 			const ctx = formatTokenCount(item.model.contextWindow);
 			const ctxBadge = theme.fg("muted", `${ctx}`);
-			const providerBadge = theme.fg("muted", `[${providerDisplayName(item.provider)}]`);
+			const authMode = this.modelRegistry.getProviderAuthMode(item.provider);
+			const authLabel = providerAuthBadge(authMode);
+			const providerBadgeText = authLabel
+				? `[${providerDisplayName(item.provider)} · ${authLabel}]`
+				: `[${providerDisplayName(item.provider)}]`;
+			const providerBadge = theme.fg("muted", providerBadgeText);
 			const checkmark = isCurrent ? theme.fg("success", " ✓") : "";
 
 			let line: string;
@@ -445,7 +464,19 @@ export class ModelSelectorComponent extends Container implements Focusable {
 		const maxVisible = 12;
 
 		if (this.groupedRows.length === 0) {
-			this.listContainer.addChild(new Text(theme.fg("muted", "  No models available"), 0, 0));
+			this.listContainer.addChild(
+				new Text(theme.fg("muted", "  No providers configured."), 0, 0),
+			);
+			this.listContainer.addChild(
+				new Text(
+					theme.fg(
+						"muted",
+						"  Run /login (OAuth), set an API key, or install a CLI provider. See README.",
+					),
+					0,
+					0,
+				),
+			);
 			return;
 		}
 
@@ -467,11 +498,14 @@ export class ModelSelectorComponent extends Container implements Focusable {
 				// Provider group header — always unselectable
 				const providerLabel = theme.fg("borderAccent", providerDisplayName(row.provider));
 				const count = theme.fg("muted", ` (${row.count})`);
+				const authMode = this.modelRegistry.getProviderAuthMode(row.provider);
+				const authLabel = providerAuthBadge(authMode);
+				const authText = authLabel ? theme.fg("muted", ` · via ${authLabel}`) : "";
 				// Add blank line before header if not the very first visible row
 				if (i > startIndex) {
 					this.listContainer.addChild(new Text("", 0, 0));
 				}
-				this.listContainer.addChild(new Text(`  ${providerLabel}${count}`, 0, 0));
+				this.listContainer.addChild(new Text(`  ${providerLabel}${count}${authText}`, 0, 0));
 			} else {
 				// Model row
 				const isSelected = i === this.selectedGroupIndex;

package/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.test.ts

@@ -17,6 +17,7 @@ function createHost(options: HostOptions = {}) {
 	const prompted: string[] = [];
 	const errors: string[] = [];
 	const warnings: string[] = [];
+	const tips: string[] = [];
 	const history: string[] = [];
 	const knownSlashCommands = new Set(options.knownSlashCommands ?? []);
 	let editorText = "";
@@ -60,6 +61,9 @@ function createHost(options: HostOptions = {}) {
 		showError(message: string) {
 			errors.push(message);
 		},
+		showTip(message: string) {
+			tips.push(message);
+		},
 		updateEditorBorderColor() {},
 		isExtensionCommand() {
 			return false;
@@ -70,6 +74,15 @@ function createHost(options: HostOptions = {}) {
 		queueCompactionMessage() {},
 		updatePendingMessagesDisplay() {},
 		flushPendingBashComponents() {},
+		contextualTips: {
+			recordBashIncluded() {},
+			evaluate() {
+				return undefined;
+			},
+		},
+		getContextPercent() {
+			return undefined;
+		},
 	};
 
 	setupEditorSubmitHandler(host as any);
@@ -79,6 +92,7 @@ function createHost(options: HostOptions = {}) {
 		prompted,
 		errors,
 		warnings,
+		tips,
 		history,
 		getEditorText: () => editorText,
 		getSettingsOpened: () => settingsOpened,