@2tle/pi-provider-manager 0.1.1 → 0.1.2

package/index.ts

@@ -1,395 +1,47 @@
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
-import type { RefreshModelsContext } from "@earendil-works/pi-ai";
-import { DynamicBorder, keyHint, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { Container, CURSOR_MARKER, getKeybindings, Input, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { keyHint } from "@earendil-works/pi-coding-agent";
+import { loadSecrets, loadState, saveSecrets, saveState, validateBaseUrl, validateProviderId } from "./src/config.js";
+import { createManagedProvider } from "./src/provider.js";
+import { SecretInputDialog } from "./src/ui.js";
+import { REFRESH_TIMEOUT_MS, type StoredProvider, type StoredSecrets, type StoredState } from "./src/types.js";
 
-const CONFIG_PATH = join(homedir(), ".pi", "agent", "pi-provider-manager.json");
-const SECRETS_PATH = join(homedir(), ".pi", "agent", "pi-provider-manager-secrets.json");
-const API = "openai-completions" as const;
-const DEFAULT_CONTEXT_WINDOW = 128_000;
-const DEFAULT_MAX_TOKENS = 16_384;
-const REFRESH_TIMEOUT_MS = 30_000;
-const PI_THINKING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
-type PiThinkingLevel = (typeof PI_THINKING_LEVELS)[number];
+// Preserve the helper's existing public export for consumers and tests.
+export { maskInputLine } from "./src/ui.js";
 
-interface StoredProvider {
-	id: string;
-	name: string;
-	baseUrl: string;
-}
-
-interface StoredState {
-	providers: StoredProvider[];
-}
-
-interface StoredSecrets {
-	apiKeys: Record<string, string>;
-}
-
-interface ProviderModelConfig {
-	id: string;
-	name: string;
-	api: typeof API;
-	reasoning: boolean;
-	thinkingLevelMap?: Partial<Record<PiThinkingLevel, string | null>>;
-	compat?: {
-		supportsReasoningEffort: boolean;
-	};
-	input: ("text" | "image")[];
-	cost: {
-		input: number;
-		output: number;
-		cacheRead: number;
-		cacheWrite: number;
-	};
-	contextWindow: number;
-	maxTokens: number;
-}
-
-interface ManagedProviderConfig {
-	name: string;
-	baseUrl: string;
-	api: typeof API;
-	apiKey: string;
-	models: ProviderModelConfig[];
-	refreshModels(context: RefreshModelsContext): Promise<ProviderModelConfig[]>;
-}
-
-interface OpenAIModelPayload {
-	id?: unknown;
-	name?: unknown;
-	context_window?: unknown;
-	contextWindow?: unknown;
-	max_tokens?: unknown;
-	maxTokens?: unknown;
-	reasoning?: unknown;
-	supports_reasoning?: unknown;
-	supports_reasoning_effort?: unknown;
-	reasoning_efforts?: unknown;
-	input?: unknown;
-	cost?: unknown;
-	capabilities?: unknown;
-}
-
-interface OpenAIModelsPayload {
-	data?: unknown;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
-}
-
-function asNonEmptyString(value: unknown): string | undefined {
-	return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function asPositiveNumber(value: unknown, fallback: number): number {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
-}
-
-function getReasoningEfforts(value: unknown): Set<string> {
-	if (!Array.isArray(value)) return new Set();
-	return new Set(value.flatMap((item) => {
-		if (typeof item === "string") return [item.toLowerCase()];
-		const effort = asNonEmptyString(asRecord(item)?.value);
-		return effort ? [effort.toLowerCase()] : [];
-	}));
-}
-
-function thinkingLevelMap(efforts: Set<string>): Partial<Record<PiThinkingLevel, string | null>> | undefined {
-	if (efforts.size === 0) return undefined;
-
-	const map: Partial<Record<PiThinkingLevel, string | null>> = {};
-	for (const level of PI_THINKING_LEVELS) {
-		if (efforts.has(level)) map[level] = level;
-		else if (level === "max" && efforts.has("ultra")) map[level] = "ultra";
-		else map[level] = null;
-	}
-	return map;
-}
-
-function normalizeBaseUrl(value: string): string {
-	return value.trim().replace(/\/+$/, "");
-}
-
-function validateProviderId(id: string): void {
-	if (!/^[a-z0-9][a-z0-9._-]*$/.test(id)) {
-		throw new Error("Provider ID may contain only lowercase letters, numbers, '.', '_' or '-'.");
-	}
-}
-
-function validateBaseUrl(value: string): string {
-	const baseUrl = normalizeBaseUrl(value);
-	let parsed: URL;
-	try {
-		parsed = new URL(baseUrl);
-	} catch {
-		throw new Error("Base URL is not a valid URL.");
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-		throw new Error("Base URL must use the http or https protocol.");
-	}
-	return baseUrl;
-}
-
-function modelsUrl(baseUrl: string): string {
-	return new URL("models", `${normalizeBaseUrl(baseUrl)}/`).toString();
-}
-
-async function loadState(): Promise<StoredState> {
-	try {
-		const raw = await readFile(CONFIG_PATH, "utf8");
-		const parsed = asRecord(JSON.parse(raw));
-		const providers = Array.isArray(parsed?.providers) ? parsed.providers : [];
-		const normalized: StoredProvider[] = [];
-		for (const item of providers) {
-			const record = asRecord(item);
-			const id = asNonEmptyString(record?.id);
-			const name = asNonEmptyString(record?.name);
-			const baseUrl = asNonEmptyString(record?.baseUrl);
-			if (!id || !name || !baseUrl) continue;
-			try {
-				validateProviderId(id);
-				normalized.push({ id, name, baseUrl: validateBaseUrl(baseUrl) });
-			} catch {
-				// Ignore malformed entries so one broken provider does not prevent startup.
-			}
-		}
-		return { providers: normalized };
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-			return { providers: [] };
-		}
-		throw new Error(`Unable to read provider configuration: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-async function loadSecrets(): Promise<StoredSecrets> {
-	try {
-		const raw = await readFile(SECRETS_PATH, "utf8");
-		const parsed = asRecord(JSON.parse(raw));
-		const apiKeys: Record<string, string> = {};
-		const rawApiKeys = asRecord(parsed?.apiKeys);
-		for (const [id, value] of Object.entries(rawApiKeys ?? {})) {
-			if (typeof value === "string" && value.trim()) apiKeys[id] = value;
-		}
-		return { apiKeys };
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-			return { apiKeys: {} };
-		}
-		throw new Error(`Unable to read provider API keys: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-async function saveJsonFile(path: string, value: object): Promise<void> {
-	await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-	const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-	const content = `${JSON.stringify(value, null, 2)}\n`;
-	try {
-		await writeFile(temporaryPath, content, { encoding: "utf8", mode: 0o600 });
-		await chmod(temporaryPath, 0o600);
-		await rename(temporaryPath, path);
-	} finally {
-		await unlink(temporaryPath).catch(() => undefined);
-	}
-}
-
-async function saveState(state: StoredState): Promise<void> {
-	await saveJsonFile(CONFIG_PATH, state);
-}
-
-async function saveSecrets(secrets: StoredSecrets): Promise<void> {
-	await saveJsonFile(SECRETS_PATH, secrets);
-}
-
-function modelFromPayload(
-	provider: StoredProvider,
-	payload: OpenAIModelPayload,
-): ProviderModelConfig | undefined {
-	const id = asNonEmptyString(payload.id);
-	if (!id) return undefined;
-
-	const capabilities = asRecord(payload.capabilities);
-	const cost = asRecord(payload.cost);
-	const inputModalities = Array.isArray(payload.input)
-		? payload.input
-		: capabilities?.input_modalities;
-	const input: ("text" | "image")[] =
-		Array.isArray(inputModalities) && inputModalities.includes("image") ? ["text", "image"] : ["text"];
-	const efforts = getReasoningEfforts(payload.reasoning_efforts ?? capabilities?.reasoning_effort);
-	const reasoning =
-		payload.reasoning === true ||
-		payload.supports_reasoning === true ||
-		payload.supports_reasoning_effort === true ||
-		capabilities?.supports_reasoning === true ||
-		efforts.size > 0;
-
-	return {
-		id,
-		name: asNonEmptyString(payload.name) ?? id,
-		api: API,
-		reasoning,
-		...(reasoning ? {
-			thinkingLevelMap: thinkingLevelMap(efforts),
-			compat: { supportsReasoningEffort: true },
-		} : {}),
-		input,
-		cost: {
-			input: asPositiveNumber(cost?.input, 0),
-			output: asPositiveNumber(cost?.output, 0),
-			cacheRead: asPositiveNumber(cost?.cacheRead, 0),
-			cacheWrite: asPositiveNumber(cost?.cacheWrite, 0),
-		},
-		contextWindow: asPositiveNumber(
-			payload.context_window ?? payload.contextWindow ?? capabilities?.context_length,
-			DEFAULT_CONTEXT_WINDOW,
-		),
-		maxTokens: asPositiveNumber(
-			payload.max_tokens ?? payload.maxTokens ?? capabilities?.max_output_tokens,
-			DEFAULT_MAX_TOKENS,
-		),
-	};
-}
-
-async function fetchProviderModels(
-	provider: StoredProvider,
-	context: RefreshModelsContext,
-	getApiKey: () => string | undefined,
-): Promise<ProviderModelConfig[]> {
-	const apiKey = getApiKey();
-	if (!apiKey) {
-		throw new Error(`API key for provider '${provider.id}' is not configured.`);
-	}
-
-	const response = await fetch(modelsUrl(provider.baseUrl), {
-		signal: context.signal,
-		headers: {
-			Accept: "application/json",
-			Authorization: `Bearer ${apiKey}`,
-		},
-	});
-
-	if (!response.ok) {
-		throw new Error(`Failed to fetch model list (${response.status} ${response.statusText})`);
-	}
-
-	const payload = (await response.json()) as OpenAIModelsPayload | unknown[];
-	const data = Array.isArray(payload) ? payload : asRecord(payload)?.data;
-	if (!Array.isArray(data)) {
-		throw new Error("Model list response does not contain a data array.");
-	}
-
-	return data
-		.map((item) => {
-			const record = asRecord(item);
-			return record ? modelFromPayload(provider, record as OpenAIModelPayload) : undefined;
-		})
-		.filter((model): model is ProviderModelConfig => model !== undefined);
+function parseArgs(args: string): string[] {
+	return args.trim().split(/\s+/).filter(Boolean);
 }
 
-function createManagedProvider(
-	config: StoredProvider,
-	getApiKey: () => string | undefined,
-): ManagedProviderConfig {
-	return {
-		name: config.name,
-		baseUrl: config.baseUrl,
-		api: API,
-		// The API key is held outside the regular provider config and is only
-		// read when the provider is registered or refreshed.
-		apiKey: getApiKey() ?? "local",
-		models: [],
-		refreshModels: (context) => fetchProviderModels(config, context, getApiKey),
-	};
+function formatTokenCount(value: number | undefined): string {
+	return value === undefined ? "API/default" : value.toLocaleString();
 }
 
-export function maskInputLine(line: string): string {
-	const prompt = line.startsWith("> ") ? "> " : "";
-	let result = "";
-	for (let index = prompt.length; index < line.length; ) {
-		// Keep Input's zero-width APC cursor marker intact. Masking only CSI/SGR
-		// codes previously turned the marker bytes into visible bullets.
-		if (line.startsWith(CURSOR_MARKER, index)) {
-			result += CURSOR_MARKER;
-			index += CURSOR_MARKER.length;
-			continue;
-		}
-
-		if (line[index] === "\x1b") {
-			const ansi = line.slice(index).match(/^\x1b\[[0-9;?]*[ -/]*[@-~]/)?.[0];
-			if (ansi) {
-				result += ansi;
-				index += ansi.length;
-				continue;
-			}
-		}
-
-		const character = line[index++];
-		result += /\s/u.test(character) ? character : "*";
-	}
-	return prompt + result;
+function parseTokenCount(value: string): number | undefined {
+	const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(k|m|b)?$/);
+	if (!match) return undefined;
+	const multiplier = match[2] === "k" ? 1_000 : match[2] === "m" ? 1_000_000 : match[2] === "b" ? 1_000_000_000 : 1;
+	const parsed = Number(match[1]) * multiplier;
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
 
-class MaskedInput extends Input {
-	override render(width: number): string[] {
-		const terminalWidth = process.stdout.columns;
-		const safeWidth = Math.max(1, Number.isFinite(terminalWidth) ? Math.min(width, terminalWidth) : width);
-		return super.render(safeWidth).map((line) => truncateToWidth(maskInputLine(line), safeWidth, "", false));
-	}
+function providerChoiceLabel(provider: StoredProvider, ctx: ExtensionCommandContext): string {
+	const modelCount = ctx.modelRegistry.getProvider(provider.id)?.getModels().length ?? 0;
+	const overrideCount = Object.keys(provider.modelOverrides ?? {}).length;
+	return `${provider.id} — ${provider.name} · ${modelCount} models · ${overrideCount} overrides`;
 }
 
-class SecretInputDialog extends Container {
-	private readonly input = new MaskedInput();
-	private _focused = false;
-
-	constructor(
-		done: (value: string | undefined) => void,
-		title: string,
-		helpText: string,
-		border: (text: string) => string,
-	) {
-		super();
-		// Match Pi's built-in ctx.ui.input() layout while keeping the secret masked.
-		this.addChild(new DynamicBorder(border));
-		this.addChild(new Spacer(1));
-		this.addChild(new Text(title, 1, 0));
-		this.addChild(new Spacer(1));
-		this.addChild(this.input);
-		this.addChild(new Spacer(1));
-		this.addChild(new Text(helpText, 1, 0));
-		this.addChild(new Spacer(1));
-		this.addChild(new DynamicBorder(border));
-		this.done = done;
-	}
-
-	private readonly done: (value: string | undefined) => void;
-
-	get focused(): boolean {
-		return this._focused;
-	}
-
-	set focused(value: boolean) {
-		this._focused = value;
-		this.input.focused = value;
-	}
-
-	handleInput(data: string): void {
-		const keybindings = getKeybindings();
-		if (keybindings.matches(data, "tui.select.confirm") || data === "\n") {
-			this.done(this.input.getValue());
-		} else if (keybindings.matches(data, "tui.select.cancel")) {
-			this.done(undefined);
-		} else {
-			this.input.handleInput(data);
-		}
-	}
-}
-
-function parseArgs(args: string): string[] {
-	return args.trim().split(/\s+/).filter(Boolean);
+async function chooseManagedProvider(
+	ctx: ExtensionCommandContext,
+	managed: ReadonlyMap<string, StoredProvider>,
+	action: string,
+): Promise<StoredProvider | undefined> {
+	if (!ctx.hasUI) throw new Error(`${action} requires an interactive UI.`);
+	const providers = [...managed.values()].sort((a, b) => a.id.localeCompare(b.id));
+	if (providers.length === 0) throw new Error("No managed providers.");
+	const labels = providers.map((provider) => providerChoiceLabel(provider, ctx));
+	const selected = await ctx.ui.select(action, labels);
+	if (selected === undefined) return undefined;
+	return providers[labels.indexOf(selected)];
 }
 
 function usage(): string {
@@ -397,7 +49,8 @@ function usage(): string {
 		"Usage:",
 		"  /provider add",
 		"  /provider list",
-		"  /provider edit <provider_name>",
+		"  /provider edit [provider_name]",
+		"  /provider model [provider_name] [model_id]",
 		"  /provider reload --all",
 		"  /provider reload <provider_name>",
 		"  /provider delete <provider_name>",
@@ -408,145 +61,172 @@ function commandNotify(ctx: ExtensionCommandContext, message: string, type: "inf
 	if (ctx.hasUI) ctx.ui.notify(message, type);
 }
 
-async function refreshProviders(
-	ctx: ExtensionCommandContext,
-	providerIds: readonly string[],
-): Promise<void> {
+async function refreshProviders(ctx: ExtensionCommandContext, providerIds: readonly string[]): Promise<void> {
 	if (providerIds.length === 0) {
 		commandNotify(ctx, "No providers to refresh.", "warning");
 		return;
 	}
-
-	const signal = AbortSignal.timeout(REFRESH_TIMEOUT_MS);
 	const result = await ctx.modelRegistry.refresh({
 		providers: providerIds,
 		allowNetwork: true,
 		force: true,
-		signal,
+		signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),
 	});
+	if (result.aborted) throw new Error("Model list refresh was cancelled or timed out.");
 
-	if (result.aborted) {
-		throw new Error("Model list refresh was cancelled or timed out.");
-	}
-
-	const messages: string[] = [];
-	for (const providerId of providerIds) {
+	const messages = providerIds.map((providerId) => {
 		const error = result.errors.get(providerId);
-		if (error) {
-			messages.push(`${providerId}: failed — ${error.message}`);
-			continue;
-		}
-		const provider = ctx.modelRegistry.getProvider(providerId);
-		const count = provider?.getModels().length ?? 0;
-		messages.push(`${providerId}: ${count} model${count === 1 ? "" : "s"}`);
-	}
-
-	const failed = result.errors.size > 0;
-	commandNotify(ctx, `Model list refresh complete\n${messages.join("\n")}`, failed ? "warning" : "info");
+		if (error) return `${providerId}: failed — ${error.message}`;
+		const count = ctx.modelRegistry.getProvider(providerId)?.getModels().length ?? 0;
+		return `${providerId}: ${count} model${count === 1 ? "" : "s"}`;
+	});
+	commandNotify(ctx, `Model list refresh complete\n${messages.join("\n")}`, result.errors.size > 0 ? "warning" : "info");
 }
 
 async function promptForProvider(ctx: ExtensionCommandContext): Promise<StoredProvider | undefined> {
 	if (!ctx.hasUI) throw new Error("/provider add requires an interactive UI.");
-
 	const id = (await ctx.ui.input("Provider ID", "e.g. lmstudio"))?.trim();
 	if (!id) return undefined;
 	validateProviderId(id);
-
 	const name = (await ctx.ui.input("Provider display name", id))?.trim() || id;
-	const baseUrlInput = await ctx.ui.input("OpenAI-compatible Base URL", "e.g. http://localhost:1234/v1");
-	if (!baseUrlInput?.trim()) return undefined;
-
-	return { id, name, baseUrl: validateBaseUrl(baseUrlInput) };
+	const baseUrl = await ctx.ui.input("OpenAI-compatible Base URL", "e.g. http://localhost:1234/v1");
+	if (!baseUrl?.trim()) return undefined;
+	return { id, name, baseUrl: validateBaseUrl(baseUrl) };
 }
 
 async function promptForApiKey(ctx: ExtensionCommandContext): Promise<string | undefined> {
 	if (!ctx.hasUI) throw new Error("API key entry requires an interactive UI.");
-
-	const apiKey =
-		ctx.mode === "tui"
-			? await ctx.ui.custom<string | undefined>((_tui, theme, _keybindings, done) =>
-				new SecretInputDialog(
-					done,
-					theme.fg("accent", "API key"),
-					`${keyHint("tui.select.confirm", "submit")}  ${keyHint("tui.select.cancel", "cancel")}`,
-					(text: string) => theme.fg("accent", text),
-				),
-			)
-			: await ctx.ui.input("API key", "sk-... or local");
-
+	const apiKey = ctx.mode === "tui"
+		? await ctx.ui.custom<string | undefined>((_tui, theme, _keybindings, done) => new SecretInputDialog(
+			done,
+			theme.fg("accent", "API key"),
+			`${keyHint("tui.select.confirm", "submit")}  ${keyHint("tui.select.cancel", "cancel")}`,
+			(text: string) => theme.fg("accent", text),
+		))
+		: await ctx.ui.input("API key", "sk-... or local");
 	if (apiKey === undefined) return undefined;
 	if (!apiKey.trim()) throw new Error("API key cannot be empty.");
 	return apiKey;
 }
 
-interface ProviderEdit {
-	provider: StoredProvider;
-	apiKey?: string;
-}
-
-async function promptForProviderEdit(
-	ctx: ExtensionCommandContext,
-	provider: StoredProvider,
-): Promise<ProviderEdit | undefined> {
+async function promptForProviderEdit(ctx: ExtensionCommandContext, provider: StoredProvider): Promise<{ provider: StoredProvider; apiKey?: string } | undefined> {
 	if (!ctx.hasUI) throw new Error("/provider edit requires an interactive UI.");
-
 	let updatedProvider = { ...provider };
 	let updatedApiKey: string | undefined;
-
 	while (true) {
 		const choice = await ctx.ui.select(`Edit provider: ${provider.id}`, [
 			`Change display name (${updatedProvider.name})`,
 			`Change Base URL (${updatedProvider.baseUrl})`,
 			"Change API key",
+			"Edit model limits",
+			`Reset all model limits (${Object.keys(updatedProvider.modelOverrides ?? {}).length})`,
 			"Save changes",
 		]);
 		if (choice === undefined) return undefined;
 		if (choice === "Save changes") return { provider: updatedProvider, apiKey: updatedApiKey };
-
 		if (choice.startsWith("Change display name")) {
 			const name = await ctx.ui.input("Provider display name", `Current value: ${updatedProvider.name}`);
 			if (name?.trim()) updatedProvider = { ...updatedProvider, name: name.trim() };
 			continue;
 		}
-
 		if (choice.startsWith("Change Base URL")) {
-			const baseUrlInput = await ctx.ui.input("OpenAI-compatible Base URL", `Current value: ${updatedProvider.baseUrl}`);
-			if (!baseUrlInput?.trim()) continue;
-			try {
-				updatedProvider = { ...updatedProvider, baseUrl: validateBaseUrl(baseUrlInput) };
-			} catch (error) {
-				commandNotify(ctx, error instanceof Error ? error.message : String(error), "error");
+			const baseUrl = await ctx.ui.input("OpenAI-compatible Base URL", `Current value: ${updatedProvider.baseUrl}`);
+			if (!baseUrl?.trim()) continue;
+			try { updatedProvider = { ...updatedProvider, baseUrl: validateBaseUrl(baseUrl) }; }
+			catch (error) { commandNotify(ctx, error instanceof Error ? error.message : String(error), "error"); }
+			continue;
+		}
+		if (choice === "Edit model limits") {
+			const edited = await promptForModelOverride(ctx, updatedProvider);
+			if (edited) updatedProvider = edited;
+			continue;
+		}
+		if (choice.startsWith("Reset all model limits")) {
+			if (Object.keys(updatedProvider.modelOverrides ?? {}).length === 0) continue;
+			if (await ctx.ui.confirm("Reset model limits", `Remove all model overrides for '${provider.id}'?`)) {
+				const { modelOverrides: _old, ...withoutOverrides } = updatedProvider;
+				updatedProvider = withoutOverrides;
 			}
 			continue;
 		}
-
 		const apiKey = await promptForApiKey(ctx);
 		if (apiKey !== undefined) updatedApiKey = apiKey;
 	}
 }
 
-function findManagedProvider(managed: ReadonlyMap<string, StoredProvider>, name: string): StoredProvider | undefined {
-	const providerById = managed.get(name);
-	if (providerById) return providerById;
+async function promptForModelOverride(
+	ctx: ExtensionCommandContext,
+	provider: StoredProvider,
+	requestedModelId?: string,
+): Promise<StoredProvider | undefined> {
+	if (!ctx.hasUI) throw new Error("/provider model requires an interactive UI.");
+	const loadedModels = ctx.modelRegistry.getProvider(provider.id)?.getModels() ?? [];
+	const modelIds = new Set([...loadedModels.map((model) => model.id), ...Object.keys(provider.modelOverrides ?? {})]);
+	let modelId = requestedModelId;
+	if (!modelId) {
+		const modelChoices = [...modelIds].sort().map((id) => {
+			const model = loadedModels.find((item) => item.id === id);
+			const override = provider.modelOverrides?.[id];
+			const context = override?.contextWindow ?? model?.contextWindow;
+			const output = override?.maxTokens ?? model?.maxTokens;
+			const marker = override ? " · override" : "";
+			return `${id} · context ${formatTokenCount(context)} · output ${formatTokenCount(output)}${marker}`;
+		});
+		const enterModelId = "Enter a model ID…";
+		const selected = await ctx.ui.select(`Update model limits: ${provider.id}`, [...modelChoices, enterModelId]);
+		if (selected === undefined) return undefined;
+		modelId = selected === enterModelId
+			? (await ctx.ui.input("Model ID", "e.g. opencode-go/deepseek-v4.1-flash"))?.trim()
+			: [...modelIds].sort()[modelChoices.indexOf(selected)];
+	}
+	if (!modelId) return undefined;
 
-	const matches = [...managed.values()].filter((provider) => provider.name === name);
-	if (matches.length > 1) {
-		throw new Error(`Multiple providers have the display name '${name}'. Use a provider ID instead.`);
+	const modelOverrides = { ...provider.modelOverrides };
+	let override = { ...modelOverrides[modelId] };
+	while (true) {
+		const choice = await ctx.ui.select(`Model limits: ${provider.id}/${modelId}`, [
+			`Context window: ${formatTokenCount(override.contextWindow)}`,
+			`Max output tokens: ${formatTokenCount(override.maxTokens)}`,
+			"Clear context window override",
+			"Clear max output override",
+			"Remove all overrides for this model",
+			"Save changes",
+		]);
+		if (choice === undefined) return undefined;
+		if (choice === "Save changes") {
+			if (override.contextWindow === undefined && override.maxTokens === undefined) delete modelOverrides[modelId];
+			else modelOverrides[modelId] = override;
+			const { modelOverrides: _old, ...providerWithoutOverrides } = provider;
+			return { ...providerWithoutOverrides, ...(Object.keys(modelOverrides).length ? { modelOverrides } : {}) };
+		}
+		if (choice === "Clear context window override") { const { contextWindow: _old, ...rest } = override; override = rest; continue; }
+		if (choice === "Clear max output override") { const { maxTokens: _old, ...rest } = override; override = rest; continue; }
+		if (choice === "Remove all overrides for this model") { override = {}; continue; }
+		const field = choice.startsWith("Context window") ? "contextWindow" : "maxTokens";
+		const label = field === "contextWindow" ? "Context window" : "Max output tokens";
+		const input = await ctx.ui.input(label, "Examples: 128k, 1m, 1048576");
+		if (input === undefined) continue;
+		const value = parseTokenCount(input);
+		if (value === undefined) { commandNotify(ctx, `${label} must be a positive whole token count (e.g. 128k or 1m).`, "error"); continue; }
+		override = { ...override, [field]: value };
 	}
+}
+
+function findManagedProvider(managed: ReadonlyMap<string, StoredProvider>, name: string): StoredProvider | undefined {
+	const provider = managed.get(name);
+	if (provider) return provider;
+	const matches = [...managed.values()].filter((item) => item.name === name);
+	if (matches.length > 1) throw new Error(`Multiple providers have the display name '${name}'. Use a provider ID instead.`);
 	return matches[0];
 }
 
-function providerListMessage(
-	providers: readonly StoredProvider[],
-	secrets: StoredSecrets,
-	ctx: ExtensionCommandContext,
-): string {
+function providerListMessage(providers: readonly StoredProvider[], secrets: StoredSecrets, ctx: ExtensionCommandContext): string {
 	if (providers.length === 0) return "No managed providers.";
-
 	return ["Managed providers:", ...providers.map((provider) => {
 		const modelCount = ctx.modelRegistry.getProvider(provider.id)?.getModels().length ?? 0;
 		const apiKeyStatus = secrets.apiKeys[provider.id] ? "configured" : "missing";
-		return `- ${provider.id} (${provider.name})\n  Base URL: ${provider.baseUrl}\n  API key: ${apiKeyStatus} · Models: ${modelCount}`;
+		const overrideCount = Object.keys(provider.modelOverrides ?? {}).length;
+		return `- ${provider.id} (${provider.name})\n  Base URL: ${provider.baseUrl}\n  API key: ${apiKeyStatus} · Models: ${modelCount} · Overrides: ${overrideCount}`;
 	})].join("\n");
 }
 
@@ -554,49 +234,38 @@ export default async function (pi: ExtensionAPI) {
 	const state = await loadState();
 	const secrets = await loadSecrets();
 	const managed = new Map<string, StoredProvider>();
-
-	for (const provider of state.providers) {
-		if (managed.has(provider.id)) continue;
+	const register = (provider: StoredProvider) => {
 		managed.set(provider.id, provider);
 		pi.registerProvider(provider.id, createManagedProvider(provider, () => secrets.apiKeys[provider.id]));
-	}
+	};
+	for (const provider of state.providers) if (!managed.has(provider.id)) register(provider);
 
 	pi.registerCommand("provider", {
-		description: "Add, list, edit, refresh, and delete OpenAI-compatible providers",
+		description: "Add, configure models, refresh, and delete OpenAI-compatible providers",
 		handler: async (args, ctx) => {
 			try {
 				const [subcommand, ...rest] = parseArgs(args);
-
-				if (!subcommand) {
-					commandNotify(ctx, usage(), "warning");
-					return;
-				}
-
+				if (!subcommand) { commandNotify(ctx, usage(), "warning"); return; }
 				if (subcommand === "list") {
-					if (rest.length > 0) throw new Error("/provider list does not accept arguments.");
+					if (rest.length) throw new Error("/provider list does not accept arguments.");
 					commandNotify(ctx, providerListMessage([...managed.values()], secrets, ctx));
 					return;
 				}
-
 				if (subcommand === "add") {
-					if (rest.length > 0) throw new Error("/provider add does not accept arguments.");
+					if (rest.length) throw new Error("/provider add does not accept arguments.");
 					const provider = await promptForProvider(ctx);
 					if (!provider) return;
-					if (managed.has(provider.id) || ctx.modelRegistry.getProvider(provider.id)) {
-						throw new Error(`Provider '${provider.id}' is already registered.`);
-					}
+					if (managed.has(provider.id) || ctx.modelRegistry.getProvider(provider.id)) throw new Error(`Provider '${provider.id}' is already registered.`);
 					const apiKey = await promptForApiKey(ctx);
 					if (!apiKey) return;
-
 					const nextState: StoredState = { providers: [...state.providers, provider] };
 					const previousApiKey = secrets.apiKeys[provider.id];
 					secrets.apiKeys[provider.id] = apiKey;
 					try {
 						await saveState(nextState);
 						await saveSecrets(secrets);
-						pi.registerProvider(provider.id, createManagedProvider(provider, () => secrets.apiKeys[provider.id]));
 						state.providers = nextState.providers;
-						managed.set(provider.id, provider);
+						register(provider);
 					} catch (error) {
 						if (previousApiKey === undefined) delete secrets.apiKeys[provider.id];
 						else secrets.apiKeys[provider.id] = previousApiKey;
@@ -605,87 +274,76 @@ export default async function (pi: ExtensionAPI) {
 						pi.unregisterProvider(provider.id);
 						throw error;
 					}
-
 					commandNotify(ctx, `Provider '${provider.id}' was added. Fetching its model list.`);
 					await refreshProviders(ctx, [provider.id]);
 					return;
 				}
-
 				if (subcommand === "edit") {
-					if (rest.length !== 1) throw new Error("Usage: /provider edit <provider_name>");
-					const currentProvider = findManagedProvider(managed, rest[0]);
-					if (!currentProvider) throw new Error(`Managed provider '${rest[0]}' was not found.`);
-
-					const edit = await promptForProviderEdit(ctx, currentProvider);
-					if (!edit) return;
-					const providerChanged =
-						edit.provider.name !== currentProvider.name || edit.provider.baseUrl !== currentProvider.baseUrl;
-					if (!providerChanged && edit.apiKey === undefined) {
-						commandNotify(ctx, "No provider settings were changed.", "warning");
-						return;
-					}
-
+					if (rest.length > 1) throw new Error("Usage: /provider edit [provider_name]");
+					const current = rest.length === 1
+						? findManagedProvider(managed, rest[0])
+						: await chooseManagedProvider(ctx, managed, "Edit provider");
+					if (!current) return;
+					const edit = await promptForProviderEdit(ctx, current); if (!edit) return;
+					if (edit.provider.name === current.name && edit.provider.baseUrl === current.baseUrl && edit.apiKey === undefined) { commandNotify(ctx, "No provider settings were changed.", "warning"); return; }
 					const previousState: StoredState = { providers: [...state.providers] };
-					const previousApiKey = secrets.apiKeys[currentProvider.id];
-					const nextState: StoredState = {
-						providers: state.providers.map((provider) =>
-							provider.id === currentProvider.id ? edit.provider : provider,
-						),
-					};
-					if (edit.apiKey !== undefined) secrets.apiKeys[currentProvider.id] = edit.apiKey;
-
+					const previousApiKey = secrets.apiKeys[current.id];
+					const nextState: StoredState = { providers: state.providers.map((item) => item.id === current.id ? edit.provider : item) };
+					if (edit.apiKey !== undefined) secrets.apiKeys[current.id] = edit.apiKey;
 					try {
 						await saveState(nextState);
 						if (edit.apiKey !== undefined) await saveSecrets(secrets);
-						pi.registerProvider(
-							currentProvider.id,
-							createManagedProvider(edit.provider, () => secrets.apiKeys[currentProvider.id]),
-						);
 						state.providers = nextState.providers;
-						managed.set(currentProvider.id, edit.provider);
+						register(edit.provider);
 					} catch (error) {
-						if (previousApiKey === undefined) delete secrets.apiKeys[currentProvider.id];
-						else secrets.apiKeys[currentProvider.id] = previousApiKey;
+						if (previousApiKey === undefined) delete secrets.apiKeys[current.id];
+						else secrets.apiKeys[current.id] = previousApiKey;
 						await saveState(previousState).catch(() => undefined);
 						if (edit.apiKey !== undefined) await saveSecrets(secrets).catch(() => undefined);
-						pi.registerProvider(
-							currentProvider.id,
-							createManagedProvider(currentProvider, () => secrets.apiKeys[currentProvider.id]),
-						);
+						register(current);
 						throw error;
 					}
-
-					commandNotify(ctx, `Saved settings for provider '${currentProvider.id}'. Fetching its model list.`);
-					await refreshProviders(ctx, [currentProvider.id]);
+					commandNotify(ctx, `Saved settings for provider '${current.id}'. Fetching its model list.`);
+					await refreshProviders(ctx, [current.id]);
 					return;
 				}
-
-				if (subcommand === "reload") {
-					if (rest.length !== 1) throw new Error("Usage: /provider reload --all | <provider_name>");
-					const providerIds = rest[0] === "--all" ? [...managed.keys()] : [rest[0]];
-					for (const providerId of providerIds) {
-						if (!managed.has(providerId)) throw new Error(`Managed provider '${providerId}' was not found.`);
+				if (subcommand === "model") {
+					if (rest.length > 2) throw new Error("Usage: /provider model [provider_name] [model_id]");
+					const current = rest.length > 0
+						? findManagedProvider(managed, rest[0])
+						: await chooseManagedProvider(ctx, managed, "Edit model limits");
+					if (!current) return;
+					const updated = await promptForModelOverride(ctx, current, rest[1]); if (!updated) return;
+					const previousState: StoredState = { providers: [...state.providers] };
+					const nextState: StoredState = { providers: state.providers.map((item) => item.id === current.id ? updated : item) };
+					try {
+						await saveState(nextState);
+						state.providers = nextState.providers;
+						register(updated);
+					} catch (error) {
+						await saveState(previousState).catch(() => undefined);
+						register(current);
+						throw error;
 					}
-					await refreshProviders(ctx, providerIds);
+					commandNotify(ctx, `Saved model config overrides for provider '${current.id}'. Fetching its model list.`);
+					await refreshProviders(ctx, [current.id]);
 					return;
 				}
-
+				if (subcommand === "reload") {
+					if (rest.length !== 1) throw new Error("Usage: /provider reload --all | <provider_name>");
+					const ids = rest[0] === "--all" ? [...managed.keys()] : [rest[0]];
+					for (const id of ids) if (!managed.has(id)) throw new Error(`Managed provider '${id}' was not found.`);
+					await refreshProviders(ctx, ids); return;
+				}
 				if (subcommand === "delete") {
 					if (rest.length !== 1) throw new Error("Usage: /provider delete <provider_name>");
 					const providerId = rest[0];
 					if (!managed.has(providerId)) throw new Error(`Managed provider '${providerId}' was not found.`);
 					if (!ctx.hasUI) throw new Error("/provider delete requires an interactive UI.");
-					const shouldDelete = await ctx.ui.confirm(
-						"Delete provider",
-						`Delete provider '${providerId}' and its stored API key?`,
-					);
-					if (!shouldDelete) return;
-
+					if (!await ctx.ui.confirm("Delete provider", `Delete provider '${providerId}' and its stored API key?`)) return;
 					const previousState: StoredState = { providers: [...state.providers] };
 					const previousApiKey = secrets.apiKeys[providerId];
-					const nextState: StoredState = {
-						providers: state.providers.filter((provider) => provider.id !== providerId),
-					};
+					const nextState: StoredState = { providers: state.providers.filter((item) => item.id !== providerId) };
 					delete secrets.apiKeys[providerId];
 					try {
 						await saveState(nextState);
@@ -702,23 +360,14 @@ export default async function (pi: ExtensionAPI) {
 					commandNotify(ctx, `Provider '${providerId}' was deleted.`);
 					return;
 				}
-
 				throw new Error(`Unknown provider command: ${subcommand}\n\n${usage()}`);
-			} catch (error) {
-				commandNotify(ctx, error instanceof Error ? error.message : String(error), "error");
-			}
+			} catch (error) { commandNotify(ctx, error instanceof Error ? error.message : String(error), "error"); }
 		},
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
 		if (managed.size === 0) return;
-		const result = await ctx.modelRegistry.refresh({
-			providers: [...managed.keys()],
-			allowNetwork: true,
-			signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),
-		});
-		if (result.errors.size > 0 && ctx.hasUI) {
-			ctx.ui.notify(`Could not refresh model lists for: ${[...result.errors.keys()].join(", ")}`, "warning");
-		}
+		const result = await ctx.modelRegistry.refresh({ providers: [...managed.keys()], allowNetwork: true, signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS) });
+		if (result.errors.size > 0 && ctx.hasUI) ctx.ui.notify(`Could not refresh model lists for: ${[...result.errors.keys()].join(", ")}`, "warning");
 	});
 }