@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/domains/providers/auth/storage.ts

@@ -1,6 +1,6 @@
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-
 import type { OAuthLoginCallbacks } from "../../../engine/oauth.js";
+import type { AuthOperationOptions } from "../../../engine/types.js";
 import type { RuntimeAuth, RuntimeDescriptor } from "../types/runtime-descriptor.js";
 import type { TargetDescriptor } from "../types/target-descriptor.js";
 
@@ -39,7 +39,10 @@ export interface LockResult<T> {
 
 export interface AuthStorageBackend {
 	withLock<T>(fn: (current: string | undefined) => LockResult<T>): T;
-	withLockAsync<T>(fn: (current: string | undefined) => Promise<LockResult<T>>): Promise<T>;
+	withLockAsync<T>(
+		fn: (current: string | undefined) => Promise<LockResult<T>>,
+		options?: AuthOperationOptions,
+	): Promise<T>;
 	/** Where the store lives, for error text. Absent for non-file backends. */
 	describe?(): string;
 }
@@ -246,7 +249,12 @@ function serializeStorageData(data: AuthStorageData): string {
 	});
 }
 
-export function resolveAuthTarget(target: TargetDescriptor, runtime: RuntimeDescriptor): AuthTarget {
+export type RuntimeAuthMetadata = Pick<
+	RuntimeDescriptor,
+	"id" | "auth" | "tier" | "credentialsEnvVar" | "oauthProviderId"
+>;
+
+export function resolveAuthTarget(target: TargetDescriptor, runtime: RuntimeAuthMetadata): AuthTarget {
 	const providerId =
 		target.auth?.oauthProfile?.trim() || target.auth?.apiKeyRef?.trim() || runtime.oauthProviderId || runtime.id;
 	const authTarget: AuthTarget = {
@@ -268,7 +276,7 @@ export function resolveRuntimeAuthTarget(runtime: RuntimeDescriptor): AuthTarget
 	return target;
 }
 
-export function targetRequiresAuth(target: TargetDescriptor, runtime: RuntimeDescriptor): boolean {
+export function targetRequiresAuth(target: TargetDescriptor, runtime: RuntimeAuthMetadata): boolean {
 	if (runtime.auth === "oauth") return true;
 	if (runtime.auth !== "api-key") return false;
 	if (target.auth?.apiKeyEnvVar || target.auth?.apiKeyRef || target.auth?.oauthProfile) return true;
@@ -371,6 +379,34 @@ export class AuthStorage {
 		delete this.data[providerId];
 	}
 
+	renameProvider(fromProviderId: string, toProviderId: string, options: { keepSource?: boolean } = {}): void {
+		this.backend.withLock((current) => {
+			const read = readStorageData(current);
+			const source = read.data[fromProviderId];
+			// A rename with nothing to rename writes nothing, so a file this parser
+			// could not fully read is in no danger from it. Refusing on damage before
+			// establishing that turned a hand-edited credentials.yaml into a
+			// permanent `clio-coder upgrade` failure: the lmstudio-native migration
+			// calls this on every upgrade, and it failed even on homes that had never
+			// held an lmstudio-native credential.
+			if (!source) {
+				// Adopt the fresh view only when it is the whole file. A damaged read
+				// yields an empty view, and adopting that would report stored
+				// credentials as gone.
+				if (read.damage === null) this.data = read.data;
+				return { result: undefined };
+			}
+			// Past here the rename rewrites the whole file, so a partially readable
+			// one would be serialized back with the unread entries dropped.
+			if (read.damage !== null) throw new AuthStorageDamagedError(read.damage, this.backend.describe?.());
+			if (!read.data[toProviderId]) read.data[toProviderId] = source;
+			if (options.keepSource !== true) delete read.data[fromProviderId];
+			this.data = read.data;
+			this.damage = null;
+			return { result: undefined, next: serializeStorageData(read.data) };
+		});
+	}
+
 	listStored(): ReadonlyArray<{ providerId: string; type: AuthCredential["type"]; updatedAt: string }> {
 		return Object.entries(this.data)
 			.map(([providerId, credential]) => ({
@@ -486,41 +522,51 @@ export class AuthStorage {
 
 	private async refreshOAuthCredentialWithLock(
 		providerId: string,
+		signal: AbortSignal,
 	): Promise<{ apiKey: string; credential: OAuthCredential } | null> {
-		return this.backend.withLockAsync(async (current) => {
-			const read = readStorageData(current);
-			if (read.damage !== null) {
-				this.damage = read.damage;
-				throw new AuthStorageDamagedError(read.damage, this.backend.describe?.());
-			}
-			const currentData = read.data;
-			this.data = currentData;
-			this.damage = null;
-			const stored = currentData[providerId];
-			if (stored?.type !== "oauth") {
-				return { result: null };
-			}
-			if (Date.now() < stored.expires) {
-				return { result: { apiKey: await getOAuthApiKey(providerId, stored), credential: stored } };
-			}
-			const refreshed = await refreshOAuthCredentials(providerId, stored);
-			const next: OAuthCredential = {
-				type: "oauth",
-				...refreshed,
-				updatedAt: nowIso(),
-			};
-			const merged: AuthStorageData = { ...currentData, [providerId]: next };
-			this.data = merged;
-			return {
-				result: { apiKey: await getOAuthApiKey(providerId, next), credential: next },
-				next: serializeStorageData(merged),
-			};
-		});
+		let latestData: AuthStorageData | undefined;
+		const result = await this.backend.withLockAsync(
+			async (current) => {
+				const read = readStorageData(current);
+				if (read.damage !== null) {
+					this.damage = read.damage;
+					throw new AuthStorageDamagedError(read.damage, this.backend.describe?.());
+				}
+				const currentData = read.data;
+				latestData = currentData;
+				const stored = currentData[providerId];
+				if (stored?.type !== "oauth") {
+					return { result: null };
+				}
+				if (Date.now() < stored.expires) {
+					return { result: { apiKey: await getOAuthApiKey(providerId, stored), credential: stored } };
+				}
+				const refreshed = await refreshOAuthCredentials(providerId, stored, signal);
+				const next: OAuthCredential = {
+					type: "oauth",
+					...refreshed,
+					updatedAt: nowIso(),
+				};
+				const merged: AuthStorageData = { ...currentData, [providerId]: next };
+				latestData = merged;
+				return {
+					result: { apiKey: await getOAuthApiKey(providerId, next), credential: next },
+					next: serializeStorageData(merged),
+				};
+			},
+			{ signal },
+		);
+		// Adopt the view only after the backend has committed it. Pi 0.84's
+		// CredentialStore.modify pattern prevents a cancellation between refresh
+		// and persistence from making memory advertise a token disk never received.
+		if (latestData) this.data = latestData;
+		this.damage = null;
+		return result;
 	}
 
 	async resolveApiKey(
 		providerId: string,
-		opts?: { targetId?: string; explicitEnvVar?: string; includeFallback?: boolean },
+		opts?: { targetId?: string; explicitEnvVar?: string; includeFallback?: boolean; signal?: AbortSignal },
 	): Promise<AuthResolution> {
 		if (opts?.targetId) {
 			const override = this.runtimeOverrides.get(opts.targetId);
@@ -571,7 +617,10 @@ export class AuthStorage {
 				};
 			}
 			try {
-				const refreshed = await this.refreshOAuthCredentialWithLock(providerId);
+				const refreshed = await this.refreshOAuthCredentialWithLock(
+					providerId,
+					opts?.signal ?? new AbortController().signal,
+				);
 				if (refreshed) {
 					return {
 						providerId,
@@ -582,7 +631,8 @@ export class AuthStorage {
 						apiKey: refreshed.apiKey,
 					};
 				}
-			} catch {
+			} catch (error) {
+				if (opts?.signal?.aborted) throw opts.signal.reason ?? error;
 				// A refusal already recorded its reason on this.damage; a refresh that
 				// failed for any other reason is answered by re-reading the store below.
 				this.reload();
@@ -642,9 +692,18 @@ export class AuthStorage {
 		};
 	}
 
-	resolveForTarget(target: AuthTarget, opts?: { includeFallback?: boolean }): Promise<AuthResolution> {
-		const args: { targetId?: string; explicitEnvVar?: string; includeFallback?: boolean } = {};
+	resolveForTarget(
+		target: AuthTarget,
+		opts?: { includeFallback?: boolean; signal?: AbortSignal },
+	): Promise<AuthResolution> {
+		const args: {
+			targetId?: string;
+			explicitEnvVar?: string;
+			includeFallback?: boolean;
+			signal?: AbortSignal;
+		} = {};
 		if (opts?.includeFallback !== undefined) args.includeFallback = opts.includeFallback;
+		if (opts?.signal !== undefined) args.signal = opts.signal;
 		if (target.explicitEnvVar) args.explicitEnvVar = target.explicitEnvVar;
 		if (target.targetId) args.targetId = target.targetId;
 		return this.resolveApiKey(target.providerId, args);

package/src/domains/providers/capabilities.ts

@@ -4,10 +4,11 @@ import type { CapabilityFlags } from "./types/capability-flags.js";
  * Layer capability sources onto a runtime's defaults, weakest first.
  *
  * A probe is what the server currently reports; a knowledge-base entry is what
- * an operator wrote down about a specific model. The written entry wins, because
- * a hand-authored `model-catalog.d` file exists precisely to correct metadata a
- * server gets wrong, and losing to the probe would leave no per-model escape
- * hatch at all. A target-level override still outranks both.
+ * an operator wrote down about a specific model. The written entry wins for
+ * descriptive capabilities because a hand-authored `model-catalog.d` file is
+ * the per-model escape hatch for incorrect server metadata. Context and output
+ * limits are deployment facts, so a live probe overrides the model's maximums.
+ * A target-level override still outranks every source.
  */
 export function mergeCapabilities(
 	base: CapabilityFlags,
@@ -18,10 +19,17 @@ export function mergeCapabilities(
 	const merged: Record<string, unknown> = { ...base };
 	applyLayer(merged, probe);
 	applyLayer(merged, kb);
+	applyDeploymentLimits(merged, probe);
 	applyLayer(merged, userOverride);
 	return merged as unknown as CapabilityFlags;
 }
 
+function applyDeploymentLimits(target: Record<string, unknown>, probe: Partial<CapabilityFlags> | null): void {
+	if (!probe) return;
+	if (probe.contextWindow !== undefined) target.contextWindow = probe.contextWindow;
+	if (probe.maxTokens !== undefined) target.maxTokens = probe.maxTokens;
+}
+
 /**
  * Whether a model may drive an agent role (orchestrator, dispatched worker).
  *

package/src/domains/providers/contract.ts

@@ -1,8 +1,9 @@
 import type { OAuthLoginCallbacks } from "../../engine/oauth.js";
+import type { AuthOperationOptions } from "../../engine/types.js";
 import type { AuthCredential, AuthResolution, AuthStatus } from "./auth/index.js";
 import type { CapabilityFlags } from "./types/capability-flags.js";
 import type { KnowledgeBase } from "./types/knowledge-base.js";
-import type { ProbeModelStatus, RuntimeDescriptor } from "./types/runtime-descriptor.js";
+import type { ProbeModelStatus, ProbeSurfaceMap, RuntimeDescriptor } from "./types/runtime-descriptor.js";
 import type { TargetDescriptor } from "./types/target-descriptor.js";
 
 /**
@@ -54,6 +55,8 @@ export interface TargetStatus {
 	probeModelId?: string | null;
 	/** Diagnostic notes from the last probe (e.g. wire-model mismatch warnings). */
 	probeNotes?: ReadonlyArray<string>;
+	/** Inference and management surfaces selected by the last successful probe. */
+	probeSurfaces?: Readonly<ProbeSurfaceMap>;
 	/** Ids returned by the last successful probeModels() call. */
 	discoveredModels: ReadonlyArray<string>;
 	/**
@@ -85,8 +88,12 @@ export interface ProvidersContract {
 	/** Live liveness + probeModels sweep. */
 	probeAllLive(): Promise<void>;
 
-	/** Probe a single target live. Null when the id is not in settings.targets. */
-	probeTarget(id: string): Promise<TargetStatus | null>;
+	/**
+	 * Probe a single target live. Null when the id is not in settings.targets.
+	 * `reasoning: false` skips an inference-based reasoning-capability probe while
+	 * retaining the target's liveness and model-catalog checks.
+	 */
+	probeTarget(id: string, options?: { reasoning?: boolean }): Promise<TargetStatus | null>;
 
 	/** Clear in-memory live connection state for a configured target. */
 	disconnectTarget(id: string): TargetStatus | null;
@@ -114,7 +121,11 @@ export interface ProvidersContract {
 	 */
 	auth: {
 		statusForTarget(target: TargetDescriptor, runtime: RuntimeDescriptor): AuthStatus;
-		resolveForTarget(target: TargetDescriptor, runtime: RuntimeDescriptor): Promise<AuthResolution>;
+		resolveForTarget(
+			target: TargetDescriptor,
+			runtime: RuntimeDescriptor,
+			options?: AuthOperationOptions,
+		): Promise<AuthResolution>;
 		getStored(providerId: string): AuthCredential | null;
 		listStored(): ReadonlyArray<{ providerId: string; type: AuthCredential["type"]; updatedAt: string }>;
 		setApiKey(providerId: string, key: string): void;

package/src/domains/providers/extension.ts

@@ -157,6 +157,7 @@ export interface ProbeMerge {
 	probeModelCapabilities: NonNullable<TargetStatus["probeModelCapabilities"]> | null;
 	probeModelId: NonNullable<TargetStatus["probeModelId"]> | null;
 	probeNotes?: ReadonlyArray<string>;
+	probeSurfaces?: NonNullable<TargetStatus["probeSurfaces"]>;
 }
 
 /**
@@ -185,6 +186,7 @@ export function mergeProbeResult(
 			: ((preservePrevious ? previous.probeModelId : null) ?? null);
 	const probeNotes =
 		probe?.notes && probe.notes.length > 0 ? probe.notes : preservePrevious ? previous.probeNotes : undefined;
+	const probeSurfaces = probe?.surfaces ?? (preservePrevious ? previous.probeSurfaces : undefined);
 	const discoveredModels = uniqueModels(
 		probe?.models ?? (preservePrevious ? previous.discoveredModels : undefined) ?? desc.knownModels ?? [],
 	);
@@ -198,6 +200,7 @@ export function mergeProbeResult(
 		probeModelId,
 	};
 	if (probeNotes && probeNotes.length > 0) merge.probeNotes = probeNotes;
+	if (probeSurfaces && Object.keys(probeSurfaces).length > 0) merge.probeSurfaces = probeSurfaces;
 	return merge;
 }
 
@@ -282,6 +285,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				discoveredModelStates: previous?.discoveredModelStates ?? null,
 			};
 			if (previous?.probeNotes && previous.probeNotes.length > 0) out.probeNotes = previous.probeNotes;
+			if (previous?.probeSurfaces) out.probeSurfaces = previous.probeSurfaces;
 			return out;
 		}
 		const availability = availabilityFor(desc, target, authStatusFor);
@@ -315,10 +319,15 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			discoveredModelStates: merge.discoveredModelStates,
 		};
 		if (merge.probeNotes && merge.probeNotes.length > 0) out.probeNotes = merge.probeNotes;
+		if (merge.probeSurfaces) out.probeSurfaces = merge.probeSurfaces;
 		return out;
 	}
 
-	async function probeTargetInternal(target: TargetDescriptor, live: boolean): Promise<TargetStatus> {
+	async function probeTargetInternal(
+		target: TargetDescriptor,
+		live: boolean,
+		options?: { reasoning?: boolean },
+	): Promise<TargetStatus> {
 		const previous = statuses.get(target.id);
 		const desc = registry.get(target.runtime);
 		if (!desc) {
@@ -347,7 +356,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				// model discovery is best-effort; keep probe as-is.
 			}
 		}
-		if (probeResult.ok && typeof desc.probeReasoning === "function") {
+		if (probeResult.ok && options?.reasoning !== false && typeof desc.probeReasoning === "function") {
 			const settings = readConfig();
 			const orchestratorTarget = settings.orchestrator.target === target.id ? settings.orchestrator.model : null;
 			const candidateModelId = orchestratorTarget ?? target.defaultModel ?? null;
@@ -460,11 +469,11 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		},
 		probeAll,
 		probeAllLive,
-		async probeTarget(id) {
+		async probeTarget(id, options) {
 			const settings = readConfig();
 			const target = settings.targets.find((ep) => ep.id === id);
 			if (!target) return null;
-			return probeTargetInternal(target, true);
+			return probeTargetInternal(target, true, options);
 		},
 		disconnectTarget(id) {
 			const settings = readConfig();
@@ -492,11 +501,14 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				}
 				return authStore.statusForTarget(resolveAuthTarget(target, runtime), { includeFallback: false });
 			},
-			resolveForTarget(target, runtime) {
+			resolveForTarget(target, runtime, options) {
 				if (!targetRequiresAuth(target, runtime)) {
 					return Promise.resolve(authNotRequiredStatus(resolveAuthTarget(target, runtime).providerId));
 				}
-				return authStore.resolveForTarget(resolveAuthTarget(target, runtime), { includeFallback: false });
+				return authStore.resolveForTarget(resolveAuthTarget(target, runtime), {
+					includeFallback: false,
+					...(options?.signal ? { signal: options.signal } : {}),
+				});
 			},
 			getStored(providerId) {
 				return authStore.get(providerId) ?? null;

package/src/domains/providers/model-runtime-capabilities.ts

@@ -325,7 +325,12 @@ export function effectiveThinkingLevel(
 	const fallback = available[0] ?? "off";
 	if (!configured) return fallback;
 	if (available.includes(configured)) return configured;
-	if ((configured === "high" || configured === "xhigh") && available.includes("high")) return "high";
+	// Catalog effort maps intentionally stop at xhigh; `max` must clamp to that
+	// supported ceiling instead of falling through to the generic low fallback.
+	if (configured === "max" && available.includes("xhigh")) return "xhigh";
+	if ((configured === "high" || configured === "xhigh" || configured === "max") && available.includes("high")) {
+		return "high";
+	}
 	if (configured === "medium" && available.includes("medium")) return "medium";
 	if (configured !== "off" && available.includes("low")) return "low";
 	if (configured === "off" && !available.includes("off") && available.includes("low")) return "low";
@@ -359,7 +364,9 @@ export function thinkingLevelFromChoiceLabel(value: string): ThinkingLevel | nul
 	return null;
 }
 
-function acceptsBudgetTokensField(input: Pick<ResolveRuntimeCapabilitiesInput, "apiFamily" | "capabilities">): boolean {
+function acceptsBudgetTokensField(
+	input: Pick<ResolveRuntimeCapabilitiesInput, "runtimeId" | "apiFamily" | "capabilities">,
+): boolean {
 	const format = input.capabilities.thinkingFormat;
 	if (format === "anthropic-extended") {
 		return (
@@ -369,12 +376,13 @@ function acceptsBudgetTokensField(input: Pick<ResolveRuntimeCapabilitiesInput, "
 		);
 	}
 	if (input.apiFamily !== "openai-completions") return false;
+	if (input.runtimeId === "vllm") return true;
 	return format === "openrouter" || format === "zai";
 }
 
 function resolveBudgetEnforcement(
 	mechanism: ThinkingMechanism,
-	input: Pick<ResolveRuntimeCapabilitiesInput, "apiFamily" | "capabilities">,
+	input: Pick<ResolveRuntimeCapabilitiesInput, "runtimeId" | "apiFamily" | "capabilities">,
 ): ThinkingBudgetEnforcement {
 	if (mechanism !== "budget-tokens") return "none";
 	return acceptsBudgetTokensField(input) ? "enforced" : "informational";
@@ -483,7 +491,7 @@ function resolveThinkingCapability(
  * while llama.cpp did the reverse. Sending the wrong spelling reads as "no
  * preference" to the server, so the model keeps reasoning at every dial.
  */
-const REASONING_EFFORT_ON_OFF_RUNTIMES: ReadonlySet<string> = new Set(["lmstudio-native", "lmstudio"]);
+const REASONING_EFFORT_ON_OFF_RUNTIMES: ReadonlySet<string> = new Set(["lmstudio"]);
 
 /** `none` is LM Studio's documented off value; on-off models have no finer dial than `low`. */
 function onOffReasoningEffort(thinkingActive: boolean): string {
@@ -499,6 +507,9 @@ function resolveRequestCapability(
 	if (thinking.mechanism === "effort-levels" && thinking.effort) {
 		request.reasoningEffort = thinking.effort;
 	}
+	if (thinking.mechanism === "effort-levels" && !thinking.thinkingActive) {
+		request.chatTemplateKwargs = { ...(request.chatTemplateKwargs ?? {}), enable_thinking: false };
+	}
 	if (thinking.mechanism === "budget-tokens" && thinking.budgetTokens !== undefined) {
 		request.budgetTokens = thinking.budgetTokens;
 	}