pi-free 2.0.11 → 2.0.13

package/lib/registry.ts

@@ -9,7 +9,7 @@ import type {
 	ExtensionAPI,
 	ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
-import { getFreeOnly, saveConfig } from "../config.ts";
+import { getFreeOnly, getProviderShowPaid, saveConfig } from "../config.ts";
 import { createLogger } from "./logger.ts";
 
 const _logger = createLogger("pi-free");
@@ -82,7 +82,7 @@ function detectPricingExposed(allModels: ProviderModelConfig[]): boolean {
  * @returns true if the model is definitively free per the provider's API
  */
 export function isFreeModel(
-	model: ProviderModelConfig & { provider?: string },
+	model: ProviderModelConfig & { provider?: string; _pricingKnown?: boolean },
 	allModels?: ProviderModelConfig[],
 ): boolean {
 	return isFreeModelInternal(model, allModels);
@@ -90,7 +90,7 @@ export function isFreeModel(
 
 // Internal implementation to work around TypeScript filter callback issues
 function isFreeModelInternal(
-	model: ProviderModelConfig & { provider?: string },
+	model: ProviderModelConfig & { provider?: string; _pricingKnown?: boolean },
 	allModels: ProviderModelConfig[] | undefined,
 ): boolean {
 	// Determine if pricing is exposed
@@ -106,12 +106,20 @@ function isFreeModelInternal(
 		pricingExposed = true;
 	}
 
-	// Route A: Pricing-exposed providers - use OR logic
-	// Model is free if EITHER cost is zero OR name contains "free"
+	// Route A: Pricing-exposed providers
+	// Model is free if EITHER cost is zero OR name contains "free".
+	// BUT: when _pricingKnown is explicitly false (API returned no pricing data),
+	// cost values are untrustworthy defaults — fall back to name-only detection.
 	if (pricingExposed) {
 		const isZeroCost =
 			(model.cost?.input ?? 0) === 0 && (model.cost?.output ?? 0) === 0;
 		const hasFreeInName = model.name.toLowerCase().includes("free");
+
+		// Pricing missing for this specific model — only trust name-based signal
+		if (model._pricingKnown === false) {
+			return hasFreeInName;
+		}
+
 		return isZeroCost || hasFreeInName;
 	}
 
@@ -156,12 +164,32 @@ export function getProviderRegistry(): ReadonlyMap<string, ProviderEntry> {
 // Global filter application
 // =============================================================================
 
+function showAllForProvider(providerId: string, entry: ProviderEntry): void {
+	const allModels =
+		entry.stored.all.length > 0 ? entry.stored.all : entry.stored.free;
+	if (allModels.length > 0) {
+		entry.reRegister(allModels);
+		_logger.info(
+			`[pi-free] ${providerId}: showing all ${allModels.length} models`,
+		);
+	}
+}
+
 function applyFilterToProvider(
 	providerId: string,
 	entry: ProviderEntry,
 	freeOnly: boolean,
+	force: boolean,
 ): void {
 	if (freeOnly) {
+		if (!force && getProviderShowPaid(providerId)) {
+			showAllForProvider(providerId, entry);
+			_logger.info(
+				`[pi-free] ${providerId}: preserved persisted all-models toggle`,
+			);
+			return;
+		}
+
 		if (entry.stored.free.length > 0) {
 			entry.reRegister(entry.stored.free);
 			_logger.info(
@@ -171,25 +199,21 @@ function applyFilterToProvider(
 			_logger.warn(`[pi-free] ${providerId}: no free models available`);
 		}
 	} else {
-		// Show all models (paid + free)
-		const allModels =
-			entry.stored.all.length > 0 ? entry.stored.all : entry.stored.free;
-		if (allModels.length > 0) {
-			entry.reRegister(allModels);
-			_logger.info(
-				`[pi-free] ${providerId}: showing all ${allModels.length} models`,
-			);
-		}
+		showAllForProvider(providerId, entry);
 	}
 }
 
-export function applyGlobalFilter(_pi: ExtensionAPI, freeOnly: boolean): void {
+export function applyGlobalFilter(
+	_pi: ExtensionAPI,
+	freeOnly: boolean,
+	options: { force?: boolean } = {},
+): void {
 	globalFreeOnly = freeOnly;
 	saveConfig({ free_only: freeOnly });
 
 	for (const [providerId, entry] of providerRegistry) {
 		try {
-			applyFilterToProvider(providerId, entry, freeOnly);
+			applyFilterToProvider(providerId, entry, freeOnly, options.force === true);
 		} catch (err) {
 			_logger.error(
 				`[pi-free] Failed to apply filter to ${providerId}`,

package/lib/util.ts

@@ -361,7 +361,8 @@ export function mapOpenRouterModel(m: {
 		contextWindow: m.context_length ?? 4096,
 		maxTokens:
 			m.max_completion_tokens ?? m.top_provider?.max_completion_tokens ?? 4096,
-	};
+		_pricingKnown: true,
+	} as ProviderModelConfig & { _pricingKnown?: boolean };
 }
 
 // =============================================================================
@@ -484,20 +485,19 @@ export async function fetchOpenAICompatibleModels(
 					(hasVision ? ["text", "image"] : ["text"]);
 
 				// Use per-model pricing if the API provides it, otherwise use defaults
-				const inputCost =
-					(typeof m.pricing?.prompt === "number" ||
+				const hasApiPricing = m.pricing !== undefined;
+				const apiInput =
+					typeof m.pricing?.prompt === "number" ||
 					typeof m.pricing?.prompt === "string"
 						? Number(m.pricing.prompt)
-						: undefined) ??
-					defaults.cost?.input ??
-					0;
-				const outputCost =
-					(typeof m.pricing?.completion === "number" ||
+						: undefined;
+				const apiOutput =
+					typeof m.pricing?.completion === "number" ||
 					typeof m.pricing?.completion === "string"
 						? Number(m.pricing.completion)
-						: undefined) ??
-					defaults.cost?.output ??
-					0;
+						: undefined;
+				const inputCost = apiInput ?? defaults.cost?.input ?? 0;
+				const outputCost = apiOutput ?? defaults.cost?.output ?? 0;
 
 				return {
 					id: m.id,
@@ -513,7 +513,8 @@ export async function fetchOpenAICompatibleModels(
 					contextWindow,
 					maxTokens,
 					compat: getProxyModelCompat({ id: m.id, name }),
-				};
+					_pricingKnown: hasApiPricing,
+				} as PiProviderModelConfig & { _pricingKnown?: boolean };
 			});
 	} catch (error) {
 		logger.error(`[${providerId}] Failed to fetch models:`, {

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "pi-free",
-	"version": "2.0.11",
+	"version": "2.0.13",
 	"type": "module",
-	"description": "AI model providers for Pi with free model filtering. Shows only $0 cost models by default. Supports Kilo (free OAuth), Cline (free), NVIDIA (freemium), ZenMux, CrofAI, Ollama Cloud, and more.",
+	"description": "AI model providers for Pi with free model filtering and dynamic model fetching",
 	"keywords": [
 		"pi-package",
 		"pi-extension",

package/providers/cline/cline-models.ts

@@ -9,15 +9,10 @@ import { applyHidden } from "../../config.ts";
 import {
 	BASE_URL_OPENROUTER,
 	DEFAULT_FETCH_TIMEOUT_MS,
-	DEFAULT_MIN_SIZE_B,
 	PROVIDER_CLINE,
 } from "../../constants.ts";
 import type { ProviderModelConfig } from "../../lib/types.ts";
-import {
-	cleanModelName,
-	fetchWithRetry,
-	isUsableModel,
-} from "../../lib/util.ts";
+import { cleanModelName, fetchWithRetry } from "../../lib/util.ts";
 
 interface OpenRouterRaw {
 	id: string;
@@ -74,10 +69,8 @@ export async function fetchClineModels(
 
 	const json = (await response.json()) as { data?: OpenRouterRaw[] };
 
-	// Filter to usable models (chat-capable, size threshold)
-	let usableModels = (json.data ?? []).filter((m) =>
-		isUsableModel(m.id, DEFAULT_MIN_SIZE_B),
-	);
+	// Filter to usable models (chat-capable)
+	let usableModels = json.data ?? [];
 
 	// If freeOnly, filter to free models
 	if (freeOnly) {

package/providers/crofai/crofai.ts

@@ -119,7 +119,11 @@ async function fetchCrofaiModels(
 				contextWindow: m.context_length ?? 128_000,
 				maxTokens: m.max_completion_tokens ?? 16_384,
 				compat: getProxyModelCompat({ id: m.id, name }),
-			};
+				_pricingKnown:
+					m.pricing?.prompt !== undefined ||
+					m.pricing?.completion !== undefined ||
+					m.pricing?.cache_prompt !== undefined,
+			} as ProviderModelConfig & { _pricingKnown?: boolean };
 		});
 }
 

package/providers/deepinfra/deepinfra.ts

@@ -44,7 +44,7 @@ import {
 	getProxyModelCompat,
 	isLikelyReasoningModel,
 } from "../../lib/provider-compat.ts";
-import { registerWithGlobalToggle } from "../../lib/registry.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchWithRetry } from "../../lib/util.ts";
 import { createReRegister, setupProvider } from "../../provider-helper.ts";
 
@@ -136,7 +136,8 @@ async function fetchDeepinfraModels(
 				contextWindow: meta?.context_length ?? 128_000,
 				maxTokens: meta?.max_tokens ?? 16_384,
 				compat: getProxyModelCompat({ id: m.id, name }),
-			};
+				_pricingKnown: meta?.pricing !== undefined,
+			} as ProviderModelConfig & { _pricingKnown?: boolean };
 		});
 }
 
@@ -163,9 +164,10 @@ export default async function deepinfraProvider(pi: ExtensionAPI) {
 	}
 
 	// DeepInfra is a trial credit provider — $5 one-time credit, no truly free models.
-	// All models are marked as paid. When free-only mode is ON, no models are shown.
-	// Toggle free-only OFF to see all models.
-	const freeModels: ProviderModelConfig[] = [];
+	// Use isFreeModel for consistent detection across all providers.
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_DEEPINFRA }, allModels),
+	);
 	const stored = { free: freeModels, all: allModels };
 
 	_logger.info(

package/providers/dynamic-built-in/index.ts

@@ -5,39 +5,60 @@
  * standard /models endpoints when the user has configured an API key.
  *
  * Uses a single generic fetch function instead of per-provider boilerplate.
- * Discovery runs concurrently with 1s timeout per provider, fire-and-forget
- * so extension init never blocks. Pi's built-in defaults serve until
- * discovery completes and replaces them.
+ * Discovery runs concurrently and is awaited by the extension entry point.
+ * Pi only flushes provider registrations after async extension startup, so
+ * dynamic providers must register before setup returns.
  *
  * Providers handled:
  * - mistral (MISTRAL_API_KEY)
  * - groq (GROQ_API_KEY)
  * - cerebras (CEREBRAS_API_KEY)
  * - xai (XAI_API_KEY)
+ * - opencode (OPENCODE_API_KEY from auth.json)
+ * - openrouter (OPENROUTER_API_KEY from auth.json)
+ * - fastrouter (always discovered, FASTROUTER_API_KEY)
  * - huggingface (HF_TOKEN - optional, special-cased API shape)
  *
  * OpenAI is intentionally skipped per user request.
  */
 
+import type { Api } from "@earendil-works/pi-ai";
 import type {
 	ExtensionAPI,
 	ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
 import {
 	getCerebrasApiKey,
+	getFastrouterApiKey,
+	getFastrouterShowPaid,
 	getGroqApiKey,
 	getHfToken,
 	getMistralApiKey,
+	getOpencodeApiKey,
+	getOpencodeShowPaid,
+	getOpenrouterApiKey,
+	getOpenrouterShowPaid,
 	getXaiApiKey,
 } from "../../config.ts";
+import { DEFAULT_FETCH_TIMEOUT_MS } from "../../constants.ts";
 import { createLogger } from "../../lib/logger.ts";
 import { getProxyModelCompat } from "../../lib/provider-compat.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { fetchOpenRouterCompatibleModels } from "../model-fetcher.ts";
 import { createToggleState } from "../../lib/toggle-state.ts";
 import { enhanceWithCI } from "../../provider-helper.ts";
+import {
+	OPENCODE_DYNAMIC_API,
+	createOpenCodeSessionTracker,
+	createOpenCodeStreamSimple,
+	isOpenCodeProvider,
+} from "../opencode-session.ts";
 
 const _logger = createLogger("dynamic-built-in");
 
+// OpenCode headers must be regenerated for every LLM request.
+const _opencodeSession = createOpenCodeSessionTracker();
+
 // =============================================================================
 // Generic Model Fetcher
 // =============================================================================
@@ -68,7 +89,7 @@ async function fetchModelsFromEndpoint(
 
 	const response = await fetch(url, {
 		headers,
-		signal: AbortSignal.timeout(opts.timeoutMs ?? 1_000),
+		signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS),
 	});
 
 	if (!response.ok) {
@@ -101,9 +122,10 @@ async function fetchModelsFromEndpoint(
 				((m.max_tokens ?? m.max_completion_tokens) as number) ??
 				opts.modelDefaults?.maxTokens ??
 				16_384,
+			_pricingKnown: false as boolean | undefined,
 			...opts.modelDefaults,
 			...(opts.compat ? { compat: opts.compat } : {}),
-		} satisfies ProviderModelConfig;
+		} satisfies ProviderModelConfig & { _pricingKnown?: boolean };
 	});
 }
 
@@ -123,7 +145,7 @@ async function fetchHuggingFaceModels(
 
 	const response = await fetch(
 		"https://api-inference.huggingface.co/models?pipeline_tag=text-generation&limit=50",
-		{ headers, signal: AbortSignal.timeout(1_000) },
+		{ headers, signal: AbortSignal.timeout(DEFAULT_FETCH_TIMEOUT_MS) },
 	);
 
 	if (!response.ok) {
@@ -158,12 +180,17 @@ interface DynamicProviderDef {
 	providerId: string;
 	getApiKey: () => string | undefined;
 	baseUrl: string;
-	api: "openai-completions" | "mistral-conversations" | "anthropic-messages";
-	defaultShowPaid: boolean;
+	api: Api;
+	defaultShowPaid: boolean | (() => boolean);
 	/** Optional per-provider compat overrides (e.g., DeepSeek proxy). */
 	compat?: ProviderModelConfig["compat"];
 	/** Per-model field defaults when the API doesn't expose them. */
 	modelDefaults?: Partial<ProviderModelConfig>;
+	/**
+	 * Custom model fetcher (e.g., OpenRouter uses its own pricing-aware fetcher).
+	 * When not provided, fetchModelsFromEndpoint is used (no pricing, _pricingKnown=false).
+	 */
+	fetchModels?: (apiKey: string) => Promise<ProviderModelConfig[]>;
 }
 
 const DYNAMIC_PROVIDERS: DynamicProviderDef[] = [
@@ -196,6 +223,36 @@ const DYNAMIC_PROVIDERS: DynamicProviderDef[] = [
 		api: "openai-completions",
 		defaultShowPaid: false,
 	},
+	{
+		providerId: "opencode",
+		getApiKey: getOpencodeApiKey,
+		baseUrl: "https://opencode.ai/zen/v1",
+		api: OPENCODE_DYNAMIC_API,
+		defaultShowPaid: getOpencodeShowPaid,
+		// OpenCode API returns no pricing — _pricingKnown=false, name-based detection
+	},
+	{
+		providerId: "opencode-go",
+		getApiKey: getOpencodeApiKey,
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		api: OPENCODE_DYNAMIC_API,
+		defaultShowPaid: getOpencodeShowPaid,
+		// OpenCode Go uses the same OPENCODE_API_KEY and per-request headers
+	},
+	{
+		providerId: "openrouter",
+		getApiKey: getOpenrouterApiKey,
+		baseUrl: "https://openrouter.ai/api/v1",
+		api: "openai-completions",
+		defaultShowPaid: getOpenrouterShowPaid,
+		// OpenRouter returns full pricing — use its dedicated fetcher
+		fetchModels: (apiKey) =>
+			fetchOpenRouterCompatibleModels({
+				baseUrl: "https://openrouter.ai/api/v1",
+				apiKey,
+				freeOnly: false,
+			}),
+	},
 ];
 
 // =============================================================================
@@ -210,22 +267,29 @@ async function discoverAndRegister(
 	let allModels: ProviderModelConfig[];
 
 	try {
-		allModels = await fetchModelsFromEndpoint({
-			baseUrl: config.baseUrl,
-			apiKey,
-			compat: config.compat,
-			modelDefaults: config.modelDefaults,
-			timeoutMs: 1_000,
-		});
+		if (config.fetchModels) {
+			allModels = await config.fetchModels(apiKey);
+		} else {
+			allModels = await fetchModelsFromEndpoint({
+				baseUrl: config.baseUrl,
+				apiKey,
+				compat: config.compat,
+				modelDefaults: config.modelDefaults,
+				timeoutMs: DEFAULT_FETCH_TIMEOUT_MS,
+			});
+		}
 
-		// Apply DeepSeek proxy compat to matching models
+		// Apply DeepSeek proxy compat to matching models. OpenCode headers are
+		// injected per request by createOpenCodeStreamSimple(), not stored here.
 		allModels = allModels.map((m) => ({
 			...m,
+			api: isOpenCodeProvider(config.providerId) ? OPENCODE_DYNAMIC_API : m.api,
 			compat: getProxyModelCompat(m) ?? m.compat,
 		}));
-	} catch {
+	} catch (error) {
 		_logger.info(
 			`[dynamic] ${config.providerId}: discovery failed, Pi keeps its defaults`,
+			{ error: error instanceof Error ? error.message : String(error) },
 		);
 		return;
 	}
@@ -248,9 +312,10 @@ async function discoverAndRegisterHF(
 	let allModels: ProviderModelConfig[];
 	try {
 		allModels = await fetchHuggingFaceModels(apiKey);
-	} catch {
+	} catch (error) {
 		_logger.info(
 			"[dynamic] huggingface: discovery failed, Pi keeps its defaults",
+			{ error: error instanceof Error ? error.message : String(error) },
 		);
 		return;
 	}
@@ -282,6 +347,9 @@ async function registerProvider(
 			baseUrl: config.baseUrl,
 			apiKey,
 			api: config.api,
+			...(isOpenCodeProvider(config.providerId)
+				? { streamSimple: createOpenCodeStreamSimple(_opencodeSession) }
+				: {}),
 			models: enhanceWithCI(models, config.providerId),
 		});
 	};
@@ -289,7 +357,10 @@ async function registerProvider(
 	// Toggle state
 	const toggleState = createToggleState({
 		providerId: config.providerId,
-		initialShowPaid: config.defaultShowPaid,
+		initialShowPaid:
+			typeof config.defaultShowPaid === "function"
+				? config.defaultShowPaid()
+				: config.defaultShowPaid,
 		initialModels: { free: freeModels, all: allModels },
 	});
 
@@ -341,16 +412,18 @@ async function registerProvider(
 }
 
 // =============================================================================
-// Main Entry — Fire-and-Forget
+// Main Entry
 // =============================================================================
 
 /**
  * Kick off model discovery for all configured providers.
- * Runs each fetch concurrently with a 1s timeout so the worst-case
- * wall time is ~1s, not `n * 1s`. Extension init never blocks.
+ * Runs each fetch concurrently so startup waits for the slowest provider,
+ * not `n * provider latency`.
  *
- * Pi's built-in defaults serve until discovery completes and this
- * function replaces them via pi.registerProvider().
+ * Pi flushes provider registrations after async extension startup completes,
+ * so this function must await discovery before returning. Otherwise late
+ * pi.registerProvider() calls may not be visible to startup flows such as
+ * `pi --list-models` or the initial model picker.
  */
 export async function setupDynamicBuiltInProviders(
 	pi: ExtensionAPI,
@@ -368,18 +441,41 @@ export async function setupDynamicBuiltInProviders(
 		fetchers.push(discoverAndRegisterHF(pi, hfKey));
 	}
 
+	// FastRouter: always discovered (model listing needs no auth), but Pi
+	// requires a non-empty apiKey/env-var name when replacing a provider's models.
+	// Use the real configured key when present; otherwise register with the env
+	// var name so startup does not fail for users who have not configured it yet.
+	const fastrouterApiKey = getFastrouterApiKey();
+	fetchers.push(
+		discoverAndRegister(
+			pi,
+			{
+				providerId: "fastrouter",
+				getApiKey: getFastrouterApiKey,
+				baseUrl: "https://api.fastrouter.ai/api/v1",
+				api: "openai-completions",
+				defaultShowPaid: getFastrouterShowPaid,
+				fetchModels: () =>
+					fetchOpenRouterCompatibleModels({
+						baseUrl: "https://api.fastrouter.ai/api/v1",
+						apiKey: fastrouterApiKey,
+						freeOnly: false,
+					}),
+			},
+			fastrouterApiKey ?? "FASTROUTER_API_KEY",
+		),
+	);
+
 	if (fetchers.length === 0) return;
 
 	_logger.info(
-		`[dynamic] Kicking off discovery for ${fetchers.length} providers (1s timeout each, concurrent)...`,
+		`[dynamic] Kicking off discovery for ${fetchers.length} providers (concurrent)...`,
 	);
 
-	// Fire-and-forget: log results, never block init
-	void Promise.allSettled(fetchers).then((results) => {
-		const succeeded = results.filter((r) => r.status === "fulfilled").length;
-		const failed = results.filter((r) => r.status === "rejected").length;
-		_logger.info(
-			`[dynamic] Discovery complete: ${succeeded} succeeded, ${failed} failed/rejected`,
-		);
-	});
+	const results = await Promise.allSettled(fetchers);
+	const succeeded = results.filter((r) => r.status === "fulfilled").length;
+	const failed = results.filter((r) => r.status === "rejected").length;
+	_logger.info(
+		`[dynamic] Discovery complete: ${succeeded} succeeded, ${failed} failed/rejected`,
+	);
 }

package/providers/model-fetcher.ts

@@ -3,17 +3,9 @@
  * Consolidates duplicate logic from openrouter.ts and kilo-models.ts
  */
 
-import {
-	DEFAULT_FETCH_TIMEOUT_MS,
-	DEFAULT_MIN_SIZE_B,
-	URL_MODELS_DEV,
-} from "../constants.ts";
+import { DEFAULT_FETCH_TIMEOUT_MS, URL_MODELS_DEV } from "../constants.ts";
 import type { ModelsDevModel, ProviderModelConfig } from "../lib/types.ts";
-import {
-	fetchWithRetry,
-	isUsableModel,
-	mapOpenRouterModel,
-} from "../lib/util.ts";
+import { fetchWithRetry, mapOpenRouterModel } from "../lib/util.ts";
 
 interface OpenRouterCompatibleModel {
 	id: string;
@@ -113,9 +105,6 @@ export async function fetchOpenRouterCompatibleModels(
 				if (prompt !== 0 || completion !== 0) return false;
 			}
 
-			// Filter unusable and too-small models
-			if (!isUsableModel(m.id, DEFAULT_MIN_SIZE_B)) return false;
-
 			return true;
 		})
 		.map(mapOpenRouterModel);