pi-free 1.0.6 → 1.0.8

package/lib/model-detection.ts

@@ -0,0 +1,268 @@
+/**
+ * Model detection utilities for pi-free-providers.
+ * Extracts and adapts model family detection from pi-models.
+ * Used for failover when providers hit rate limits.
+ */
+
+import type { Model } from "@mariozechner/pi-ai";
+import type { ProviderModelConfig } from "./types.ts";
+
+export interface ModelInfo {
+	id: string;
+	name?: string;
+	provider: string;
+	isFree: boolean;
+	inputCost: number;
+	outputCost: number;
+}
+
+export interface ModelFamily {
+	id: string; // Normalized family ID (e.g., "claude-sonnet")
+	displayName: string; // Human readable (e.g., "Claude Sonnet")
+	models: ModelInfo[]; // All models in this family
+}
+
+/**
+ * Check if a model is free (zero input and output cost)
+ */
+export function isModelFree(model: {
+	cost?: { input: number; output: number };
+}): boolean {
+	if (!model.cost) return true;
+	return model.cost.input === 0 && model.cost.output === 0;
+}
+
+/**
+ * Convert Pi's Model type to ModelInfo for internal use
+ */
+export function toModelInfo(model: Model<any>): ModelInfo {
+	return {
+		id: model.id,
+		name: model.name,
+		provider: model.provider,
+		isFree: isModelFree(model),
+		inputCost: model.cost?.input ?? 0,
+		outputCost: model.cost?.output ?? 0,
+	};
+}
+
+/**
+ * Convert ProviderModelConfig to ModelInfo for internal use
+ */
+export function toProviderModelInfo(model: ProviderModelConfig): ModelInfo {
+	return {
+		id: model.id,
+		name: model.name,
+		provider: "", // Will be set by caller
+		isFree: isModelFree(model),
+		inputCost: model.cost?.input ?? 0,
+		outputCost: model.cost?.output ?? 0,
+	};
+}
+
+/**
+ * Detect the model family from a model's ID or name.
+ * Returns the family ID and display name.
+ */
+export function detectModelFamily(
+	model: ModelInfo,
+): { familyId: string; familyName: string } | null {
+	const id = model.id.toLowerCase();
+	const name = (model.name || "").toLowerCase();
+	const fullText = `${id} ${name}`;
+
+	// Router models (gateways to free models) - group into "other"
+	if (/\brouter\b/.test(fullText) || /\bauto\b/.test(fullText) || id === "kilo-auto/free") {
+		return { familyId: "other", familyName: "Other" };
+	}
+
+	// Known brand keywords - order matters: more specific/longer matches first
+	const brandMappings: {
+		keywords: string[];
+		familyId: string;
+		familyName: string;
+	}[] = [
+		{ keywords: ["claude"], familyId: "claude", familyName: "Claude" },
+		{ keywords: ["deepseek"], familyId: "deepseek", familyName: "DeepSeek" },
+		{ keywords: ["gemini"], familyId: "gemini", familyName: "Gemini" },
+		{ keywords: ["gpt"], familyId: "gpt", familyName: "GPT" },
+		{ keywords: ["llama"], familyId: "llama", familyName: "Llama" },
+		{ keywords: ["minimax"], familyId: "minimax", familyName: "MiniMax" },
+		{ keywords: ["qwen"], familyId: "qwen", familyName: "Qwen" },
+		{ keywords: ["nemotron"], familyId: "nemotron", familyName: "Nemotron" },
+		{ keywords: ["kimi", "moonshot"], familyId: "kimi", familyName: "Kimi" },
+		{ keywords: ["glm", "chatglm"], familyId: "glm", familyName: "GLM" },
+		{ keywords: ["mistral"], familyId: "mistral", familyName: "Mistral" },
+		{ keywords: ["arcee", "trinity"], familyId: "arcee", familyName: "Arcee" },
+		{ keywords: ["o1", "o3"], familyId: "openai-o", familyName: "OpenAI o" },
+	];
+
+	// Check for known brands in ID or name
+	for (const mapping of brandMappings) {
+		for (const keyword of mapping.keywords) {
+			if (fullText.includes(keyword)) {
+				return { familyId: mapping.familyId, familyName: mapping.familyName };
+			}
+		}
+	}
+
+	// Provider-specific fallbacks for models without brand in ID/name
+	const providerMappings: Record<string, { familyId: string; familyName: string }> = {
+		minimax: { familyId: "minimax", familyName: "MiniMax" },
+		minimaxai: { familyId: "minimax", familyName: "MiniMax" },
+		deepseek: { familyId: "deepseek", familyName: "DeepSeek" },
+		nvidia: { familyId: "nemotron", familyName: "Nemotron" },
+		moonshot: { familyId: "kimi", familyName: "Kimi" },
+		zhipu: { familyId: "glm", familyName: "GLM" },
+	};
+
+	if (providerMappings[model.provider]) {
+		return providerMappings[model.provider];
+	}
+
+	// Helper to find brand in ID parts
+	function findBrandInParts(parts: string[]): { familyId: string; familyName: string } | null {
+		for (const part of parts) {
+			for (const mapping of brandMappings) {
+				for (const keyword of mapping.keywords) {
+					if (part.includes(keyword)) {
+						return { familyId: mapping.familyId, familyName: mapping.familyName };
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+	// Smart fallback: try to identify brand from model ID structure
+	const parts = id.split(/[-_:.@]/);
+	const firstPart = parts[0];
+
+	// If ID starts with a version number, check remaining parts for brand
+	if (firstPart && /^v?\d+(\.\d+)?$/.test(firstPart)) {
+		const brandFromParts = findBrandInParts(parts.slice(1));
+		if (brandFromParts) {
+			return brandFromParts;
+		}
+	}
+
+	// If ID has multiple parts, check ALL parts for brand keywords
+	if (parts.length > 1) {
+		const brandFromParts = findBrandInParts(parts);
+		if (brandFromParts) {
+			return brandFromParts;
+		}
+
+		// Use first part as brand if it looks brand-like
+		if (firstPart && !/^v?\d+(\.\d+)?$/.test(firstPart)) {
+			return {
+				familyId: firstPart,
+				familyName: firstPart.charAt(0).toUpperCase() + firstPart.slice(1),
+			};
+		}
+	}
+
+	// Last resort: use first non-version part
+	if (firstPart && /^v?\d+(\.\d+)?$/.test(firstPart) && parts.length > 1) {
+		for (let i = 1; i < parts.length; i++) {
+			const part = parts[i];
+			if (
+				part &&
+				!/^v?\d+(\.\d+)?$/.test(part) &&
+				!["latest", "preview", "rc", "beta", "alpha", "dev", "free"].includes(part)
+			) {
+				return {
+					familyId: part,
+					familyName: part.charAt(0).toUpperCase() + part.slice(1),
+				};
+			}
+		}
+	}
+
+	return {
+		familyId: firstPart || id,
+		familyName: (firstPart || id).charAt(0).toUpperCase() + (firstPart || id).slice(1),
+	};
+}
+
+/**
+ * Normalize a model name for comparison by removing provider-specific suffixes
+ * and common qualifiers. This helps detect when the same model is offered by
+ * multiple providers with slightly different naming.
+ */
+export function normalizeModelName(name: string): string {
+	return (
+		name
+			.toLowerCase()
+			// Remove common suffixes added by providers
+			.replace(/\s*\(free\)\s*$/i, "")
+			.replace(/\s*\(cline\)\s*$/i, "")
+			.replace(/\s*\(ci:\s*[\d.]+\)\s*$/i, "")
+			.replace(/\s*\[ci:\s*[\d.]+\]\s*$/i, "")
+			.replace(/\s*\([^)]*\)\s*$/g, "") // Remove any trailing parenthetical
+			.replace(/\s*-\s*free\s*$/i, "") // e.g., "minimax-m2.5-free"
+			.replace(/\s*free\s*$/i, "") // trailing "free"
+			.trim()
+	);
+}
+
+/**
+ * Get all model families from a list of models.
+ * Groups models by family and merges same-name models across providers.
+ */
+export function getModelFamilies(models: ModelInfo[]): ModelFamily[] {
+	const byFamily = new Map<string, ModelInfo[]>();
+	const nameToFamilyId = new Map<string, string>();
+
+	for (const model of models) {
+		const family = detectModelFamily(model);
+		if (!family) continue;
+
+		const existing = byFamily.get(family.familyId) ?? [];
+		existing.push(model);
+		byFamily.set(family.familyId, existing);
+	}
+
+	// Second pass: merge families with models that have the same normalized name
+	const familyIds = [...byFamily.keys()];
+	for (const familyId of familyIds) {
+		const familyModels = byFamily.get(familyId);
+		if (!familyModels) continue;
+
+		for (const model of familyModels) {
+			const normalizedName = normalizeModelName(model.name || model.id);
+			if (!normalizedName) continue;
+
+			const existingFamilyForName = nameToFamilyId.get(normalizedName);
+			if (existingFamilyForName && existingFamilyForName !== familyId) {
+				// Same model name found in different family - merge them
+				const targetFamily = byFamily.get(existingFamilyForName);
+				const sourceFamily = byFamily.get(familyId);
+				if (targetFamily && sourceFamily) {
+					targetFamily.push(...sourceFamily);
+					byFamily.delete(familyId);
+					break;
+				}
+			} else {
+				nameToFamilyId.set(normalizedName, familyId);
+			}
+		}
+	}
+
+	const families: ModelFamily[] = [];
+	for (const [id, familyModels] of byFamily) {
+		const firstModel = familyModels[0]!;
+		const familyInfo = detectModelFamily(firstModel)!;
+
+		families.push({
+			id,
+			displayName: familyInfo.familyName,
+			models: familyModels.sort(
+				(a, b) =>
+					a.provider.localeCompare(b.provider) || b.id.localeCompare(a.id),
+			),
+		});
+	}
+
+	return families.sort((a, b) => a.displayName.localeCompare(b.displayName));
+}

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "pi-free",
-	"version": "1.0.6",
+	"version": "1.0.8",
 	"type": "module",
-	"description": "AIO Free AI models for Pi - Access free models from Kilo, Zen, OpenRouter, NVIDIA, Cline, Mistral, and Ollama",
+	"description": "AIO Free AI models for Pi - Access free models from Kilo, Zen, OpenRouter, NVIDIA, Cline, Mistral, Ollama, and Qwen",
 	"keywords": [
 		"pi-package",
 		"pi-extension",
@@ -14,7 +14,9 @@
 		"cline",
 		"ollama",
 		"mistral",
-		"fireworks"
+		"fireworks",
+		"qwen",
+		"qwen-oauth"
 	],
 	"license": "MIT",
 	"author": "Apostolos Mantzaris",
@@ -34,15 +36,18 @@
 		"lib/**/*.ts",
 		"usage/**/*.ts",
 		"provider-failover/**/*.ts",
+		"widget/**/*.ts",
 		"config.ts",
 		"constants.ts",
 		"provider-factory.ts",
 		"provider-helper.ts",
 		"README.md",
 		"LICENSE",
-		"CHANGELOG.md"
+		"CHANGELOG.md",
+		"scripts/check-extensions.mjs"
 	],
 	"scripts": {
+		"check": "node scripts/check-extensions.mjs",
 		"test": "vitest",
 		"test:ui": "vitest --ui",
 		"test:run": "vitest run"
@@ -54,20 +59,24 @@
 		"@sinclair/typebox": "*"
 	},
 	"devDependencies": {
-		"vitest": "^1.0.0",
 		"@vitest/ui": "^1.0.0",
-		"tsx": "^4.0.0"
+		"tsx": "^4.0.0",
+		"typescript": "^6.0.2",
+		"vitest": "^1.0.0"
 	},
 	"pi": {
 		"extensions": [
 			"./providers/kilo.ts",
 			"./providers/zen.ts",
+			"./providers/go.ts",
 			"./providers/openrouter.ts",
 			"./providers/nvidia.ts",
 			"./providers/cline.ts",
 			"./providers/fireworks.ts",
 			"./providers/mistral.ts",
-			"./providers/ollama.ts"
+			"./providers/ollama.ts",
+			"./providers/qwen.ts",
+			"./providers/modal.ts"
 		]
 	}
 }

package/provider-factory.ts

@@ -33,6 +33,7 @@ import {
 	OLLAMA_SHOW_PAID,
 	OPENCODE_API_KEY,
 	ZEN_SHOW_PAID,
+	MODAL_API_KEY,
 } from "./config.ts";
 import { createLogger } from "./lib/logger.ts";
 import { logWarning } from "./lib/util.ts";
@@ -86,6 +87,7 @@ const API_KEY_GETTERS: Record<string, () => string | undefined> = {
 	ollama_api_key: () => OLLAMA_API_KEY,
 	mistral_api_key: () => MISTRAL_API_KEY,
 	opencode_api_key: () => OPENCODE_API_KEY,
+	modal_api_key: () => MODAL_API_KEY,
 };
 
 const SHOW_PAID_GETTERS: Record<string, () => boolean> = {

package/provider-failover/auto-switch.ts

@@ -0,0 +1,350 @@
+/**
+ * Auto-switch failover for pi-free-providers.
+ * 
+ * When a provider hits a 429 or capacity error, this module finds
+ * an equivalent or similar model from another provider and switches to it.
+ * 
+ * Strategy:
+ * 1. Extract the base model name/family from the failed model
+ * 2. Search all available models for the same model (different provider)
+ * 3. If not found, find a similar model in the same family
+ * 4. If not found, find any free model with similar capability
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { Model } from "@mariozechner/pi-ai";
+import { createLogger } from "../lib/logger.ts";
+import {
+	detectModelFamily,
+	normalizeModelName,
+	toModelInfo,
+	type ModelInfo,
+} from "../lib/model-detection.ts";
+import { getHardcodedScore } from "./hardcoded-benchmarks.ts";
+
+const _logger = createLogger("auto-switch");
+
+export interface AutoSwitchConfig {
+	/** Whether to enable auto-switching (can be disabled by user) */
+	enabled: boolean;
+	/** Maximum CI score degradation allowed (e.g., 10 = can drop up to 10 points) */
+	maxCIScoreDrop: number;
+	/** Provider priority for fallback (preferred first) */
+	providerPriority: string[];
+}
+
+const DEFAULT_CONFIG: AutoSwitchConfig = {
+	enabled: true,
+	maxCIScoreDrop: 15,
+	providerPriority: ["zen", "go", "kilo", "openrouter", "nvidia", "fireworks", "mistral", "ollama", "cline"],
+};
+
+export interface AutoSwitchResult {
+	success: boolean;
+	switched: boolean;
+	message: string;
+	fallbackModel?: ModelInfo;
+}
+
+interface CandidateModel {
+	model: Model<any>;
+	modelInfo: ModelInfo;
+	ciScore: number;
+	normalizedName: string;
+	family: string;
+}
+
+/**
+ * Find a fallback model when the current provider fails.
+ * 
+ * Priority order:
+ * 1. Same model name from different provider (best match)
+ * 2. Same model family, prefer free models
+ * 3. Any free model with similar CI score
+ */
+export async function findFallbackModel(
+	failedModel: Model<any>,
+	availableModels: Model<any>[],
+	config: Partial<AutoSwitchConfig> = {},
+): Promise<CandidateModel | null> {
+	const fullConfig = { ...DEFAULT_CONFIG, ...config };
+
+	// Convert to ModelInfo for internal processing
+	const failedModelInfo = toModelInfo(failedModel);
+	const failedFamily = detectModelFamily(failedModelInfo);
+	const failedNormalizedName = normalizeModelName(failedModelInfo.name || failedModelInfo.id);
+	const failedCIScore = getHardcodedScore(failedModel.name || "", failedModel.id) ?? 20;
+
+	_logger.info("Finding fallback model", {
+		failedModel: failedModel.id,
+		failedProvider: failedModel.provider,
+		failedFamily: failedFamily?.familyId,
+		failedNormalizedName: failedNormalizedName,
+		failedCIScore,
+	});
+
+	// Build candidate list
+	const candidates: CandidateModel[] = [];
+
+	for (const candidate of availableModels) {
+		// Skip the same provider
+		if (candidate.provider === failedModel.provider) continue;
+
+		// Skip if no auth configured for this provider
+		// (We'll assume available models have auth, but check anyway)
+		if (!candidate.baseUrl) continue;
+
+		const modelInfo = toModelInfo(candidate);
+		const family = detectModelFamily(modelInfo);
+		const normalizedName = normalizeModelName(modelInfo.name || modelInfo.id);
+		const ciScore = getHardcodedScore(candidate.name || "", candidate.id) ?? 20;
+
+		candidates.push({
+			model: candidate,
+			modelInfo,
+			ciScore,
+			normalizedName,
+			family: family?.familyId ?? "other",
+		});
+	}
+
+	if (candidates.length === 0) {
+		_logger.info("No candidate models found");
+		return null;
+	}
+
+	// Priority 1: Same model name (different provider)
+	// e.g., "minimax-m2.5" on zen → "minimax-m2.5" on openrouter
+	const sameName = candidates.find(
+		(c) => c.normalizedName === failedNormalizedName && c.model.provider !== failedModel.provider,
+	);
+	if (sameName) {
+		_logger.info("Found exact model match", {
+			provider: sameName.model.provider,
+			model: sameName.model.id,
+		});
+		return sameName;
+	}
+
+	// Priority 2: Same model family, prefer free models
+	const sameFamily = candidates
+		.filter((c) => c.family === failedFamily?.familyId && c.model.provider !== failedModel.provider)
+		.sort((a, b) => {
+			// Prefer free models
+			if (a.modelInfo.isFree !== b.modelInfo.isFree) {
+				return a.modelInfo.isFree ? -1 : 1;
+			}
+			// Then by CI score
+			return b.ciScore - a.ciScore;
+		});
+
+	if (sameFamily.length > 0) {
+		const best = sameFamily[0]!;
+		_logger.info("Found same family model", {
+			provider: best.model.provider,
+			model: best.model.id,
+			family: best.family,
+			isFree: best.modelInfo.isFree,
+			ciScore: best.ciScore,
+		});
+		return best;
+	}
+
+	// Priority 3: Any free model with similar CI score
+	// Check CI score degradation limit
+	const freeCandidates = candidates
+		.filter((c) => {
+			// Must be free
+			if (!c.modelInfo.isFree) return false;
+			// Must not drop CI score too much
+			const ciDrop = failedCIScore - c.ciScore;
+			return ciDrop <= fullConfig.maxCIScoreDrop;
+		})
+		.sort((a, b) => {
+			// Sort by CI score (closest to failed model first)
+			return b.ciScore - a.ciScore;
+		});
+
+	if (freeCandidates.length > 0) {
+		const best = freeCandidates[0]!;
+		_logger.info("Found free fallback model", {
+			provider: best.model.provider,
+			model: best.model.id,
+			ciScore: best.ciScore,
+			ciDrop: failedCIScore - best.ciScore,
+		});
+		return best;
+	}
+
+	// Priority 4: Any free model (no CI limit)
+	const anyFree = candidates
+		.filter((c) => c.modelInfo.isFree)
+		.sort((a, b) => b.ciScore - a.ciScore);
+
+	if (anyFree.length > 0) {
+		const best = anyFree[0]!;
+		_logger.info("Found any free fallback", {
+			provider: best.model.provider,
+			model: best.model.id,
+			ciScore: best.ciScore,
+		});
+		return best;
+	}
+
+	// Priority 5: Any model with similar CI score
+	const similarCI = candidates
+		.filter((c) => {
+			const ciDrop = failedCIScore - c.ciScore;
+			return ciDrop <= fullConfig.maxCIScoreDrop;
+		})
+		.sort((a, b) => {
+			// Prefer providers in priority order
+			const aPriority = fullConfig.providerPriority.indexOf(a.model.provider);
+			const bPriority = fullConfig.providerPriority.indexOf(b.model.provider);
+			if (aPriority !== bPriority && aPriority >= 0 && bPriority >= 0) {
+				return aPriority - bPriority;
+			}
+			// Then by CI score
+			return b.ciScore - a.ciScore;
+		});
+
+	if (similarCI.length > 0) {
+		const best = similarCI[0]!;
+		_logger.info("Found similar CI fallback", {
+			provider: best.model.provider,
+			model: best.model.id,
+			ciScore: best.ciScore,
+		});
+		return best;
+	}
+
+	// Last resort: any model, prefer by provider priority
+	const anyModel = candidates.sort((a, b) => {
+		const aPriority = fullConfig.providerPriority.indexOf(a.model.provider);
+		const bPriority = fullConfig.providerPriority.indexOf(b.model.provider);
+		if (aPriority !== bPriority && aPriority >= 0 && bPriority >= 0) {
+			return aPriority - bPriority;
+		}
+		return b.ciScore - a.ciScore;
+	});
+
+	if (anyModel.length > 0) {
+		const best = anyModel[0]!;
+		_logger.info("Found any fallback", {
+			provider: best.model.provider,
+			model: best.model.id,
+			ciScore: best.ciScore,
+		});
+		return best;
+	}
+
+	return null;
+}
+
+/**
+ * Perform automatic failover when a provider hits an error.
+ * Returns the result of the switch attempt.
+ */
+export async function autoFailover(
+	_errorMessage: string,
+	failedModel: Model<any>,
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	config: Partial<AutoSwitchConfig> = {},
+): Promise<AutoSwitchResult> {
+	const fullConfig = { ...DEFAULT_CONFIG, ...config };
+	if (!fullConfig.enabled) {
+		return {
+			success: false,
+			switched: false,
+			message: "Auto-switch disabled",
+		};
+	}
+
+	// Get all available models
+	const availableModels = ctx.modelRegistry.getAvailable();
+
+	if (availableModels.length === 0) {
+		return {
+			success: false,
+			switched: false,
+			message: "No alternative models available",
+		};
+	}
+
+	// Find fallback model
+	const fallback = await findFallbackModel(
+		failedModel,
+		availableModels,
+		fullConfig,
+	);
+
+	if (!fallback) {
+		return {
+			success: false,
+			switched: false,
+			message: `No fallback model found for ${failedModel.provider}/${failedModel.id}`,
+		};
+	}
+
+	// Attempt to switch
+	const success = await pi.setModel(fallback.model);
+
+	if (success) {
+		const freeStatus = fallback.modelInfo.isFree ? " (free)" : "";
+		return {
+			success: true,
+			switched: true,
+			message: `Switched from ${failedModel.provider} to ${fallback.model.provider}/${fallback.model.id}${freeStatus}`,
+			fallbackModel: fallback.modelInfo,
+		};
+	} else {
+		return {
+			success: false,
+			switched: false,
+			message: `Failed to switch to ${fallback.model.provider}/${fallback.model.id} (no API key?)`,
+			fallbackModel: fallback.modelInfo,
+		};
+	}
+}
+
+/**
+ * Check if a model is available from multiple providers
+ */
+export function getModelAvailability(
+	modelId: string,
+	availableModels: Model<any>[],
+): string[] {
+	const normalizedName = normalizeModelName(modelId);
+
+	return availableModels
+		.filter((m) => {
+			const mNormalized = normalizeModelName(m.name || m.id);
+			return mNormalized === normalizedName;
+		})
+		.map((m) => m.provider);
+}
+
+/**
+ * Get a summary of available models grouped by family
+ */
+export function getModelAvailabilitySummary(
+	availableModels: Model<any>[],
+): Map<string, string[]> {
+	const families = new Map<string, string[]>();
+
+	for (const model of availableModels) {
+		const modelInfo = toModelInfo(model);
+		const family = detectModelFamily(modelInfo);
+
+		if (!family) continue;
+
+		const existing = families.get(family.familyId) ?? [];
+		if (!existing.includes(model.provider)) {
+			existing.push(model.provider);
+		}
+		families.set(family.familyId, existing);
+	}
+
+	return families;
+}