pi-free 2.1.1 → 2.2.1

package/lib/probe-cache.ts

@@ -60,6 +60,14 @@ export function getModelsDueForProbe(
 	});
 }
 
+export function areAllModelsFresh(
+	providerId: string,
+	modelIds: string[],
+	ttlMs = DEFAULT_PROBE_TTL_MS,
+): boolean {
+	return getModelsDueForProbe(providerId, modelIds, ttlMs).length === 0;
+}
+
 export async function recordModelProbeResults(
 	providerId: string,
 	results: ModelProbeResult[],

package/lib/provider-probe.ts

@@ -24,6 +24,7 @@ import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { updateConfig } from "../config.ts";
 import { createLogger } from "./logger.ts";
 import {
+	areAllModelsFresh,
 	getModelsDueForProbe,
 	recordModelProbeResults,
 	type ModelProbeResult,
@@ -175,6 +176,20 @@ export function createProviderProbe(
 		return () => {
 			if (done) return;
 			done = true;
+
+			// Skip scheduling entirely if every model was probed recently.
+			// Without this check the handler fires on every session_start and
+			// only then discovers the cache is fresh inside run().
+			if (
+				areAllModelsFresh(
+					providerId,
+					models.map((m) => m.id),
+				)
+			) {
+				_logger.info(`[probe] ${providerId}: auto-probe cache is fresh`);
+				return;
+			}
+
 			_logger.info(`[probe] Starting lazy auto-probe for ${providerId}...`);
 			run(apiKey, models, { useCache: true }).catch((err) => {
 				_logger.warn(`[probe] ${providerId}: auto-probe failed`, {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-free",
-	"version": "2.1.1",
+	"version": "2.2.1",
 	"type": "module",
 	"description": "AI model providers for Pi with free model filtering and dynamic model fetching",
 	"keywords": [
@@ -55,14 +55,14 @@
 		"smoke:cline": "tsx scripts/smoke-cline-xml-bridge.ts"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-ai": "*",
-		"@earendil-works/pi-coding-agent": "*",
-		"@earendil-works/pi-tui": "*"
+		"@earendil-works/pi-ai": "^0.79.8",
+		"@earendil-works/pi-coding-agent": "^0.79.8",
+		"@earendil-works/pi-tui": "^0.79.8"
 	},
 	"devDependencies": {
 		"@vitest/ui": "^4.1.5",
 		"tsx": "^4.0.0",
-		"typescript": "^6.0.2",
+		"typescript": "^6.0.3",
 		"vitest": "^4.1.5"
 	},
 	"pi": {

package/providers/bai/bai.ts

@@ -0,0 +1,232 @@
+/**
+ * B.AI Provider Extension
+ *
+ * B.AI (https://b.ai) is an OpenAI-compatible LLM gateway providing access
+ * to many models (OpenAI, Anthropic, Google, DeepSeek, Qwen, GLM, Kimi).
+ *
+ * API: https://api.b.ai/v1
+ * Models: /v1/models
+ * Chat: /v1/chat/completions
+ *
+ * Pricing is not exposed via the /v1/models endpoint, so all models
+ * default to cost=0. The `isFreeModel` Route B detection (name contains
+ * "free") is therefore used. As a result, with `free_only: true` no b.ai
+ * models will be visible until you run `/toggle-bai` to enable paid models.
+ *
+ * A small set of known-promotional models are hardcoded as known-free so
+ * they remain visible even when free-only mode is on (mirrors the
+ * TokenRouter approach for `MiniMax-M3`).
+ *
+ * Setup:
+ *   BAI_API_KEY=sk-...
+ *   # or add bai_api_key to ~/.pi/free.json
+ */
+
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@earendil-works/pi-coding-agent";
+import { getBaiApiKey, getBaiShowPaid, applyHidden } from "../../config.ts";
+import {
+	BASE_URL_BAI,
+	DEFAULT_FETCH_TIMEOUT_MS,
+	PROVIDER_BAI,
+} from "../../constants.ts";
+import { createLogger } from "../../lib/logger.ts";
+import { safeEnrichModelsWithModelsDev } from "../../lib/model-metadata.ts";
+import {
+	getProxyModelCompat,
+	isLikelyReasoningModel,
+} from "../../lib/provider-compat.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { cleanModelName, fetchWithRetry } from "../../lib/util.ts";
+import { createReRegister, setupProvider } from "../../provider-helper.ts";
+
+const _logger = createLogger("bai");
+
+// =============================================================================
+// Known Free Models
+// B.AI doesn't expose pricing via /v1/models, so known-free models are
+// hardcoded. The site currently advertises `MiniMax-M3` as a limited-time
+// free promotional model; we hardcode that alias and any future `:free`
+// suffixed IDs (catches dynamic promotional additions).
+// =============================================================================
+
+const BAI_KNOWN_FREE_MODELS = new Set(["minimax-m3", "MiniMax-M3"]);
+
+function isBaiKnownFree(modelId: string): boolean {
+	if (BAI_KNOWN_FREE_MODELS.has(modelId)) return true;
+	// Catch any future `:free` suffixed model the gateway advertises
+	return modelId.toLowerCase().endsWith(":free");
+}
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface BaiModel {
+	id: string;
+	object?: string;
+	created?: number;
+	owned_by?: string;
+	supported_endpoint_types?: string[];
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/** Text-capable chat endpoints (excludes image/video/audio-only types) */
+const CHAT_ENDPOINT_TYPES = new Set([
+	"openai",
+	"openai-response",
+	"anthropic",
+	"anthropic-compatible",
+	"gemini",
+]);
+
+function isTextChatModel(model: BaiModel): boolean {
+	const endpoints = model.supported_endpoint_types ?? [];
+	if (endpoints.length === 0) {
+		// No endpoint info — assume text chat (matches TokenRouter fallback)
+		return true;
+	}
+	return endpoints.some((t) => CHAT_ENDPOINT_TYPES.has(t));
+}
+
+function mapBaiModel(model: BaiModel): ProviderModelConfig & {
+	_pricingKnown?: boolean;
+	_freeKnown?: boolean;
+	_isFree?: boolean;
+} {
+	const name = cleanModelName(model.id);
+	const reasoning = isLikelyReasoningModel({ id: model.id, name });
+	const isKnownFree = isBaiKnownFree(model.id);
+
+	return {
+		id: model.id,
+		name,
+		reasoning,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 128_000,
+		maxTokens: 16_384,
+		compat: getProxyModelCompat({ id: model.id, name }),
+		// Known-free models bypass name-based detection entirely
+		_freeKnown: isKnownFree,
+		_isFree: isKnownFree,
+		// Non-free models signal no pricing data (name-based detection only)
+		_pricingKnown: false,
+	} as ProviderModelConfig & {
+		_pricingKnown?: boolean;
+		_freeKnown?: boolean;
+		_isFree?: boolean;
+	};
+}
+
+// =============================================================================
+// Fetch Models
+// =============================================================================
+
+async function fetchBaiModels(apiKey: string): Promise<ProviderModelConfig[]> {
+	_logger.info("[bai] Fetching models from B.AI API...");
+
+	try {
+		const response = await fetchWithRetry(
+			`${BASE_URL_BAI}/models`,
+			{
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					Accept: "application/json",
+					"Content-Type": "application/json",
+				},
+			},
+			3,
+			1000,
+			DEFAULT_FETCH_TIMEOUT_MS,
+		);
+
+		if (!response.ok) {
+			throw new Error(`B.AI API error: ${response.status}`);
+		}
+
+		const json = (await response.json()) as { data?: BaiModel[] };
+		const models = (json.data ?? []).filter(isTextChatModel);
+
+		_logger.info(`[bai] Fetched ${models.length} text chat models`);
+		const enriched = await safeEnrichModelsWithModelsDev(
+			models.map(mapBaiModel),
+			{ providerId: PROVIDER_BAI },
+		);
+		return applyHidden(enriched, PROVIDER_BAI);
+	} catch (error) {
+		_logger.error("[bai] Failed to fetch models", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return [];
+	}
+}
+
+// =============================================================================
+// Extension Entry Point
+// =============================================================================
+
+export default async function baiProvider(pi: ExtensionAPI) {
+	const apiKey = getBaiApiKey();
+
+	if (!apiKey) {
+		_logger.info(
+			"[bai] Skipping — BAI_API_KEY not set. Sign up at https://b.ai/",
+		);
+		return;
+	}
+
+	const allModels = await fetchBaiModels(apiKey);
+
+	if (allModels.length === 0) {
+		_logger.warn("[bai] No text chat models available");
+		return;
+	}
+
+	// Use isFreeModel with allModels for proper detection
+	// B.AI doesn't expose pricing, so Route B (name-based) applies:
+	// FREE if name contains "free" OR _isFree is true (known-free hardcoded).
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_BAI }, allModels),
+	);
+	const stored = { free: freeModels, all: allModels };
+
+	_logger.info(
+		`[bai] Registered ${allModels.length} models (${freeModels.length} free)`,
+	);
+
+	const reRegister = createReRegister(pi, {
+		providerId: PROVIDER_BAI,
+		baseUrl: BASE_URL_BAI,
+		apiKey,
+	});
+
+	registerWithGlobalToggle(PROVIDER_BAI, stored, reRegister, true);
+
+	setupProvider(
+		pi,
+		{
+			providerId: PROVIDER_BAI,
+			initialShowPaid: getBaiShowPaid(),
+			tosUrl: "https://b.ai/",
+			reRegister: (models, _stored) => {
+				if (_stored) {
+					stored.free = _stored.free;
+					stored.all = _stored.all;
+				}
+				reRegister(models);
+			},
+		},
+		stored,
+	);
+
+	const showPaid = getBaiShowPaid();
+	const initialModels =
+		showPaid && stored.all.length > 0 ? stored.all : freeModels;
+	reRegister(initialModels);
+}

package/providers/cline/cline-xml-bridge.ts

@@ -315,10 +315,25 @@ function replaceInFileBridge(tool?: Tool): ToolBridge {
 		description:
 			tool?.description ?? "Edit a file using Cline SEARCH/REPLACE blocks",
 		parameters: ["path", "diff"],
-		toRuntimeArgs: (args) => ({
-			path: stringArg(args, "path"),
-			edits: parseSearchReplaceBlocks(stringArg(args, "diff")),
-		}),
+		toRuntimeArgs: (args) => {
+			// Pi native <edit> form sends <edits>[{oldText,newText},...]</edits>
+			// as JSON. Cline <replace_in_file> form uses SEARCH/REPLACE <diff>.
+			if (Array.isArray(args.edits)) {
+				return {
+					path: stringArg(args, "path"),
+					edits: args.edits
+						.map((edit) => ({
+							oldText: stringArg(edit as Record<string, unknown>, "oldText"),
+							newText: stringArg(edit as Record<string, unknown>, "newText"),
+						}))
+						.filter((edit) => edit.oldText || edit.newText),
+				};
+			}
+			return {
+				path: stringArg(args, "path"),
+				edits: parseSearchReplaceBlocks(stringArg(args, "diff")),
+			};
+		},
 		fromRuntimeArgs: (args) => {
 			const edits = Array.isArray(args.edits)
 				? args.edits
@@ -949,10 +964,20 @@ function parseXmlToolCalls(
 	rawText: string,
 	tools: Tool[] | undefined,
 ): ParsedToolCalls {
+	const bridges = getParseToolBridges(tools);
 	const bridgeByRemoteName = new Map(
-		getParseToolBridges(tools).map((bridge) => [bridge.remoteName, bridge]),
+		bridges.map((bridge) => [bridge.remoteName, bridge]),
+	);
+	// Some Cline/MiMo variants use the Pi runtime tool name (e.g. <edit>,
+	// <write>) instead of the Cline XML name (<replace_in_file>, <write_to_file>).
+	// Register runtime names as aliases so both forms are recognised.
+	const bridgeByName = new Map(
+		bridges.flatMap((bridge) => [
+			[bridge.remoteName, bridge],
+			[bridge.runtimeName, bridge],
+		]),
 	);
-	const toolNames = new Set(bridgeByRemoteName.keys());
+	const toolNames = new Set(bridgeByName.keys());
 
 	// Extract <function=name> Pi SDK tool calls directly (no Cline XML intermediate)
 	const fnResult = extractFunctionTagToolCalls(rawText, bridgeByRemoteName);
@@ -972,7 +997,9 @@ function parseXmlToolCalls(
 	while (cursor < sourceText.length) {
 		const next = findNextToolStart(sourceText, toolNames, cursor);
 		if (!next) break;
-		const closeTag = `</${next.name}>`;
+		const bridge = bridgeByName.get(next.name);
+		const remoteName = bridge?.remoteName ?? next.name;
+		const closeTag = `</${remoteName}>`;
 		const closeStart = sourceText.indexOf(
 			closeTag,
 			next.index + next.openTag.length,
@@ -980,11 +1007,10 @@ function parseXmlToolCalls(
 		pushTextFragment(textParts, sourceText.slice(cursor, next.index));
 		const blockEnd = closeStart === -1 ? sourceText.length : closeStart;
 		const block = sourceText.slice(next.index + next.openTag.length, blockEnd);
-		const bridge = bridgeByRemoteName.get(next.name);
 		const remoteArgs = parseToolArguments(block);
 		const writeRuntimeName = getWriteRuntimeToolName(tools);
 		const heredocWrite =
-			next.name === "execute_command" && writeRuntimeName
+			remoteName === "execute_command" && writeRuntimeName
 				? parseCatHeredocWriteCommand(stringArg(remoteArgs, "command"))
 				: undefined;
 		if (heredocWrite && writeRuntimeName) {
@@ -1003,7 +1029,10 @@ function parseXmlToolCalls(
 	}
 
 	pushTextFragment(textParts, sourceText.slice(cursor));
-	return { text: textParts.join("\n\n").trim(), toolCalls: [...fnResult.toolCalls, ...toolCalls] };
+	return {
+		text: textParts.join("\n\n").trim(),
+		toolCalls: [...fnResult.toolCalls, ...toolCalls],
+	};
 }
 
 function parseReasoningHiddenToolCalls(
@@ -1393,7 +1422,10 @@ export function streamClineXml(
 					thinking,
 					currentContext.tools,
 				);
-				const parsed = parseXmlToolCalls(extractedThinking.text, currentContext.tools);
+				const parsed = parseXmlToolCalls(
+					extractedThinking.text,
+					currentContext.tools,
+				);
 				output = prepareClineXmlOutput(
 					parsed.text,
 					extractedThinking.thinking,
@@ -1404,10 +1436,7 @@ export function streamClineXml(
 				// Reasoning-only response: MiMo stopped without producing visible
 				// text or tool calls. Auto-retry once with a "continue" nudge
 				// instead of showing a dead-end error to the user.
-				if (
-					output.visibleText === INTERNAL_ONLY_RESPONSE &&
-					attempt === 0
-				) {
+				if (output.visibleText === INTERNAL_ONLY_RESPONSE && attempt === 0) {
 					currentContext = {
 						...context,
 						messages: [

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

@@ -45,6 +45,7 @@ import { createLogger } from "../../lib/logger.ts";
 import { safeEnrichModelsWithModelsDev } from "../../lib/model-metadata.ts";
 import { getProxyModelCompat } from "../../lib/provider-compat.ts";
 import {
+	areAllModelsFresh,
 	getModelsDueForProbe,
 	recordModelProbeResults,
 } from "../../lib/probe-cache.ts";
@@ -605,6 +606,17 @@ async function registerProvider(
 			wrapSessionStartHandler(`${config.providerId}-auto-probe`, async () => {
 				if (_autoProbeDone) return;
 				_autoProbeDone = true;
+				if (
+					areAllModelsFresh(
+						config.providerId,
+						stored.free.map((m) => m.id),
+					)
+				) {
+					_logger.info(
+						`[probe] ${config.providerId}: auto-probe cache is fresh`,
+					);
+					return;
+				}
 				_logger.info(
 					`Starting lazy auto-probe of ${config.providerId} free models...`,
 				);

package/providers/ollama/ollama.ts

@@ -43,6 +43,7 @@ import {
 } from "../../lib/provider-cache.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import {
+	areAllModelsFresh,
 	getModelsDueForProbe,
 	recordModelProbeResults,
 } from "../../lib/probe-cache.ts";
@@ -592,6 +593,18 @@ export default async function ollamaProvider(pi: ExtensionAPI) {
 	});
 
 	const runProbeInBackground = (models: ProviderModelConfig[]) => {
+		// Skip scheduling entirely if every model was probed recently.
+		// Without this check the probe runs on every session_start and
+		// only then discovers the cache is fresh inside runOllamaProbe.
+		if (
+			areAllModelsFresh(
+				PROVIDER_OLLAMA,
+				models.map((m) => m.id),
+			)
+		) {
+			_logger.info("Auto-probe: Ollama probe cache is fresh");
+			return;
+		}
 		runOllamaProbe(apiKey, models, applyModelList, { useCache: true }).catch(
 			(error) => {
 				_logger.warn("Auto-probe failed", {

package/providers/routeway/routeway.ts

@@ -37,6 +37,7 @@ import {
 	isLikelyReasoningModel,
 } from "../../lib/provider-compat.ts";
 import {
+	areAllModelsFresh,
 	getModelsDueForProbe,
 	recordModelProbeResults,
 } from "../../lib/probe-cache.ts";
@@ -350,6 +351,15 @@ export default async function routewayProvider(pi: ExtensionAPI) {
 		wrapSessionStartHandler("routeway", async () => {
 			if (_autoProbeDone || !apiKey) return;
 			_autoProbeDone = true;
+			if (
+				areAllModelsFresh(
+					PROVIDER_ROUTEWAY,
+					allModels.map((m) => m.id),
+				)
+			) {
+				_logger.info("Auto-probe: Routeway probe cache is fresh");
+				return;
+			}
 			_logger.info("Starting lazy auto-probe of Routeway models...");
 			runRoutewayProbe(apiKey, allModels, stored, reRegister, {
 				useCache: true,