jeopi-cli 16.6.3 → 16.6.5

package/dist/types/config/model-registry.d.ts

@@ -94,7 +94,7 @@ export declare class ModelRegistry {
      * Drives the same SQLite model cache as built-in providers, so the default
      * `online-if-uncached` strategy fetches at most once per cache TTL (24 h).
      */
-    refreshRuntimeProviders(strategy?: ModelRefreshStrategy): Promise<void>;
+    refreshRuntimeProviders(strategy?: ModelRefreshStrategy, excludedProviders?: ReadonlySet<string>): Promise<void>;
     /**
      * Get any error from loading custom models config (undefined if no error).
      */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.6.3",
+	"version": "16.6.5",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -57,17 +57,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"jeopi-hashline": "16.6.3",
-		"jeopi-stats": "16.6.3",
-		"jeopi-agent-core": "16.6.3",
-		"jeopi-ai": "16.6.3",
-		"jeopi-catalog": "16.6.3",
-		"jeopi-mnemopi": "16.6.3",
-		"jeopi-natives": "16.6.3",
-		"jeopi-tui": "16.6.3",
-		"jeopi-utils": "16.6.3",
-		"jeopi-wire": "16.6.3",
-		"jeopi-snapcompact": "16.6.3",
+		"jeopi-hashline": "16.6.5",
+		"jeopi-stats": "16.6.5",
+		"jeopi-agent-core": "16.6.5",
+		"jeopi-ai": "16.6.5",
+		"jeopi-catalog": "16.6.5",
+		"jeopi-mnemopi": "16.6.5",
+		"jeopi-natives": "16.6.5",
+		"jeopi-tui": "16.6.5",
+		"jeopi-utils": "16.6.5",
+		"jeopi-wire": "16.6.5",
+		"jeopi-snapcompact": "16.6.5",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/config/model-registry.ts

@@ -823,14 +823,30 @@ export class ModelRegistry {
 		this.#backgroundRefresh = refreshPromise;
 	}
 
+	#resolveProviderId(providerId: string): string | undefined {
+		const candidates = new Set<string>([
+			...STARTUP_MODEL_CACHE_PROVIDER_IDS,
+			...this.#models.map(model => model.provider),
+			...this.#discoverableProviders.map(provider => provider.provider),
+			...this.#providerOverrides.keys(),
+			...this.#customProviderApiKeys.keys(),
+			...this.#runtimeProviderApiKeys.keys(),
+			...this.#runtimeProviderOverrides.keys(),
+			...this.#runtimeModelManagers.keys(),
+		]);
+		return [...candidates].find(candidate => candidate.toLowerCase() === providerId.toLowerCase());
+	}
+
 	async refreshProvider(providerId: string, strategy: ModelRefreshStrategy = "online"): Promise<void> {
 		this.#reloadStaticModels();
+		const canonicalProviderId = this.#resolveProviderId(providerId);
+		if (!canonicalProviderId) return;
 		for (const selector of this.#suppressedSelectors.keys()) {
-			if (selector.startsWith(`${providerId}/`)) {
+			if (selector.startsWith(`${canonicalProviderId}/`)) {
 				this.#suppressedSelectors.delete(selector);
 			}
 		}
-		await this.#refreshRuntimeDiscoveries(strategy, new Set([providerId]));
+		await this.#refreshRuntimeDiscoveries(strategy, new Set([canonicalProviderId]));
 	}
 
 	/**
@@ -892,11 +908,18 @@ export class ModelRegistry {
 	 * Drives the same SQLite model cache as built-in providers, so the default
 	 * `online-if-uncached` strategy fetches at most once per cache TTL (24 h).
 	 */
-	async refreshRuntimeProviders(strategy: ModelRefreshStrategy = "online-if-uncached"): Promise<void> {
+	async refreshRuntimeProviders(
+		strategy: ModelRefreshStrategy = "online-if-uncached",
+		excludedProviders?: ReadonlySet<string>,
+	): Promise<void> {
 		if (this.#runtimeModelManagers.size === 0) {
 			return;
 		}
-		await this.#refreshRuntimeDiscoveries(strategy, new Set(this.#runtimeModelManagers.keys()));
+		const providers = new Set(
+			[...this.#runtimeModelManagers.keys()].filter(provider => !excludedProviders?.has(provider.toLowerCase())),
+		);
+		if (providers.size === 0) return;
+		await this.#refreshRuntimeDiscoveries(strategy, providers);
 	}
 
 	#reloadStaticModels(): void {
@@ -1620,7 +1643,7 @@ export class ModelRegistry {
 	): Promise<BuiltInDiscoveryResult> {
 		// Skip providers already handled by configured discovery (e.g. user-configured ollama with discovery.type)
 		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(p => p.provider));
-		const managerOptions = (await this.#collectBuiltInModelManagerOptions()).filter(opts => {
+		const managerOptions = (await this.#collectBuiltInModelManagerOptions(providerFilter)).filter(opts => {
 			if (configuredDiscoveryProviders.has(opts.providerId)) {
 				return false;
 			}
@@ -1643,7 +1666,7 @@ export class ModelRegistry {
 		return { models, authoritativeProviders };
 	}
 
-	async #collectBuiltInModelManagerOptions(): Promise<ModelManagerOptions<Api>[]> {
+	async #collectBuiltInModelManagerOptions(providerFilter?: ReadonlySet<string>): Promise<ModelManagerOptions<Api>[]> {
 		const specialProviderDescriptors: Array<{
 			providerId: string;
 			resolveKey: (value: string | undefined) => string | undefined;
@@ -1712,10 +1735,14 @@ export class ModelRegistry {
 		];
 		const disabledProviders = getDisabledProviderIdsFromSettings();
 		const standardProviderDescriptors = PROVIDER_DESCRIPTORS.filter(
-			descriptor => !disabledProviders.has(descriptor.providerId),
+			descriptor =>
+				!disabledProviders.has(descriptor.providerId) &&
+				(providerFilter === undefined || providerFilter.has(descriptor.providerId)),
 		);
 		const enabledSpecialProviderDescriptors = specialProviderDescriptors.filter(
-			descriptor => !disabledProviders.has(descriptor.providerId),
+			descriptor =>
+				!disabledProviders.has(descriptor.providerId) &&
+				(providerFilter === undefined || providerFilter.has(descriptor.providerId)),
 		);
 		// Use peekApiKey to avoid OAuth token refresh during discovery.
 		// The token is only needed if the dynamic fetch fires (cache miss),
@@ -1764,6 +1791,7 @@ export class ModelRegistry {
 		}
 		// Append runtime model managers registered by extensions via fetchDynamicModels.
 		for (const { options: managerOpts } of this.#runtimeModelManagers.values()) {
+			if (providerFilter !== undefined && !providerFilter.has(managerOpts.providerId)) continue;
 			options.push(managerOpts);
 		}
 		return options;

package/src/main.ts

@@ -34,6 +34,7 @@ import { findConfigFile } from "./config";
 import { ModelRegistry } from "./config/model-registry";
 import {
 	getModelMatchPreferences,
+	parseModelString,
 	resolveCliModel,
 	resolveModelRoleValue,
 	resolveModelScope,
@@ -861,18 +862,35 @@ async function buildSessionOptions(
 			modelRegistry,
 			preferences: modelMatchPreferences,
 		});
-		if (resolved.warning) {
+		const requestedSelector =
+			parsed.provider && !parsed.model.toLowerCase().startsWith(`${parsed.provider.toLowerCase()}/`)
+				? `${parsed.provider}/${parsed.model}`
+				: parsed.model;
+		const parsedSelector = parseModelString(requestedSelector, {
+			allowMaxAlias: true,
+			allowAutoAlias: true,
+			isLiteralModelId: (provider, id) => modelRegistry.find(provider, id) !== undefined,
+		});
+		const exactSelector = parsedSelector && !/[?*[\]]/.test(parsedSelector.id);
+		const exactModel = exactSelector ? modelRegistry.find(parsedSelector.provider, parsedSelector.id) : undefined;
+		const resolvedExactSelector =
+			parsedSelector &&
+			resolved.selector?.toLowerCase() === `${parsedSelector.provider}/${parsedSelector.id}`.toLowerCase();
+		const deferSelection = resolved.error || (exactSelector && !exactModel && !resolvedExactSelector);
+		if (resolved.warning && !deferSelection) {
 			process.stderr.write(`${chalk.yellow(`Warning: ${resolved.warning}`)}\n`);
 		}
-		if (resolved.error) {
-			if (!parsed.provider && !parsed.model.includes(":")) {
-				// Model not found in built-in registry — defer resolution to after extensions load
-				// (extensions may register additional providers/models via registerProvider)
-				options.modelPattern = parsed.model;
-			} else {
+		if (deferSelection) {
+			if (
+				resolved.error &&
+				parsedSelector?.provider.toLowerCase() !== "google-antigravity" &&
+				(parsed.provider || parsed.model.includes(":"))
+			) {
 				process.stderr.write(`${chalk.red(resolved.error)}\n`);
 				process.exit(1);
 			}
+			// Register extension overrides before discovering missing account models.
+			options.modelPattern = requestedSelector;
 		} else if (resolved.model) {
 			options.model = resolved.model;
 			activeSettings.overrideModelRoles({
@@ -1416,7 +1434,7 @@ export async function runRootCommand(
 			notifs.push({ kind: "error", message: modelRegistryError.message });
 		}
 
-		if (!isInteractive && !session.model) {
+		if (!session.model && (!isInteractive || sessionOptions.modelPattern !== undefined)) {
 			if (modelFallbackMessage) {
 				process.stderr.write(`${chalk.red(modelFallbackMessage)}\n`);
 			} else {

package/src/sdk.ts

@@ -1255,6 +1255,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	const hasExplicitModel = options.model !== undefined || options.modelPattern !== undefined;
 	const modelMatchPreferences = getModelMatchPreferences(settings);
+	const sessionModelStrings =
+		!hasExplicitModel && hasExistingSession
+			? getRestorableSessionModels(existingSession.models, sessionManager.getLastModelChangeRole())
+			: [];
 	const allowedModels = await logger.time("resolveAllowedModels", () =>
 		resolveAllowedModels(modelRegistry, settings, modelMatchPreferences),
 	);
@@ -1271,10 +1275,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// host preconnect) can use the restored model; extension-registered
 	// providers aren't visible yet, so we retry the preferred candidates once
 	// extensions register below.
-	const sessionModelStrings =
-		!hasExplicitModel && hasExistingSession
-			? getRestorableSessionModels(existingSession.models, sessionManager.getLastModelChangeRole())
-			: [];
 	let restoredSessionModelIndex = -1;
 	let restoredSessionThinkingLevel: ConfiguredThinkingLevel | undefined;
 	if (!hasExplicitModel && !model && sessionModelStrings.length > 0) {
@@ -1319,6 +1319,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 
 	const taskDepth = options.taskDepth ?? 0;
+	let deferredThinkingLevel: ConfiguredThinkingLevel | undefined;
 
 	// Resolves the session/agent thinking level using the same precedence we
 	// apply at startup: explicit option → persisted session entry → restored
@@ -1327,7 +1328,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// role reclaim so the final model's own defaults aren't masked by an earlier
 	// fallback model's.
 	const pickInitialThinkingLevel = (selectedModel: Model | undefined): ConfiguredThinkingLevel | undefined => {
-		let level = options.thinkingLevel;
+		let level = options.thinkingLevel ?? deferredThinkingLevel;
 		if (level === undefined && hasExistingSession && hasThinkingEntry) {
 			level =
 				parseConfiguredThinkingLevel(existingSession.configuredThinkingLevel) ??
@@ -1402,11 +1403,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		},
 	);
 
-	// Resolve contextFiles up-front (it's needed before tool creation). The
-	// workspace tree scan is slow on large repos and we MUST NOT block startup on
-	// it. On timeout we forward `undefined` to ToolSession; buildSystemPromptInternal
-	// will re-race the same promise through its own withDeadline path. Background
-	// work continues so caches still warm.
+	// Resolve contextFiles before tool creation. Bound optional startup discovery;
+	// late work may still populate caches or system-prompt fallback data.
 	const raceWithDeadline = async <T>(name: string, work: Promise<T>): Promise<T | undefined> => {
 		let timedOut = false;
 		const result = await Promise.race([
@@ -1417,7 +1415,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}),
 		]);
 		if (timedOut) {
-			logger.warn("Startup scan exceeded deadline; deferring to system prompt fallback", {
+			logger.warn("Startup work exceeded deadline; continuing with available data", {
 				name,
 				timeoutMs: STARTUP_SCAN_DEADLINE_MS,
 				cwd,
@@ -1914,12 +1912,50 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 			extensionsResult.runtime.pendingProviderRegistrations = [];
 		}
+		// Resolve account-only models after extension overrides own their endpoints.
+		const discoverySelectors = options.modelPattern
+			? [options.modelPattern]
+			: !hasExplicitModel
+				? [...sessionModelStrings, settings.getModelRole("default")]
+				: [];
+		const refreshedProviders = new Set<string>();
+		for (const selector of discoverySelectors) {
+			if (!selector) continue;
+			const parsed = parseModelString(selector, {
+				allowMaxAlias: true,
+				allowAutoAlias: true,
+				isLiteralModelId: (provider, id) => modelRegistry.find(provider, id) !== undefined,
+			});
+			if (!parsed || /[?*[\]]/.test(parsed.id)) continue;
+			const existing = modelRegistry.find(parsed.provider, parsed.id);
+			if (existing && hasModelAuth(existing)) break;
+			if (!existing && selector.includes("@")) {
+				const routed = parseModelPattern(selector, modelRegistry.getAll(), modelMatchPreferences);
+				if (routed.upstream && routed.model && hasModelAuth(routed.model)) break;
+			}
+			const providerKey = parsed.provider.toLowerCase();
+			if (existing || refreshedProviders.has(providerKey)) continue;
+			refreshedProviders.add(providerKey);
+			try {
+				await raceWithDeadline(
+					`refreshProvider:${parsed.provider}`,
+					modelRegistry.refreshProvider(parsed.provider, "online"),
+				);
+			} catch (error) {
+				logger.debug("startup model discovery failed", {
+					provider: parsed.provider,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+			const discovered = modelRegistry.find(parsed.provider, parsed.id);
+			if (discovered && hasModelAuth(discovered)) break;
+		}
 		// Discover runtime (extension) provider catalogs now that they are
 		// registered. The startup refreshInBackground() ran before extensions
 		// loaded, so dynamic extension providers are only discovered here. Runs in
 		// the background (cache-aware) so startup is never blocked on the fetch; the
 		// model list re-renders when the catalog arrives, like other dynamic providers.
-		void modelRegistry.refreshRuntimeProviders().catch(error => {
+		void modelRegistry.refreshRuntimeProviders("online-if-uncached", refreshedProviders).catch(error => {
 			logger.warn("runtime provider discovery failed", {
 				error: error instanceof Error ? error.message : String(error),
 			});
@@ -1964,14 +2000,28 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				}
 			}
 		}
+		if (!hasExplicitModel && restoredSessionModelIndex < 0 && refreshedProviders.size > 0) {
+			model = undefined;
+		}
 		// Resolve deferred --model pattern now that extension models are registered.
 		if (!model && options.modelPattern) {
 			const availableModels = modelRegistry.getAll();
 			const matchPreferences = getModelMatchPreferences(settings);
-			const { model: resolved } = parseModelPattern(options.modelPattern, availableModels, matchPreferences);
+			const { model: resolved, thinkingLevel: selectorThinkingLevel } = parseModelPattern(
+				options.modelPattern,
+				availableModels,
+				matchPreferences,
+				{ allowInvalidThinkingSelectorFallback: false },
+			);
 			if (resolved) {
 				model = resolved;
 				modelFallbackMessage = undefined;
+				deferredThinkingLevel = selectorThinkingLevel;
+				thinkingLevel = pickInitialThinkingLevel(resolved);
+				autoThinking = thinkingLevel === AUTO_THINKING;
+				effectiveThinkingLevel = autoThinking
+					? resolveProvisionalAutoLevel(resolved)
+					: resolveThinkingLevelForModel(resolved, concreteThinkingLevel(thinkingLevel));
 			} else {
 				modelFallbackMessage = `Model "${options.modelPattern}" not found`;
 			}
@@ -1994,7 +2044,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			// default with a bundled provider's default whenever a stray
 			// `OPENAI_API_KEY`/`ANTHROPIC_API_KEY` is in the environment.
 			// (issue #3569)
-			if (!hasExplicitModel && !defaultRoleSpec.model) {
+			if (!hasExplicitModel && (!defaultRoleSpec.model || refreshedProviders.size > 0)) {
 				const reResolvedRoleSpec = resolveModelRoleValue(settings.getModelRole("default"), fallbackCandidates, {
 					settings,
 					matchPreferences: modelMatchPreferences,