pi-free 2.0.4 → 2.0.5

package/provider-failover/benchmark-lookup.ts

@@ -370,24 +370,46 @@ function findBestVariantByPrefix(
 }
 
 // =============================================================================
-// Main lookup
+// Variant alias mappings
 // =============================================================================
 
-export function findHardcodedBenchmark(
-	modelName: string,
-	modelId: string,
-	provider?: string,
-): HardcodedBenchmark | null {
-	const search = `${modelName} ${modelId}`.toLowerCase();
+const MODEL_VARIANTS: Record<string, string[]> = {
+	"gpt-4o-aug-24": ["gpt-4o", "gpt-4-o"],
+	"gpt-4": ["gpt-4", "gpt4"],
+	"claude-3.5-sonnet-oct-24": [
+		"claude-3.5-sonnet",
+		"claude-3-5-sonnet",
+		"sonnet-3.5",
+	],
+	"claude-3-opus": ["claude-3-opus", "opus-3"],
+	"llama-3.1-instruct-405b": ["llama-3.1-405b", "llama3.1-405b", "llama-405b"],
+	"llama-3.1-instruct-70b": ["llama-3.1-70b", "llama3.1-70b", "llama-70b"],
+	"gemini-1.5-pro": ["gemini-1.5-pro", "gemini1.5-pro", "gemini-pro-1.5"],
+	"qwen2.5-instruct-72b": ["qwen2.5-72b", "qwen-2.5-72b"],
+	"deepseek-v3.2-non-reasoning": ["deepseek-v3", "deepseekv3", "deepseek-chat"],
+	"mimo-v2-pro": ["mimo-v2-pro", "mimo-v2-pro-free", "mimo-pro"],
+	"mimo-v2-omni": ["mimo-v2-omni", "mimo-v2-omni-free", "mimo-omni"],
+	"mimo-v2-flash": ["mimo-v2-flash", "mimo-v2-flash-free", "mimo-flash"],
+	"big-pickle": ["big-pickle", "bigpickle"],
+	"minimax-m2.5": ["minimax-m2.5", "minimax-m2.5-free", "minimax-m25"],
+	"nvidia-nemotron-3-super-120b-a12b-reasoning": [
+		"nemotron-3-super",
+		"nemotron-3-super-free",
+		"nemotron-super",
+		"nemotron-3",
+	],
+};
 
-	logDebug({
-		provider,
-		modelId,
-		modelName,
-		action: "attempt",
-	});
+// =============================================================================
+// Strategy steps
+// =============================================================================
 
-	// 1. Direct lookup — check if any benchmark key is a substring of the search
+function tryDirectSubstringMatch(
+	search: string,
+	provider: string | undefined,
+	modelId: string,
+	modelName: string,
+): HardcodedBenchmark | null {
 	for (const [key, data] of Object.entries(HARDCODED_BENCHMARKS) as [
 		string,
 		HardcodedBenchmark,
@@ -405,44 +427,16 @@ export function findHardcodedBenchmark(
 			return data;
 		}
 	}
+	return null;
+}
 
-	// 2. Variant matching — aliases for models with different naming conventions
-	const variants: Record<string, string[]> = {
-		"gpt-4o-aug-24": ["gpt-4o", "gpt-4-o"],
-		"gpt-4": ["gpt-4", "gpt4"],
-		"claude-3.5-sonnet-oct-24": [
-			"claude-3.5-sonnet",
-			"claude-3-5-sonnet",
-			"sonnet-3.5",
-		],
-		"claude-3-opus": ["claude-3-opus", "opus-3"],
-		"llama-3.1-instruct-405b": [
-			"llama-3.1-405b",
-			"llama3.1-405b",
-			"llama-405b",
-		],
-		"llama-3.1-instruct-70b": ["llama-3.1-70b", "llama3.1-70b", "llama-70b"],
-		"gemini-1.5-pro": ["gemini-1.5-pro", "gemini1.5-pro", "gemini-pro-1.5"],
-		"qwen2.5-instruct-72b": ["qwen2.5-72b", "qwen-2.5-72b"],
-		"deepseek-v3.2-non-reasoning": [
-			"deepseek-v3",
-			"deepseekv3",
-			"deepseek-chat",
-		],
-		"mimo-v2-pro": ["mimo-v2-pro", "mimo-v2-pro-free", "mimo-pro"],
-		"mimo-v2-omni": ["mimo-v2-omni", "mimo-v2-omni-free", "mimo-omni"],
-		"mimo-v2-flash": ["mimo-v2-flash", "mimo-v2-flash-free", "mimo-flash"],
-		"big-pickle": ["big-pickle", "bigpickle"],
-		"minimax-m2.5": ["minimax-m2.5", "minimax-m2.5-free", "minimax-m25"],
-		"nvidia-nemotron-3-super-120b-a12b-reasoning": [
-			"nemotron-3-super",
-			"nemotron-3-super-free",
-			"nemotron-super",
-			"nemotron-3",
-		],
-	};
-
-	for (const [canonical, names] of Object.entries(variants)) {
+function tryVariantAliasMatch(
+	search: string,
+	provider: string | undefined,
+	modelId: string,
+	modelName: string,
+): HardcodedBenchmark | null {
+	for (const [canonical, names] of Object.entries(MODEL_VARIANTS)) {
 		if (names.some((n) => search.includes(n.toLowerCase()))) {
 			const data = HARDCODED_BENCHMARKS[canonical];
 			if (data) {
@@ -459,66 +453,115 @@ export function findHardcodedBenchmark(
 			}
 		}
 	}
+	return null;
+}
 
-	// 3. Provider-specific normalization
-	const { normalized: providerNormalized, strategy: providerStrategy } =
-		applyProviderNormalization(modelId, provider);
-
-	if (providerNormalized !== modelId.toLowerCase()) {
-		logDebug({
-			provider,
-			modelId,
-			modelName,
-			action: "normalized",
-			strategy: providerStrategy,
-			normalizedId: providerNormalized,
-		});
+function tryProviderNormalizedMatch(
+	modelId: string,
+	provider: string | undefined,
+	modelName: string,
+): { result: HardcodedBenchmark | null; normalized: string } {
+	const { normalized, strategy } = applyProviderNormalization(
+		modelId,
+		provider,
+	);
 
-		// Try exact match on normalized ID
-		for (const [key, data] of Object.entries(HARDCODED_BENCHMARKS) as [
-			string,
-			HardcodedBenchmark,
-		][]) {
-			if (providerNormalized.includes(key.toLowerCase())) {
-				logDebug({
-					provider,
-					modelId,
-					modelName,
-					action: "match",
-					strategy: `provider-normalized:${providerStrategy}`,
-					matchKey: key,
-					codingIndex: data.codingIndex,
-				});
-				return data;
-			}
-		}
+	if (normalized === modelId.toLowerCase()) {
+		return { result: null, normalized };
 	}
 
-	// 4. Prefix fallback — extract base model ID and find best variant
-	//    Handles cases where benchmark keys have variant suffixes
-	//    (reasoning/non-reasoning, effort levels, dates) that the model ID lacks
-	const baseId = extractBaseModelId(providerNormalized);
-	if (baseId) {
-		let best = findBestVariantByPrefix(baseId, provider, modelId);
-		if (best) return best;
-
-		// 4b. Try with word-order normalization
-		//     (e.g., llama-3.3-70b-instruct → llama-3.3-instruct-70b)
-		const normalizedId = normalizeSizeTokenOrder(baseId);
-		if (normalizedId !== baseId) {
+	logDebug({
+		provider,
+		modelId,
+		modelName,
+		action: "normalized",
+		strategy,
+		normalizedId: normalized,
+	});
+
+	for (const [key, data] of Object.entries(HARDCODED_BENCHMARKS) as [
+		string,
+		HardcodedBenchmark,
+	][]) {
+		if (normalized.includes(key.toLowerCase())) {
 			logDebug({
 				provider,
 				modelId,
 				modelName,
-				action: "normalized",
-				strategy: "size-token-reorder",
-				normalizedId: normalizedId,
+				action: "match",
+				strategy: `provider-normalized:${strategy}`,
+				matchKey: key,
+				codingIndex: data.codingIndex,
 			});
-			best = findBestVariantByPrefix(normalizedId, provider, modelId);
-			if (best) return best;
+			return { result: data, normalized };
 		}
 	}
 
+	return { result: null, normalized };
+}
+
+function tryPrefixFallback(
+	normalizedId: string,
+	provider: string | undefined,
+	modelId: string,
+	modelName: string,
+): HardcodedBenchmark | null {
+	const baseId = extractBaseModelId(normalizedId);
+	if (!baseId) return null;
+
+	const best = findBestVariantByPrefix(baseId, provider, modelId);
+	if (best) return best;
+
+	// Try with word-order normalization
+	// (e.g., llama-3.3-70b-instruct → llama-3.3-instruct-70b)
+	const reordered = normalizeSizeTokenOrder(baseId);
+	if (reordered === baseId) return null;
+
+	logDebug({
+		provider,
+		modelId,
+		modelName,
+		action: "normalized",
+		strategy: "size-token-reorder",
+		normalizedId: reordered,
+	});
+
+	return findBestVariantByPrefix(reordered, provider, modelId);
+}
+
+// =============================================================================
+// Main lookup
+// =============================================================================
+
+export function findHardcodedBenchmark(
+	modelName: string,
+	modelId: string,
+	provider?: string,
+): HardcodedBenchmark | null {
+	const search = `${modelName} ${modelId}`.toLowerCase();
+
+	logDebug({ provider, modelId, modelName, action: "attempt" });
+
+	// 1. Direct substring match
+	const direct = tryDirectSubstringMatch(search, provider, modelId, modelName);
+	if (direct) return direct;
+
+	// 2. Variant alias matching
+	const variant = tryVariantAliasMatch(search, provider, modelId, modelName);
+	if (variant) return variant;
+
+	// 3. Provider-specific normalization
+	const { result: normalizedResult, normalized } = tryProviderNormalizedMatch(
+		modelId,
+		provider,
+		modelName,
+	);
+	if (normalizedResult) return normalizedResult;
+
+	// 4. Prefix fallback with base model extraction
+	const prefix = tryPrefixFallback(normalized, provider, modelId, modelName);
+	if (prefix) return prefix;
+
 	// No match found
 	logDebug({
 		provider,
@@ -526,8 +569,8 @@ export function findHardcodedBenchmark(
 		modelName,
 		action: "miss",
 		strategy: "all-strategies-failed",
-		normalizedId: baseId || providerNormalized,
-		details: `Final normalized: ${baseId || providerNormalized}`,
+		normalizedId: normalized,
+		details: `Final normalized: ${normalized}`,
 	});
 
 	return null;
@@ -569,6 +612,45 @@ export function enhanceModelNameWithCodingIndex(
  * Get statistics about model matching from the current session
  * Note: This reads the log file and computes stats
  */
+interface LogStats {
+	totalAttempts: number;
+	matches: number;
+	misses: number;
+	byProvider: Record<
+		string,
+		{ attempts: number; matches: number; misses: number }
+	>;
+}
+
+function parseLogLine(stats: LogStats, line: string): void {
+	if (!line.trim()) return;
+	const parts = line.split("|");
+	if (parts.length < 5) return;
+
+	const provider = parts[1] || "unknown";
+	const action = parts[4];
+
+	if (!stats.byProvider[provider]) {
+		stats.byProvider[provider] = { attempts: 0, matches: 0, misses: 0 };
+	}
+
+	if (action === "attempt") {
+		stats.totalAttempts++;
+		stats.byProvider[provider].attempts++;
+	} else if (action === "match") {
+		stats.matches++;
+		stats.byProvider[provider].matches++;
+	} else if (action === "miss") {
+		stats.misses++;
+		stats.byProvider[provider].misses++;
+	}
+}
+
+function computeMatchRate(stats: LogStats): number {
+	const total = stats.matches + stats.misses;
+	return total > 0 ? Math.round((stats.matches / total) * 100) : 0;
+}
+
 export function getMatchingStats(): {
 	totalAttempts: number;
 	matches: number;
@@ -579,58 +661,27 @@ export function getMatchingStats(): {
 		{ attempts: number; matches: number; misses: number }
 	>;
 } {
-	const stats = {
+	const stats: LogStats = {
 		totalAttempts: 0,
 		matches: 0,
 		misses: 0,
-		matchRate: 0,
-		byProvider: {} as Record<
-			string,
-			{ attempts: number; matches: number; misses: number }
-		>,
+		byProvider: {},
 	};
 
 	try {
 		if (!existsSync(LOG_FILE)) {
-			return stats;
+			return { ...stats, matchRate: 0 };
 		}
 
 		const content = readFileSync(LOG_FILE, "utf-8");
-		const lines = content.split("\n").slice(1); // Skip header
-
-		for (const line of lines) {
-			if (!line.trim()) continue;
-			const parts = line.split("|");
-			if (parts.length < 5) continue;
-
-			const provider = parts[1] || "unknown";
-			const action = parts[4];
-
-			if (!stats.byProvider[provider]) {
-				stats.byProvider[provider] = { attempts: 0, matches: 0, misses: 0 };
-			}
-
-			if (action === "attempt") {
-				stats.totalAttempts++;
-				stats.byProvider[provider].attempts++;
-			} else if (action === "match") {
-				stats.matches++;
-				stats.byProvider[provider].matches++;
-			} else if (action === "miss") {
-				stats.misses++;
-				stats.byProvider[provider].misses++;
-			}
+		for (const line of content.split("\n").slice(1)) {
+			parseLogLine(stats, line);
 		}
-
-		stats.matchRate =
-			stats.totalAttempts > 0
-				? Math.round((stats.matches / (stats.matches + stats.misses)) * 100)
-				: 0;
 	} catch {
 		// Return empty stats on error
 	}
 
-	return stats;
+	return { ...stats, matchRate: computeMatchRate(stats) };
 }
 
 // Need to import readFileSync for stats

package/providers/cline/cline.ts

@@ -138,19 +138,24 @@ function extractTaskBody(content: unknown): string {
 	return "";
 }
 
-function shapeMessagesForCline(messages: any[]): any[] {
-	let lastWrappedIdx = -1;
-	let baseTranscript = "";
+function findLastClineWrappedMessage(messages: any[]): {
+	index: number;
+	transcript: string;
+} {
 	for (let i = messages.length - 1; i >= 0; i--) {
 		if (messages[i]?.role !== "user") continue;
 		if (!isClineWrapped(messages[i]?.content)) continue;
-		lastWrappedIdx = i;
-		baseTranscript = extractTaskBody(messages[i].content);
-		break;
+		return { index: i, transcript: extractTaskBody(messages[i].content) };
 	}
+	return { index: -1, transcript: "" };
+}
 
+function buildTranscriptParts(
+	messages: any[],
+	startIdx: number,
+	baseTranscript: string,
+): string[] {
 	const parts: string[] = baseTranscript ? [baseTranscript] : [];
-	const startIdx = lastWrappedIdx >= 0 ? lastWrappedIdx + 1 : 0;
 
 	for (let i = startIdx; i < messages.length; i++) {
 		const msg = messages[i];
@@ -167,9 +172,10 @@ function shapeMessagesForCline(messages: any[]): any[] {
 		}
 	}
 
-	const transcript = parts.join("\n\n").trim() || "(no conversation yet)";
-	const envDetails = buildEnvironmentDetails();
+	return parts;
+}
 
+function buildCollapsedMessage(messages: any[], transcript: string): any[] {
 	const collapsed: any[] = [];
 	const systemMsg = messages.find((m: any) => m?.role === "system");
 	if (systemMsg) {
@@ -182,13 +188,24 @@ function shapeMessagesForCline(messages: any[]): any[] {
 		content: [
 			{ type: "text", text: `<task>\n${transcript}\n</task>` },
 			{ type: "text", text: TASK_PROGRESS_BLOCK },
-			{ type: "text", text: envDetails },
+			{ type: "text", text: buildEnvironmentDetails() },
 		],
 	});
 
 	return collapsed;
 }
 
+function shapeMessagesForCline(messages: any[]): any[] {
+	const { index: lastWrappedIdx, transcript: baseTranscript } =
+		findLastClineWrappedMessage(messages);
+
+	const startIdx = lastWrappedIdx >= 0 ? lastWrappedIdx + 1 : 0;
+	const parts = buildTranscriptParts(messages, startIdx, baseTranscript);
+	const transcript = parts.join("\n\n").trim() || "(no conversation yet)";
+
+	return buildCollapsedMessage(messages, transcript);
+}
+
 // =============================================================================
 // Extension entry point
 // =============================================================================

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

@@ -58,7 +58,9 @@ interface FetchModelsOptions {
 async function fetchModelsFromEndpoint(
 	opts: FetchModelsOptions,
 ): Promise<ProviderModelConfig[]> {
-	const url = `${opts.baseUrl.replace(/\/+$/, "")}/models`;
+	let cleanBase = opts.baseUrl;
+	while (cleanBase.endsWith("/")) cleanBase = cleanBase.slice(0, -1);
+	const url = `${cleanBase}/models`;
 	const headers: Record<string, string> = {
 		Accept: "application/json",
 		Authorization: `Bearer ${opts.apiKey}`,

package/providers/nvidia/nvidia.ts

@@ -170,39 +170,35 @@ function inferModelFromId(id: string): ModelsDevModel | null {
 // Fetch + map
 // =============================================================================
 
-async function fetchNvidiaModels(
-	apiKey?: string,
-): Promise<ProviderModelConfig[]> {
-	// ── 1. Query NVIDIA's actual API (source of truth) ─────────────────
-	let apiModelIds = new Set<string>();
-	if (apiKey) {
-		try {
-			const response = await fetchWithRetry(
-				`${BASE_URL_NVIDIA}/models`,
-				{
-					headers: {
-						Authorization: `Bearer ${apiKey}`,
-						"User-Agent": "pi-free-providers",
-					},
+async function fetchNvidiaApiModelIds(apiKey: string): Promise<Set<string>> {
+	try {
+		const response = await fetchWithRetry(
+			`${BASE_URL_NVIDIA}/models`,
+			{
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"User-Agent": "pi-free-providers",
 				},
-				3,
-				1000,
-				DEFAULT_FETCH_TIMEOUT_MS,
-			);
-			if (response.ok) {
-				const json = (await response.json()) as {
-					data?: Array<{ id: string }>;
-				};
-				if (json.data) {
-					apiModelIds = new Set(json.data.map((m) => m.id));
-				}
+			},
+			3,
+			1000,
+			DEFAULT_FETCH_TIMEOUT_MS,
+		);
+		if (response.ok) {
+			const json = (await response.json()) as {
+				data?: Array<{ id: string }>;
+			};
+			if (json.data) {
+				return new Set(json.data.map((m) => m.id));
 			}
-		} catch (error) {
-			console.error("[nvidia] Failed to fetch models from NVIDIA API", error);
 		}
+	} catch (error) {
+		console.error("[nvidia] Failed to fetch models from NVIDIA API", error);
 	}
+	return new Set();
+}
 
-	// ── 2. Fetch models.dev for rich metadata (cost, limits, etc.) ─────
+async function fetchModelsDevMetadata(): Promise<Map<string, ModelsDevModel>> {
 	const devModels = new Map<string, ModelsDevModel>();
 	try {
 		const response = await fetchWithRetry(
@@ -226,6 +222,27 @@ async function fetchNvidiaModels(
 	} catch (error) {
 		console.error("[nvidia] Failed to fetch models.dev", error);
 	}
+	return devModels;
+}
+
+function isChatModel(m: ModelsDevModel): boolean {
+	const modalities = m.modalities;
+	if (!modalities) return true;
+	const output = modalities.output ?? [];
+	const input = modalities.input ?? [];
+	return output.includes("text") && input.includes("text");
+}
+
+async function fetchNvidiaModels(
+	apiKey?: string,
+): Promise<ProviderModelConfig[]> {
+	// ── 1. Query NVIDIA's actual API (source of truth) ─────────────────
+	const apiModelIds = apiKey
+		? await fetchNvidiaApiModelIds(apiKey)
+		: new Set<string>();
+
+	// ── 2. Fetch models.dev for rich metadata (cost, limits, etc.) ─────
+	const devModels = await fetchModelsDevMetadata();
 
 	// ── 3. Build unified list (NVIDIA API wins; fallback to models.dev) ─
 	const modelIds =
@@ -233,30 +250,11 @@ async function fetchNvidiaModels(
 
 	const result = applyHidden(
 		modelIds
-			.map((id) => {
-				const dev = devModels.get(id);
-				if (dev) return dev;
-				return inferModelFromId(id);
-			})
+			.map((id) => devModels.get(id) ?? inferModelFromId(id))
 			.filter((m): m is ModelsDevModel => m !== null)
 			.filter((m) => isUsableModel(m.id, NVIDIA_MIN_SIZE_B))
-			.filter((m) => {
-				const modalities = m.modalities;
-				if (modalities) {
-					const output = modalities.output ?? [];
-					const input = modalities.input ?? [];
-					if (!output.includes("text")) return false;
-					if (!input.includes("text")) return false;
-				}
-				return true;
-			})
-			// Filter out known 404 models (listed but not provisioned for chat)
-			.filter((m) => {
-				if (NVIDIA_KNOWN_404_MODELS.has(m.id)) {
-					return false;
-				}
-				return true;
-			})
+			.filter(isChatModel)
+			.filter((m) => !NVIDIA_KNOWN_404_MODELS.has(m.id))
 			// NVIDIA is freemium — all models are usable with free credits.
 			// No cost filtering applied.
 			.map(