pi-free 2.0.2 → 2.0.5

package/lib/model-detection.ts

@@ -60,6 +60,83 @@ export function toProviderModelInfo(model: ProviderModelConfig): ModelInfo {
 	};
 }
 
+// =============================================================================
+// Shared helpers for model family detection
+// =============================================================================
+
+const VERSION_RE = /^v?\d+(\.\d+)?$/;
+const ROUTER_RE = /\b(?:router|auto)\b/;
+const SKIP_PARTS = new Set([
+	"latest",
+	"preview",
+	"rc",
+	"beta",
+	"alpha",
+	"dev",
+	"free",
+]);
+
+interface BrandMapping {
+	keywords: string[];
+	familyId: string;
+	familyName: string;
+}
+
+const BRAND_MAPPINGS: BrandMapping[] = [
+	{ 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" },
+];
+
+const PROVIDER_MAPPINGS: 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" },
+};
+
+function capitalize(s: string): string {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+function findBrandInText(
+	text: string,
+): { familyId: string; familyName: string } | null {
+	for (const mapping of BRAND_MAPPINGS) {
+		for (const keyword of mapping.keywords) {
+			if (text.includes(keyword)) {
+				return { familyId: mapping.familyId, familyName: mapping.familyName };
+			}
+		}
+	}
+	return null;
+}
+
+function findBrandInParts(
+	parts: string[],
+): { familyId: string; familyName: string } | null {
+	for (const part of parts) {
+		const result = findBrandInText(part);
+		if (result) return result;
+	}
+	return null;
+}
+
 /**
  * Detect the model family from a model's ID or name.
  * Returns the family ID and display name.
@@ -72,116 +149,41 @@ export function detectModelFamily(
 	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") {
+	if (ROUTER_RE.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 };
-			}
-		}
-	}
+	// Known brand keywords in full text
+	const brandFromText = findBrandInText(fullText);
+	if (brandFromText) return brandFromText;
 
 	// 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;
-	}
+	const providerResult = PROVIDER_MAPPINGS[model.provider];
+	if (providerResult) return providerResult;
 
-	// Smart fallback: try to identify brand from model ID structure
+	// 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;
-		}
+	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),
-			};
-		}
+	// Use first part as brand if it looks brand-like
+	if (firstPart && !VERSION_RE.test(firstPart)) {
+		return { familyId: firstPart, familyName: capitalize(firstPart) };
 	}
 
-	// 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),
-				};
-			}
-		}
+	// First non-version, non-skip part
+	const nonVersion = parts.find(
+		(p) => p && !VERSION_RE.test(p) && !SKIP_PARTS.has(p),
+	);
+	if (nonVersion) {
+		return { familyId: nonVersion, familyName: capitalize(nonVersion) };
 	}
 
 	return {
 		familyId: firstPart || id,
-		familyName: (firstPart || id).charAt(0).toUpperCase() + (firstPart || id).slice(1),
+		familyName: capitalize(firstPart || id),
 	};
 }
 
@@ -189,21 +191,83 @@ export function detectModelFamily(
  * 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.
+ *
+ * Uses string operations instead of regex backtracking to avoid ReDoS warnings.
  */
 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()
-	);
+	const suffixes = ["(free)", "(cline)", "-free", "free"];
+	let normalized = name.toLowerCase().trimEnd();
+
+	// Remove common literal suffixes — simple string ops, no regex backtracking
+	for (const suffix of suffixes) {
+		while (normalized.endsWith(suffix)) {
+			normalized = normalized.slice(0, -suffix.length).trimEnd();
+		}
+	}
+
+	// CI score suffix — regex with disjoint char classes (linear)
+	normalized = normalized.replace(/\(ci:\s*[\d.]+\)$/, "").trimEnd();
+	normalized = normalized.replace(/\[ci:\s*[\d.]+\]$/, "").trimEnd();
+
+	// Remove any trailing parenthetical — non-regex loop
+	while (normalized.endsWith(")")) {
+		const idx = normalized.lastIndexOf("(", normalized.length - 1);
+		if (idx === -1) break;
+		normalized = normalized.slice(0, idx).trimEnd();
+	}
+
+	return normalized.trim();
+}
+
+/**
+ * Try to merge a model into another family if its normalized name
+ * matches a model in a different family.
+ */
+function tryMergeFamily(
+	byFamily: Map<string, ModelInfo[]>,
+	nameToFamilyId: Map<string, string>,
+	familyId: string,
+	model: ModelInfo,
+): boolean {
+	const normalizedName = normalizeModelName(model.name || model.id);
+	if (!normalizedName) return false;
+
+	const existingFamilyForName = nameToFamilyId.get(normalizedName);
+	if (!existingFamilyForName || existingFamilyForName === familyId) {
+		nameToFamilyId.set(normalizedName, familyId);
+		return false;
+	}
+
+	// Same model name found in different family - merge them
+	const targetFamily = byFamily.get(existingFamilyForName);
+	const sourceFamily = byFamily.get(familyId);
+	if (!targetFamily || !sourceFamily) return false;
+
+	targetFamily.push(...sourceFamily);
+	byFamily.delete(familyId);
+	return true;
+}
+
+/**
+ * Build a sorted list of ModelFamily from a by-family grouping map.
+ */
+function buildFamiliesList(byFamily: Map<string, ModelInfo[]>): ModelFamily[] {
+	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));
 }
 
 /**
@@ -214,6 +278,7 @@ export function getModelFamilies(models: ModelInfo[]): ModelFamily[] {
 	const byFamily = new Map<string, ModelInfo[]>();
 	const nameToFamilyId = new Map<string, string>();
 
+	// First pass: group models by detected family
 	for (const model of models) {
 		const family = detectModelFamily(model);
 		if (!family) continue;
@@ -223,46 +288,18 @@ export function getModelFamilies(models: ModelInfo[]): ModelFamily[] {
 		byFamily.set(family.familyId, existing);
 	}
 
-	// Second pass: merge families with models that have the same normalized name
+	// Second pass: merge families whose models 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);
+			if (tryMergeFamily(byFamily, nameToFamilyId, familyId, model)) {
+				break;
 			}
 		}
 	}
 
-	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));
+	return buildFamiliesList(byFamily);
 }

package/lib/model-enhancer.ts

@@ -1,20 +1,20 @@
-/**
- * Model name enhancement helper
- * Adds Coding Index scores to model names for display in /model
- */
-
-import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
-import { enhanceModelNameWithCodingIndex } from "../provider-failover/benchmark-lookup.ts";
-
-/**
- * Enhance model names with Coding Index scores
- * Use this before registering providers to show CI in /model list
- */
-export function enhanceModelsWithCodingIndex(
-	models: ProviderModelConfig[],
-): ProviderModelConfig[] {
-	return models.map((m) => ({
-		...m,
-		name: enhanceModelNameWithCodingIndex(m.name, m.id),
-	}));
-}
+/**
+ * Model name enhancement helper
+ * Adds Coding Index scores to model names for display in /model
+ */
+
+import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
+import { enhanceModelNameWithCodingIndex } from "../provider-failover/benchmark-lookup.ts";
+
+/**
+ * Enhance model names with Coding Index scores
+ * Use this before registering providers to show CI in /model list
+ */
+export function enhanceModelsWithCodingIndex(
+	models: ProviderModelConfig[],
+): ProviderModelConfig[] {
+	return models.map((m) => ({
+		...m,
+		name: enhanceModelNameWithCodingIndex(m.name, m.id),
+	}));
+}

