@iowarp/clio-coder 0.4.5 → 0.4.6

package/src/cli/oauth-manual-input.ts

@@ -6,7 +6,7 @@ export interface DelayedManualCodeInput {
 }
 
 export function createDelayedManualCodeInput(
-	rl: ReadlineInterface,
+	rl: Pick<ReadlineInterface, "question">,
 	prompt: string,
 	options?: { delayMs?: number },
 ): DelayedManualCodeInput {

package/src/cli/reset.ts

@@ -372,6 +372,8 @@ export async function runResetCommand(argv: ReadonlyArray<string>): Promise<numb
 		presenter.finish();
 		return 1;
 	}
+	if (args.config || args.all) presenter.commandAdvice("Set up a model again:", "clio-coder configure");
+	else if (args.auth) presenter.commandAdvice("Reconnect your providers:", "clio-coder configure --section targets");
 
 	presenter.done("Done");
 	return 0;

package/src/cli/select.ts

@@ -48,6 +48,8 @@ export interface SelectOptions<T> {
 	backLabel?: string;
 	/** Rows to show at once. Defaults to what the terminal has room for. */
 	maxVisible?: number;
+	/** Filter a long list by typing; q/j/k are text in this mode. */
+	searchable?: boolean;
 	/**
 	 * Erase the menu once it is answered, leaving the caller's transcript to say
 	 * what was chosen. A wizard that redraws its own answer rows needs this; a
@@ -243,7 +245,7 @@ function viewportFor(output: NodeJS.WriteStream, overhead: number, total: number
 export async function promptSelect<T>(options: SelectOptions<T>): Promise<SelectResult<T>> {
 	const input = options.input ?? process.stdin;
 	const output = options.output ?? process.stdout;
-	const choices = options.choices;
+	let choices = options.choices;
 	if (choices.length === 0) return { kind: "back" };
 
 	const rail = options.railPrefix ?? "";
@@ -255,15 +257,25 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 
 	let index = Math.min(Math.max(options.initialIndex ?? 0, 0), choices.length - 1);
 	let windowStart = 0;
+	let query = "";
+	const filter = () => {
+		choices = options.choices.filter((choice) => choice.label.toLowerCase().includes(query.toLowerCase()));
+		index = 0;
+		windowStart = 0;
+		render();
+	};
 
 	const render = (): void => {
-		const viewport = viewportFor(output, head.length + 5, choices.length, options.maxVisible);
+		const viewport = viewportFor(output, head.length + (options.searchable ? 6 : 5), choices.length, options.maxVisible);
 		if (index < windowStart) windowStart = index;
 		else if (index >= windowStart + viewport) windowStart = index - viewport + 1;
 		windowStart = Math.max(0, Math.min(windowStart, choices.length - viewport));
 		const lines: string[] = [];
 		for (const line of head) lines.push(`${rail}${line}`.trimEnd());
 		if (head.length > 0) lines.push(rail.trimEnd());
+		if (options.searchable)
+			lines.push(`${rail}${truncate(`Filter: ${query || "(type to search)"}`, terminalColumns(output) - railWidth)}`);
+		if (choices.length === 0) lines.push(`${rail}No matching models`);
 		lines.push(
 			...choiceRows(
 				{
@@ -284,7 +296,8 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 		// "quit" reads as two different exits.
 		const legend = ["↑/↓ move", "enter select"];
 		if (options.backLabel !== undefined && options.backLabel !== "quit") legend.push(`esc ${options.backLabel}`);
-		legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
+		if (options.searchable) legend.push("type to filter", "ctrl-u clear", "ctrl-c quit");
+		else legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
 		lines.push(`${rail}${chalk.dim(legend.join(" · "))}`);
 		frame.draw(lines);
 	};
@@ -294,11 +307,29 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 		output,
 		true,
 		render,
-		(_str, key, finish) => {
+		(str, key, finish) => {
 			if (key.ctrl && (key.name === "c" || key.name === "d")) {
 				finish({ kind: "quit" });
 				return;
 			}
+			if (options.searchable) {
+				if (key.ctrl && key.name === "u") {
+					query = "";
+					filter();
+					return;
+				}
+				if (key.name === "backspace") {
+					query = query.slice(0, -1);
+					filter();
+					return;
+				}
+				if (!key.ctrl && !key.meta && str?.length === 1 && str >= " " && str !== "\x7f") {
+					query += str;
+					filter();
+					return;
+				}
+				if (choices.length === 0 && !["escape", "left"].includes(key.name ?? "")) return;
+			}
 			switch (key.name) {
 				case "up":
 				case "k":

package/src/cli/upgrade.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { initializeClioHome } from "../core/init.js";
-import { clioStateDir } from "../core/xdg.js";
+import { resolveClioDirs } from "../core/xdg.js";
 import { detectInstallMethod } from "../domains/lifecycle/install-method.js";
 import { listMigrations, readMigrationManifest, runPending } from "../domains/lifecycle/migrations/index.js";
 import { readStateInfo } from "../domains/lifecycle/state.js";
@@ -185,7 +185,7 @@ export async function runUpgradeCommand(argv: ReadonlyArray<string>): Promise<nu
 	presenter.header("Upgrade", "upgrade");
 
 	const before = getVersionInfo().clio;
-	const stateDir = clioStateDir();
+	const stateDir = resolveClioDirs().state;
 	const method = detectInstallMethod();
 	const methodLabel = method === "source" ? "source checkout" : opts.postInstall ? "package install" : "npm global";
 	presenter.setMethod(methodLabel);

package/src/core/config.ts

@@ -21,6 +21,7 @@ import {
 	ACTIVE_ROUTING_ROLES,
 	COUNCIL_MEMBER_LABEL_PATTERN,
 	DEFAULT_SETTINGS,
+	normalizeOutputStyle,
 	THEME_NAMED_COLORS,
 	THINKING_LEVELS,
 	type ThinkingLevel,
@@ -1745,8 +1746,12 @@ export function validateSettings(raw: unknown): SettingsValidationResult {
 				const parsed = expectBoolean(issues, `interface.${key}`, ui[key]);
 				if (parsed !== undefined) (settings.interface as unknown as Record<string, unknown>)[key] = parsed;
 			}
+			if ("outputDetail" in ui) {
+				const style = normalizeOutputStyle(ui.outputDetail);
+				if (style) settings.interface.outputDetail = style;
+				else issues.add("interface.outputDetail", "expected compact, standard, or detailed");
+			}
 			for (const [key, allowed] of [
-				["outputDetail", ["minimal", "default", "verbose"]],
 				["smoothStreaming", ["off", "auto", "on"]],
 				["mode", ["regular", "fullscreen"]],
 				["fullscreenScrollbar", ["hidden", "auto", "always"]],

package/src/core/defaults.ts

@@ -219,15 +219,37 @@ export interface RetrySettings {
 	streamStallMs: number;
 }
 
-export type OutputVerbosity = "minimal" | "default" | "verbose";
+export const OUTPUT_STYLES = ["compact", "standard", "detailed"] as const;
+export type OutputStyle = (typeof OUTPUT_STYLES)[number];
+
+/** Read older preferences without rewriting a user's settings on startup. */
+export function normalizeOutputStyle(value: unknown): OutputStyle | undefined {
+	switch (value) {
+		case "minimal":
+		case "compact":
+			return "compact";
+		case "default":
+		case "standard":
+			return "standard";
+		case "verbose":
+		case "detailed":
+			return "detailed";
+		default:
+			return undefined;
+	}
+}
+
+export function nextOutputStyle(style: OutputStyle): OutputStyle {
+	return OUTPUT_STYLES[(OUTPUT_STYLES.indexOf(style) + 1) % OUTPUT_STYLES.length] ?? "standard";
+}
 export type TuiMode = "regular" | "fullscreen";
 export type FullscreenScrollbar = "hidden" | "auto" | "always";
 export type SmoothStreaming = "off" | "auto" | "on";
 
 export interface InterfaceSettings {
 	terminalProgress: boolean;
-	/** Transcript detail: collapsed, balanced, or fully transparent. */
-	outputDetail: OutputVerbosity;
+	/** Output style: Compact, Standard, or Detailed bounded previews. */
+	outputDetail: OutputStyle;
 	/** Regular scrollback-preserving renderer or alternate-screen sticky layout. */
 	mode: TuiMode;
 	/** Fullscreen transcript scrollbar visibility. */
@@ -456,7 +478,7 @@ export const DEFAULT_SETTINGS = {
 			recentLimit: 12,
 		} as ModelSelectorSettings,
 		maxOutputTokens: 0,
-		prewarm: true,
+		prewarm: false,
 		retry: {
 			enabled: true,
 			maxRetries: 3,
@@ -484,7 +506,7 @@ export const DEFAULT_SETTINGS = {
 			mode: "deny" as WorkerPermissionMode,
 			escalation: { timeoutMs: 120000, fallback: "deny" } as WorkerEscalationSettings,
 		},
-		concurrency: "auto" as "auto" | number,
+		concurrency: 1 as "auto" | number,
 		retry: { maxRetries: 2, routeCooldownMs: 15000 },
 		limits: {
 			toolCallsPerRun: GUARDRAIL_DEFAULTS.workerToolCallCap,
@@ -521,10 +543,10 @@ export const DEFAULT_SETTINGS = {
 	} as SafetySettings,
 	interface: {
 		terminalProgress: false,
-		outputDetail: "default",
+		outputDetail: "standard",
 		mode: "regular",
 		fullscreenScrollbar: "auto",
-		smoothStreaming: "off",
+		smoothStreaming: "auto",
 		desktopNotifications: false,
 		panes: {
 			enabled: "off",
@@ -591,7 +613,7 @@ chat:
     favorites: []
     recentLimit: 12
   maxOutputTokens: 0
-  prewarm: true
+  prewarm: false
   retry:
     enabled: true
     maxRetries: 3
@@ -617,7 +639,7 @@ fleet:
     escalation:
       timeoutMs: 120000
       fallback: deny
-  concurrency: auto
+  concurrency: 1
   retry:
     maxRetries: 2
     routeCooldownMs: 15000
@@ -659,8 +681,8 @@ safety:
     enabled: false
 
 interface:
-  outputDetail: default
-  smoothStreaming: off
+  outputDetail: standard
+  smoothStreaming: auto
   mode: regular
   fullscreenScrollbar: auto
   terminalProgress: false

package/src/{interactive → core}/external-editor.ts

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { shellQuote } from "../core/shell-quote.js";
+import { shellQuote } from "./shell-quote.js";
 
 export type ExternalEditorProbe = (candidates: ReadonlyArray<string>) => string | null;
 
@@ -48,11 +48,11 @@ export function resolveExternalEditor(
 	return probe(["nano", "vi"]);
 }
 
-export function editTextExternally(initialText: string, command: string | null): ExternalEditResult {
+export function editTextExternally(initialText: string, command: string | null, extension = ".md"): ExternalEditResult {
 	if (!command) return { ok: false, error: "no external editor configured; set VISUAL or EDITOR" };
-	const tmpFile = join(tmpdir(), `clio-coder-editor-${process.pid}-${randomUUID()}.md`);
+	const tmpFile = join(tmpdir(), `clio-coder-editor-${process.pid}-${randomUUID()}${extension}`);
 	try {
-		writeFileSync(tmpFile, initialText, "utf8");
+		writeFileSync(tmpFile, initialText, { encoding: "utf8", mode: 0o600, flag: "wx" });
 		const result = runEditor(command, tmpFile);
 		if (result.error) return { ok: false, error: result.error.message };
 		if (result.status !== 0) return { ok: false, error: `external editor exited with code ${result.status ?? "?"}` };

package/src/domains/config/classify.ts

@@ -22,6 +22,7 @@ const HOT_RELOAD_FIELDS = new Set<string>([
 	"interface.keybindings",
 	"safety.autonomy",
 	"chat.modelPicker",
+	"interface.outputDetail",
 	"interface.smoothStreaming",
 	"interface.panes.notifications",
 	"integrations.git.commitAttribution",
@@ -49,7 +50,6 @@ const NEXT_TURN_FIELDS = new Set<string>([
 	"fleet.history",
 	"context",
 	"safety.limits",
-	"interface.outputDetail",
 	"interface.terminalProgress",
 	"interface.desktopNotifications",
 	"integrations.projectResources",

package/src/domains/config/keybindings.ts

@@ -19,6 +19,7 @@ import { TUI_KEYBINDINGS } from "../../engine/tui.js";
  * live in `resolveCtrlCAction` and are not a simple keybinding.
  */
 export interface ClioAppKeybindings {
+	"clio-coder.output.cycle": true;
 	"clio-coder.thinking.cycle": true;
 	"clio-coder.exit": true;
 	"clio-coder.status.toggle": true;
@@ -31,11 +32,6 @@ export interface ClioAppKeybindings {
 	"clio-coder.model.select": true;
 	"clio-coder.model.cycleForward": true;
 	"clio-coder.model.cycleBackward": true;
-	"clio-coder.tool.expand": true;
-	"clio-coder.tool.expandAll": true;
-	"clio-coder.tool.liveOutput": true;
-	"clio-coder.thinking.expand": true;
-	"clio-coder.thinking.expandAll": true;
 	"clio-coder.editor.external": true;
 	"clio-coder.message.followUp": true;
 	"clio-coder.message.interrupt": true;
@@ -128,33 +124,9 @@ export const CLIO_APP_KEYBINDINGS = {
 		defaultKeys: "alt+k",
 		description: "Cycle to previous scoped model",
 	},
-	"clio-coder.tool.expand": {
+	"clio-coder.output.cycle": {
 		defaultKeys: "alt+o",
-		description:
-			"Fold or unfold the newest tool call or worker block between its one-line summary and full details, overriding the /output level for that block",
-	},
-	"clio-coder.tool.expandAll": {
-		// Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
-		// Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
-		defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
-		description:
-			"Fold or unfold every tool call and worker block at once, overriding the /output level; changing /output clears the overrides",
-	},
-	"clio-coder.tool.liveOutput": {
-		defaultKeys: "alt+p",
-		description: "Toggle streaming partial tool output in expanded tool bodies",
-	},
-	"clio-coder.thinking.expand": {
-		defaultKeys: "alt+r",
-		description:
-			"Toggle the latest thinking block between hidden marker and full body (no effect while /output verbose pins it open)",
-	},
-	"clio-coder.thinking.expandAll": {
-		// Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
-		// Alt+Shift+R as a distinct key event.
-		defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
-		description:
-			"Toggle all thinking blocks between hidden markers and full bodies, overriding the /output level; changing /output clears the overrides",
+		description: "Cycle output style: Compact, Standard, Detailed",
 	},
 	"clio-coder.editor.external": {
 		defaultKeys: "alt+g",

package/src/domains/providers/probe/fingerprint.ts

@@ -3,11 +3,15 @@ export interface NativeRuntimeFingerprint {
 	displayName: string;
 }
 
-async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response | null> {
+async function fetchWithTimeout(
+	url: string,
+	timeoutMs: number,
+	headers: Record<string, string>,
+): Promise<Response | null> {
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(), timeoutMs);
 	try {
-		return await fetch(url, { signal: controller.signal });
+		return await fetch(url, { signal: controller.signal, headers });
 	} catch {
 		return null;
 	} finally {
@@ -22,10 +26,13 @@ async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Respons
  * by doctor + configure wizard to steer users onto native runtimes for
  * resident-model lifecycle.
  */
-export async function fingerprintNativeRuntime(baseUrl: string): Promise<NativeRuntimeFingerprint | null> {
+export async function fingerprintNativeRuntime(
+	baseUrl: string,
+	headers: Record<string, string> = {},
+): Promise<NativeRuntimeFingerprint | null> {
 	const normalized = baseUrl.replace(/^ws:/u, "http:").replace(/^wss:/u, "https:");
 	const trimmed = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-	const greeting = await fetchWithTimeout(`${trimmed}/lmstudio-greeting`, 750);
+	const greeting = await fetchWithTimeout(`${trimmed}/lmstudio-greeting`, 750, headers);
 	if (greeting?.ok) {
 		try {
 			const data = (await greeting.json()) as { lmstudio?: unknown };
@@ -34,7 +41,7 @@ export async function fingerprintNativeRuntime(baseUrl: string): Promise<NativeR
 			// The exact JSON body is the fingerprint.
 		}
 	}
-	const lmStudioV0 = await fetchWithTimeout(`${trimmed}/api/v0/models`, 750);
+	const lmStudioV0 = await fetchWithTimeout(`${trimmed}/api/v0/models`, 750, headers);
 	if (lmStudioV0?.ok) {
 		try {
 			const data = (await lmStudioV0.json()) as { data?: unknown };
@@ -48,7 +55,7 @@ export async function fingerprintNativeRuntime(baseUrl: string): Promise<NativeR
 			// A malformed v0 body is not an LM Studio fingerprint.
 		}
 	}
-	const ollama = await fetchWithTimeout(`${trimmed}/api/version`, 750);
+	const ollama = await fetchWithTimeout(`${trimmed}/api/version`, 750, headers);
 	if (ollama?.ok) {
 		try {
 			const data = (await ollama.json()) as { version?: unknown };

package/src/domains/providers/probe/reasoning.ts

@@ -19,6 +19,7 @@ export interface ProbeReasoningOptions {
 	modelId: string;
 	timeoutMs: number;
 	apiKey?: string;
+	headers?: Record<string, string>;
 	signal?: AbortSignal;
 }
 
@@ -72,6 +73,7 @@ export async function probeOpenAICompatReasoning(opts: ProbeReasoningOptions): P
 
 	const headers: Record<string, string> = { "content-type": "application/json" };
 	if (opts.apiKey && opts.apiKey.length > 0) headers.authorization = `Bearer ${opts.apiKey}`;
+	Object.assign(headers, opts.headers);
 
 	const body = JSON.stringify({
 		model: opts.modelId,

package/src/domains/providers/runtimes/common/probe-helpers.ts

@@ -8,13 +8,27 @@ export interface OpenAIModelsResponse {
 	data?: Array<Record<string, unknown> & { id?: unknown; status?: unknown }>;
 }
 
-export async function probeUrl(url: string, ctx: ProbeContext, method: "GET" | "HEAD" = "GET"): Promise<ProbeResult> {
-	const base = { url, timeoutMs: ctx.httpTimeoutMs, method } as const;
+function bearerHeaders(ctx: ProbeContext): Record<string, string> {
+	return ctx.authToken ? { Authorization: `Bearer ${ctx.authToken}` } : {};
+}
+
+export async function probeUrl(
+	url: string,
+	ctx: ProbeContext,
+	method: "GET" | "HEAD" = "GET",
+	headers: Record<string, string> = bearerHeaders(ctx),
+): Promise<ProbeResult> {
+	const base = { url, timeoutMs: ctx.httpTimeoutMs, method, headers } as const;
 	return ctx.signal ? probeHttp({ ...base, signal: ctx.signal }) : probeHttp(base);
 }
 
-export async function probeOpenAIModels(base: string, ctx: ProbeContext, modelsPath = "/v1/models"): Promise<string[]> {
-	return (await probeOpenAIModelCatalog(base, ctx, modelsPath)).models;
+export async function probeOpenAIModels(
+	base: string,
+	ctx: ProbeContext,
+	modelsPath = "/v1/models",
+	headers: Record<string, string> = bearerHeaders(ctx),
+): Promise<string[]> {
+	return (await probeOpenAIModelCatalog(base, ctx, modelsPath, headers)).models;
 }
 
 export interface OpenAIModelCatalogProbe {
@@ -38,11 +52,12 @@ async function probeModelDetailRows(
 	base: string,
 	ctx: ProbeContext,
 	modelsPath: string,
+	headers: Record<string, string>,
 ): Promise<Map<string, Record<string, unknown>>> {
 	const rows = new Map<string, Record<string, unknown>>();
 	for (const detailPath of OPENAI_COMPAT_DETAIL_PATHS) {
 		if (detailPath === modelsPath) continue;
-		const opts = { url: `${base}${detailPath}`, timeoutMs: ctx.httpTimeoutMs } as const;
+		const opts = { url: `${base}${detailPath}`, timeoutMs: ctx.httpTimeoutMs, headers } as const;
 		const result = await (ctx.signal
 			? probeJson<OpenAIModelsResponse>({ ...opts, signal: ctx.signal })
 			: probeJson<OpenAIModelsResponse>(opts));
@@ -60,13 +75,14 @@ export async function probeOpenAIModelCatalog(
 	base: string,
 	ctx: ProbeContext,
 	modelsPath = "/v1/models",
+	headers: Record<string, string> = bearerHeaders(ctx),
 ): Promise<OpenAIModelCatalogProbe> {
-	const opts = { url: `${base}${modelsPath}`, timeoutMs: ctx.httpTimeoutMs } as const;
+	const opts = { url: `${base}${modelsPath}`, timeoutMs: ctx.httpTimeoutMs, headers } as const;
 	const result = await (ctx.signal
 		? probeJson<OpenAIModelsResponse>({ ...opts, signal: ctx.signal })
 		: probeJson<OpenAIModelsResponse>(opts));
 	if (!result.ok || !result.data?.data) return { models: [], modelCapabilities: {}, modelStates: {} };
-	const detail = await probeModelDetailRows(base, ctx, modelsPath);
+	const detail = await probeModelDetailRows(base, ctx, modelsPath, headers);
 	const models: string[] = [];
 	const modelCapabilities: Record<string, Partial<CapabilityFlags>> = {};
 	const modelStates: Record<string, ProbeModelStatus> = {};

package/src/domains/providers/runtimes/protocol/anthropic-compat.ts

@@ -49,6 +49,11 @@ function synthesizeAnthropicCompatModel(input: AnthropicCompatSynthesisInput): M
 export function makeAnthropicCompatRuntime(spec: AnthropicCompatSpec): RuntimeDescriptor {
 	const messagesPath = spec.messagesPath ?? "/v1/messages";
 	const modelsPath = spec.modelsPath ?? "/v1/models";
+	const headers = (target: TargetDescriptor, ctx: ProbeContext): Record<string, string> => ({
+		"anthropic-version": "2023-06-01",
+		...(ctx.authToken ? { "x-api-key": ctx.authToken } : {}),
+		...target.auth?.headers,
+	});
 	return {
 		id: spec.id,
 		displayName: spec.displayName,
@@ -61,12 +66,12 @@ export function makeAnthropicCompatRuntime(spec: AnthropicCompatSpec): RuntimeDe
 		async probe(target: TargetDescriptor, ctx: ProbeContext): Promise<ProbeResult> {
 			const base = targetBaseUrl(target);
 			if (!base) return { ok: false, error: "target has no url" };
-			return probeUrl(`${base}${messagesPath}`, ctx, "HEAD");
+			return probeUrl(`${base}${messagesPath}`, ctx, "HEAD", headers(target, ctx));
 		},
 		async probeModels(target: TargetDescriptor, ctx: ProbeContext): Promise<string[]> {
 			const base = targetBaseUrl(target);
 			if (!base) return [];
-			return probeOpenAIModels(base, ctx, modelsPath);
+			return probeOpenAIModels(base, ctx, modelsPath, headers(target, ctx));
 		},
 		synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
 			return synthesizeAnthropicCompatModel({

package/src/domains/providers/runtimes/protocol/openai-compat.ts

@@ -61,6 +61,10 @@ export function makeOpenAICompatRuntime(spec: OpenAICompatSpec): RuntimeDescript
 	// root and a target naming the `/v1` mount point has to be reduced to it. An
 	// `asIs` spec sends the URL verbatim, so it keeps whatever the user typed.
 	const probeBase = asIs ? targetBaseUrl : targetRootUrl;
+	const headers = (target: TargetDescriptor, ctx: ProbeContext): Record<string, string> => ({
+		...(ctx.authToken ? { Authorization: `Bearer ${ctx.authToken}` } : {}),
+		...target.auth?.headers,
+	});
 	return {
 		id: spec.id,
 		displayName: spec.displayName,
@@ -72,9 +76,9 @@ export function makeOpenAICompatRuntime(spec: OpenAICompatSpec): RuntimeDescript
 		async probe(target: TargetDescriptor, ctx: ProbeContext): Promise<ProbeResult> {
 			const base = probeBase(target);
 			if (!base) return { ok: false, error: "target has no url" };
-			const health = await probeUrl(`${base}${healthPath}`, ctx);
+			const health = await probeUrl(`${base}${healthPath}`, ctx, "GET", headers(target, ctx));
 			if (!health.ok) return health;
-			const catalog = await probeOpenAIModelCatalog(base, ctx, modelsPath);
+			const catalog = await probeOpenAIModelCatalog(base, ctx, modelsPath, headers(target, ctx));
 			const result: ProbeResult = { ...health };
 			if (catalog.models.length > 0) result.models = catalog.models;
 			if (Object.keys(catalog.modelStates).length > 0) result.modelStates = catalog.modelStates;
@@ -92,19 +96,21 @@ export function makeOpenAICompatRuntime(spec: OpenAICompatSpec): RuntimeDescript
 		async probeModels(target: TargetDescriptor, ctx: ProbeContext): Promise<string[]> {
 			const base = probeBase(target);
 			if (!base) return [];
-			return probeOpenAIModels(base, ctx, modelsPath);
+			return probeOpenAIModels(base, ctx, modelsPath, headers(target, ctx));
 		},
 		async probeReasoning(target: TargetDescriptor, modelId: string, ctx: ProbeContext): Promise<ReasoningProbeResult> {
 			const base = probeBase(target);
 			if (!base) return { reasoning: false, latencyMs: 0, error: "target has no url" };
 			const apiKeyEnv = target.auth?.apiKeyEnvVar;
-			const apiKey = apiKeyEnv && ctx.credentialsPresent.has(apiKeyEnv) ? process.env[apiKeyEnv] : undefined;
+			const apiKey =
+				ctx.authToken ?? (apiKeyEnv && ctx.credentialsPresent.has(apiKeyEnv) ? process.env[apiKeyEnv] : undefined);
 			const probeOpts: Parameters<typeof probeOpenAICompatReasoning>[0] = {
 				baseUrl: base,
 				modelId,
 				timeoutMs: Math.max(ctx.httpTimeoutMs, 8000),
 			};
 			if (apiKey) probeOpts.apiKey = apiKey;
+			if (target.auth?.headers) probeOpts.headers = target.auth.headers;
 			if (ctx.signal) probeOpts.signal = ctx.signal;
 			return probeOpenAICompatReasoning(probeOpts);
 		},

package/src/interactive/application-controller.ts

@@ -6,16 +6,12 @@ import { isEscapeKey, type OverlayState, overlayOwnsInput } from "./overlay-life
 export const APPLICATION_DOUBLE_TAP_MS = 500;
 
 const CLOSED_ACTION_ORDER = [
+	"clio-coder.output.cycle",
 	"clio-coder.notifications.dismiss",
-	"clio-coder.tool.expand",
-	"clio-coder.tool.expandAll",
-	"clio-coder.tool.liveOutput",
 	"clio-coder.editor.external",
 	"clio-coder.message.followUp",
 	"clio-coder.message.interrupt",
 	"clio-coder.message.dequeue",
-	"clio-coder.thinking.expand",
-	"clio-coder.thinking.expandAll",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
 export const GLOBAL_ACTION_ORDER = [
@@ -108,10 +104,6 @@ export interface ApplicationControllerDeps {
 	listNotifications: () => ReadonlyArray<{ id: string }>;
 	dismissNotification: (id: string) => void;
 	dismissAllNotifications: () => void;
-	toggleLastToolExpanded: () => boolean;
-	toggleAllToolsExpanded: () => boolean;
-	toggleLastThinking: () => boolean;
-	toggleAllThinking: () => boolean;
 	shutdownDisposers: ReadonlyArray<() => void>;
 	/** Settle the last presentation mutation into an accepted/drained frame. */
 	beforeStopUi?: () => Promise<void>;
@@ -145,8 +137,6 @@ export interface ApplicationController {
 	handleInput(data: string): ApplicationInputResult;
 	handleCtrlC(): void;
 	dismissNotifications(): void;
-	toggleToolExpansion(): void;
-	toggleThinkingExpansion(): void;
 	shutdown(): Promise<void>;
 }
 
@@ -163,8 +153,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	let shuttingDown = false;
 	let lastCtrlCAt = 0;
 	let lastNotificationDismissAt = 0;
-	let lastToolExpandAt = 0;
-	let lastThinkingExpandAt = 0;
 
 	const isDoubleTap = (lastAt: number, now: number): boolean => lastAt > 0 && now - lastAt <= APPLICATION_DOUBLE_TAP_MS;
 
@@ -346,22 +334,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 		if (first) deps.dismissNotification(first.id);
 	};
 
-	const toggleToolExpansion = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastToolExpandAt, now);
-		lastToolExpandAt = now;
-		const changed = doubleTap ? deps.toggleAllToolsExpanded() : deps.toggleLastToolExpanded();
-		if (changed) deps.requestRender();
-	};
-
-	const toggleThinkingExpansion = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastThinkingExpandAt, now);
-		lastThinkingExpandAt = now;
-		const changed = doubleTap ? deps.toggleAllThinking() : deps.toggleLastThinking();
-		if (changed) deps.requestRender();
-	};
-
 	const handleInput = (data: string): ApplicationInputResult => {
 		const initialOverlayState = deps.getOverlayState();
 		if (overlayOwnsInput(initialOverlayState) && deps.leaderKeys.isPending()) deps.leaderKeys.reset();
@@ -427,8 +399,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 		handleInput,
 		handleCtrlC,
 		dismissNotifications,
-		toggleToolExpansion,
-		toggleThinkingExpansion,
 		shutdown,
 	};
 }