pi-free 2.0.11 → 2.0.12

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.12",
 	"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,15 +5,18 @@
  * 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.
@@ -25,14 +28,22 @@ import type {
 } 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";
 
@@ -68,7 +79,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 +112,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 +135,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) {
@@ -159,11 +171,16 @@ interface DynamicProviderDef {
 	getApiKey: () => string | undefined;
 	baseUrl: string;
 	api: "openai-completions" | "mistral-conversations" | "anthropic-messages";
-	defaultShowPaid: boolean;
+	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 +213,28 @@ const DYNAMIC_PROVIDERS: DynamicProviderDef[] = [
 		api: "openai-completions",
 		defaultShowPaid: false,
 	},
+	{
+		providerId: "opencode",
+		getApiKey: getOpencodeApiKey,
+		baseUrl: "https://opencode.ai/zen/v1",
+		api: "openai-completions",
+		defaultShowPaid: getOpencodeShowPaid,
+		// OpenCode API returns no pricing — _pricingKnown=false, name-based detection
+	},
+	{
+		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 +249,27 @@ 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
 		allModels = allModels.map((m) => ({
 			...m,
 			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 +292,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;
 	}
@@ -289,7 +334,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 +389,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 +418,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);

package/providers/novita/novita.ts

@@ -0,0 +1,205 @@
+/**
+ * Novita AI Provider Extension
+ *
+ * Novita AI deploys 100+ open-source models with an OpenAI-compatible API.
+ * Known for competitive pricing, globally distributed GPU infrastructure,
+ * and support for chat, vision, and Anthropic-compatible endpoints.
+ *
+ * API: https://api.novita.ai/openai/v1
+ * Models: /v1/models returns non-standard pricing fields (input_token_price_per_m,
+ * output_token_price_per_m) plus rich metadata (context_size, max_output_tokens,
+ * features for reasoning, input_modalities for vision).
+ *
+ * Setup:
+ *   1. Sign up at https://novita.ai
+ *   2. Get API key from dashboard
+ *   3. Set NOVITA_API_KEY env var or add to ~/.pi/free.json
+ *
+ * Usage:
+ *   pi install git:github.com/apmantza/pi-free
+ *   # Set NOVITA_API_KEY env var
+ *   # Models appear in /model selector
+ */
+
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@earendil-works/pi-coding-agent";
+import { getNovitaApiKey, getNovitaShowPaid } from "../../config.ts";
+import {
+	BASE_URL_NOVITA,
+	DEFAULT_FETCH_TIMEOUT_MS,
+	PROVIDER_NOVITA,
+} from "../../constants.ts";
+import { createLogger } from "../../lib/logger.ts";
+import {
+	getProxyModelCompat,
+	isLikelyReasoningModel,
+} from "../../lib/provider-compat.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { fetchWithRetry } from "../../lib/util.ts";
+import { createReRegister, setupProvider } from "../../provider-helper.ts";
+
+const _logger = createLogger("novita");
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface NovitaModel {
+	id: string;
+	display_name?: string;
+	description?: string;
+	input_token_price_per_m?: number;
+	output_token_price_per_m?: number;
+	context_size?: number;
+	max_output_tokens?: number;
+	features?: string[];
+	input_modalities?: string[];
+	output_modalities?: string[];
+	model_type?: string;
+	endpoints?: string[];
+	status?: number;
+}
+
+// =============================================================================
+// Fetch
+// =============================================================================
+
+async function fetchNovitaModels(
+	apiKey: string,
+): Promise<ProviderModelConfig[]> {
+	_logger.info("[novita] Fetching models from Novita API...");
+
+	try {
+		const response = await fetchWithRetry(
+			`${BASE_URL_NOVITA}/models`,
+			{
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json",
+				},
+			},
+			3,
+			1000,
+			DEFAULT_FETCH_TIMEOUT_MS,
+		);
+
+		if (!response.ok) {
+			throw new Error(`Novita API error: ${response.status}`);
+		}
+
+		const json = (await response.json()) as { data?: NovitaModel[] };
+		const models = (json.data ?? []).filter(
+			(m) => m.status === 1 && m.model_type === "chat",
+		);
+
+		_logger.info(`[novita] Fetched ${models.length} models`);
+
+		return models.map((m): ProviderModelConfig => {
+			const name = m.display_name || m.id.split("/").pop() || m.id;
+			const reasoning =
+				(m.features ?? []).includes("reasoning") ||
+				isLikelyReasoningModel({ id: m.id, name });
+			const hasVision = m.input_modalities?.includes("image") ?? false;
+
+			// Novita pricing is per-MILLION tokens. Divide for per-token (Pi convention).
+			const inputCost = (m.input_token_price_per_m ?? 0) / 1_000_000;
+			const outputCost = (m.output_token_price_per_m ?? 0) / 1_000_000;
+			const hasPricing =
+				m.input_token_price_per_m !== undefined ||
+				m.output_token_price_per_m !== undefined;
+
+			return {
+				id: m.id,
+				name,
+				reasoning,
+				input: hasVision ? ["text", "image"] : ["text"],
+				cost: {
+					input: inputCost,
+					output: outputCost,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				contextWindow: m.context_size ?? 128_000,
+				maxTokens: m.max_output_tokens ?? 16_384,
+				compat: getProxyModelCompat({ id: m.id, name }),
+				_pricingKnown: hasPricing,
+			} as ProviderModelConfig & { _pricingKnown?: boolean };
+		});
+	} catch (error) {
+		_logger.error("[novita] Failed to fetch models:", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return [];
+	}
+}
+
+// =============================================================================
+// Extension Entry Point
+// =============================================================================
+
+export default async function novitaProvider(pi: ExtensionAPI) {
+	const apiKey = getNovitaApiKey();
+
+	if (!apiKey) {
+		_logger.info(
+			"[novita] Skipping — NOVITA_API_KEY not set. Sign up at https://novita.ai/",
+		);
+		return;
+	}
+
+	// Fetch models
+	const allModels = await fetchNovitaModels(apiKey);
+
+	if (allModels.length === 0) {
+		_logger.warn("[novita] No chat models available");
+		return;
+	}
+
+	// Use isFreeModel with allModels for proper detection
+	// Novita returns pricing for all models → _pricingKnown=true → Route A OR logic
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_NOVITA }, allModels),
+	);
+
+	const stored = { free: freeModels, all: allModels };
+
+	_logger.info(
+		`[novita] Registered ${allModels.length} models (${freeModels.length} free)`,
+	);
+
+	// Create re-register function
+	const reRegister = createReRegister(pi, {
+		providerId: PROVIDER_NOVITA,
+		baseUrl: BASE_URL_NOVITA,
+		apiKey,
+	});
+
+	// Register with global toggle
+	registerWithGlobalToggle(PROVIDER_NOVITA, stored, reRegister, true);
+
+	// Setup provider with toggle command
+	setupProvider(
+		pi,
+		{
+			providerId: PROVIDER_NOVITA,
+			initialShowPaid: getNovitaShowPaid(),
+			tosUrl: "https://novita.ai/terms",
+			reRegister: (models, _stored) => {
+				if (_stored) {
+					stored.free = _stored.free;
+					stored.all = _stored.all;
+				}
+				reRegister(models);
+			},
+		},
+		stored,
+	);
+
+	// Initial registration — respect persisted toggle state
+	const showPaid = getNovitaShowPaid();
+	const initialModels =
+		showPaid && stored.all.length > 0 ? stored.all : freeModels;
+	reRegister(initialModels);
+}

package/providers/nvidia/nvidia.ts

@@ -31,7 +31,7 @@ import {
 	URL_MODELS_DEV,
 } from "../../constants.ts";
 import { createLogger } from "../../lib/logger.ts";
-import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { registerWithGlobalToggle } from "../../lib/registry.ts";
 import type { ModelsDevModel, ModelsDevProvider } from "../../lib/types.ts";
 import {
 	fetchWithRetry,
@@ -382,11 +382,9 @@ export default async function nvidiaProvider(pi: ExtensionAPI) {
 		return;
 	}
 
-	// Store both sets for global toggle using consistent isFreeModel helper
-	// NVIDIA uses Route B (name-based): only models with "free" in name are marked free
-	const freeModels = allModels.filter((m) =>
-		isFreeModel({ ...m, provider: PROVIDER_NVIDIA }),
-	);
+	// All NVIDIA NIM models are accessible via free credits (no payment method required).
+	// Same approach as Codestral/Ollama: all models shown as free-tier.
+	const freeModels = allModels;
 	const stored = { free: freeModels, all: allModels };
 
 	// Create re-register function

package/providers/sambanova/sambanova.ts

@@ -31,7 +31,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getSambanovaApiKey, getSambanovaShowPaid } from "../../config.ts";
 import { BASE_URL_SAMBANOVA, PROVIDER_SAMBANOVA } from "../../constants.ts";
 import { createLogger } from "../../lib/logger.ts";
-import { registerWithGlobalToggle } from "../../lib/registry.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchOpenAICompatibleModels } from "../../lib/util.ts";
 import { createReRegister, setupProvider } from "../../provider-helper.ts";
 
@@ -66,7 +66,13 @@ export default async function sambanovaProvider(pi: ExtensionAPI) {
 
 	// All SambaNova models are free-tier (no payment method required).
 	// Rate limits are lower on free tier but all models are accessible.
-	const freeModels = allModels;
+	// Override _pricingKnown so isFreeModel trusts the zero costs.
+	for (const m of allModels) {
+		(m as unknown as { _pricingKnown?: boolean })._pricingKnown = true;
+	}
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_SAMBANOVA }, allModels),
+	);
 	const stored = { free: freeModels, all: allModels };
 
 	_logger.info(