package/lib/open-browser.ts

@@ -25,7 +25,7 @@ export function openBrowser(url: string): void {
 					"-NoProfile",
 					"-NonInteractive",
 					"-Command",
-					`Start-Process "${url.replace(/"/g, '\\"')}"`,
+					`Start-Process "${url.replace(/[\\"]/g, "\\$&")}"`,
 				],
 				{ detached: true, shell: false, windowsHide: true },
 			).unref();

package/lib/provider-compat.ts

@@ -0,0 +1,46 @@
+import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
+
+export interface ProviderModelIdentity {
+	id: string;
+	name?: string;
+}
+
+export const DEEPSEEK_PROXY_COMPAT: NonNullable<ProviderModelConfig["compat"]> =
+	{
+		supportsStore: false,
+		supportsDeveloperRole: false,
+		supportsReasoningEffort: true,
+		requiresReasoningContentOnAssistantMessages: true,
+		thinkingFormat: "deepseek",
+	};
+
+export function isDeepSeekModel(model: ProviderModelIdentity): boolean {
+	const haystack = `${model.id} ${model.name ?? ""}`.toLowerCase();
+	return haystack.includes("deepseek");
+}
+
+export function isLikelyReasoningModel(model: ProviderModelIdentity): boolean {
+	const haystack = `${model.id} ${model.name ?? ""}`.toLowerCase();
+	return (
+		isDeepSeekModel(model) ||
+		haystack.includes("thinking") ||
+		haystack.includes("reasoning") ||
+		haystack.includes("reasoner") ||
+		haystack.includes("r1") ||
+		haystack.includes("qwq")
+	);
+}
+
+/**
+ * For gateway/proxy providers that mask the upstream DeepSeek base URL,
+ * add explicit compat so pi-ai preserves and replays reasoning_content.
+ */
+export function getProxyModelCompat(
+	model: ProviderModelIdentity,
+): ProviderModelConfig["compat"] | undefined {
+	if (isDeepSeekModel(model)) {
+		return DEEPSEEK_PROXY_COMPAT;
+	}
+
+	return undefined;
+}