pi-free 2.0.14 → 2.1.0

package/providers/ollama/ollama.ts

@@ -36,9 +36,12 @@ import {
 } from "../../constants.ts";
 import { createLogger } from "../../lib/logger.ts";
 import {
+	DEFAULT_PROVIDER_CACHE_TTL_MS,
+	isProviderCacheFresh,
 	loadProviderCache,
 	saveProviderCache,
 } from "../../lib/provider-cache.ts";
+import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import {
 	getModelsDueForProbe,
 	recordModelProbeResults,
@@ -427,7 +430,7 @@ async function runOllamaProbe(
 		}
 	}
 
-	recordModelProbeResults(PROVIDER_OLLAMA, cacheableResults);
+	await recordModelProbeResults(PROVIDER_OLLAMA, cacheableResults);
 
 	if (notFound.length === 0) {
 		_logger.info("Auto-probe: all checked Ollama models are accessible");
@@ -445,7 +448,7 @@ async function runOllamaProbe(
 	// Re-fetch and re-register so hidden models disappear immediately
 	try {
 		const fresh = await fetchAllModels(apiKey);
-		saveProviderCache(PROVIDER_OLLAMA, fresh);
+		await saveProviderCache(PROVIDER_OLLAMA, fresh);
 		applyModels(fresh);
 	} catch {
 		// If refresh fails, keep current models. The next refresh/probe will retry.
@@ -517,14 +520,14 @@ export default async function ollamaProvider(pi: ExtensionAPI) {
 	_logger.info(
 		`[ollama-cloud] Registered ${initialModels.length} models` +
 			(fromCache ? " (from cache)" : " (fallback)") +
-			", fetching fresh in background...",
+			", refresh scheduled on session start...",
 	);
 
 	// ── Background refresh ─────────────────────────────────────────
 	async function refreshModels(): Promise<ProviderModelConfig[]> {
 		try {
 			const freshModels = await fetchAllModels(apiKey!);
-			saveProviderCache(PROVIDER_OLLAMA, freshModels);
+			await saveProviderCache(PROVIDER_OLLAMA, freshModels);
 			return freshModels;
 		} catch (error) {
 			_logger.error("[ollama-cloud] Background refresh failed", {
@@ -543,7 +546,7 @@ export default async function ollamaProvider(pi: ExtensionAPI) {
 			ctx.ui.notify("Refreshing Ollama Cloud models…", "info");
 			try {
 				const fresh = await fetchAllModels(apiKey!);
-				saveProviderCache(PROVIDER_OLLAMA, fresh);
+				await saveProviderCache(PROVIDER_OLLAMA, fresh);
 				applyModelList(fresh);
 				ctx.ui.notify(
 					`Registered ${fresh.length} Ollama Cloud models (refresh complete)`,
@@ -601,30 +604,51 @@ export default async function ollamaProvider(pi: ExtensionAPI) {
 		ctx.ui.setStatus(`${PROVIDER_OLLAMA}-status`, `ollama: ${count} models`);
 	});
 
+	const runProbeInBackground = (models: ProviderModelConfig[]) => {
+		runOllamaProbe(apiKey, models, applyModelList, { useCache: true }).catch(
+			(error) => {
+				_logger.warn("Auto-probe failed", {
+					error: error instanceof Error ? error.message : String(error),
+				});
+			},
+		);
+	};
+
 	// ── Background refresh on session_start ─────────────────────────
-	let bgRefreshed = false;
+	let refreshInFlight: Promise<void> | undefined;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	pi.on("session_start" as any, async (_event: any, ctx: any) => {
-		if (bgRefreshed) {
-			return;
-		}
-		bgRefreshed = true;
+	pi.on(
+		"session_start" as any,
+		wrapSessionStartHandler("ollama-cloud", (_event: any, ctx: any) => {
+			if (refreshInFlight) return Promise.resolve();
+
+			if (
+				isProviderCacheFresh(PROVIDER_OLLAMA, DEFAULT_PROVIDER_CACHE_TTL_MS)
+			) {
+				_logger.info(
+					"session_start: Ollama Cloud cache is fresh; skipping refresh",
+				);
+				runProbeInBackground(allModels);
+				return Promise.resolve();
+			}
 
-		try {
-			const fresh = await refreshModels();
-			applyModelList(fresh);
-			ctx.ui.notify(`Ollama Cloud: ${fresh.length} models ready`, "info");
-			runOllamaProbe(apiKey, fresh, applyModelList, { useCache: true }).catch(
-				(error) => {
-					_logger.warn("Auto-probe failed", {
+			refreshInFlight = refreshModels()
+				.then((fresh) => {
+					applyModelList(fresh);
+					ctx.ui.notify(`Ollama Cloud: ${fresh.length} models ready`, "info");
+					runProbeInBackground(fresh);
+				})
+				.catch((error) => {
+					_logger.warn("Background refresh failed", {
 						error: error instanceof Error ? error.message : String(error),
 					});
-				},
-			);
-		} catch {
-			// Already logged in refreshModels()
-		}
-	});
+				})
+				.finally(() => {
+					refreshInFlight = undefined;
+				});
+			return Promise.resolve();
+		}),
+	);
 }
 
 // =============================================================================

package/providers/opencode-session.ts

@@ -352,6 +352,18 @@ export function createOpenCodeStreamSimple(
 		const headers = createOpenCodeHeaders(tracker, options?.headers);
 		const stream = new DeferredAssistantMessageEventStream();
 
+		// Sanitize context messages for Anthropic/OpenAI compatibility.
+		// OpenCode proxies to Anthropic which strictly enforces alternating
+		// user/assistant turns. This fixes consecutive assistant messages,
+		// leading assistant messages, and trailing assistant messages.
+		const sanitizedMessages = sanitizeMessagesForOpenCode(
+			context.messages as unknown[],
+		);
+		const sanitizedContext: Context = {
+			...context,
+			messages: sanitizedMessages as Context["messages"],
+		};
+
 		void (async () => {
 			try {
 				if (isAnthropicOpenCodeEndpoint(model)) {
@@ -364,7 +376,7 @@ export function createOpenCodeStreamSimple(
 								...model,
 								api: "anthropic-messages",
 							} as Model<"anthropic-messages">,
-							context,
+							sanitizedContext,
 							{ ...options, headers },
 						),
 					);
@@ -382,7 +394,7 @@ export function createOpenCodeStreamSimple(
 							...model,
 							api: "openai-completions",
 						} as Model<"openai-completions">,
-						context,
+						sanitizedContext,
 						{ ...options, headers },
 					),
 				);
@@ -396,3 +408,56 @@ export function createOpenCodeStreamSimple(
 		return stream as unknown as AssistantMessageEventStream;
 	};
 }
+
+/**
+ * Sanitize message history for OpenCode's backends.
+ *
+ * OpenCode proxies to Anthropic and OpenAI. Anthropic strictly enforces
+ * alternating user/assistant turns and rejects:
+ *   - consecutive assistant messages
+ *   - conversations that start with assistant
+ *   - conversations that end with assistant
+ *
+ * This sanitizer fixes all three issues with minimal placeholder messages.
+ */
+export function sanitizeMessagesForOpenCode(messages: unknown[]): unknown[] {
+	if (!Array.isArray(messages)) return messages;
+
+	const sanitized: unknown[] = [];
+	let hasNonSystem = false;
+
+	for (const raw of messages) {
+		if (!raw || typeof raw !== "object") continue;
+		const msg = raw as { role?: string; content?: unknown };
+		const role = msg.role;
+		if (!role) continue;
+
+		if (role === "system") {
+			sanitized.push(raw);
+			continue;
+		}
+
+		// Skip leading assistant messages before any user/tool message
+		if (role === "assistant" && !hasNonSystem) continue;
+
+		hasNonSystem = true;
+
+		// Insert placeholder user message between consecutive assistant messages
+		const last = sanitized[sanitized.length - 1] as
+			| { role?: string }
+			| undefined;
+		if (role === "assistant" && last?.role === "assistant") {
+			sanitized.push({ role: "user", content: " " });
+		}
+
+		sanitized.push(raw);
+	}
+
+	// Ensure conversation ends with a user message
+	const last = sanitized[sanitized.length - 1] as { role?: string } | undefined;
+	if (last?.role === "assistant") {
+		sanitized.push({ role: "user", content: " " });
+	}
+
+	return sanitized;
+}

package/providers/routeway/routeway.ts

@@ -18,7 +18,12 @@ import type {
 	ExtensionAPI,
 	ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
-import { getRoutewayApiKey, getRoutewayShowPaid } from "../../config.ts";
+import {
+	getRoutewayApiKey,
+	getRoutewayShowPaid,
+	loadConfigFile,
+	saveConfig,
+} from "../../config.ts";
 import {
 	BASE_URL_ROUTEWAY,
 	DEFAULT_FETCH_TIMEOUT_MS,
@@ -26,12 +31,19 @@ import {
 } from "../../constants.ts";
 import { applyHidden } from "../../config.ts";
 import { createLogger } from "../../lib/logger.ts";
+import { safeEnrichModelsWithModelsDev } from "../../lib/model-metadata.ts";
 import {
 	getProxyModelCompat,
 	isLikelyReasoningModel,
 } from "../../lib/provider-compat.ts";
+import {
+	getModelsDueForProbe,
+	recordModelProbeResults,
+} from "../../lib/probe-cache.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { cleanModelName, fetchWithRetry } from "../../lib/util.ts";
+import { fetchWithTimeout } from "../../lib/util.ts";
 import { createReRegister, setupProvider } from "../../provider-helper.ts";
 
 const _logger = createLogger("routeway");
@@ -146,7 +158,13 @@ async function fetchRoutewayModels(
 		const models = (json.data ?? []).filter(isChatModel);
 
 		_logger.info(`[routeway] Fetched ${models.length} chat models`);
-		return applyHidden(models.map(mapRoutewayModel), PROVIDER_ROUTEWAY);
+		const enriched = await safeEnrichModelsWithModelsDev(
+			models.map(mapRoutewayModel),
+			{
+				providerId: PROVIDER_ROUTEWAY,
+			},
+		);
+		return applyHidden(enriched, PROVIDER_ROUTEWAY);
 	} catch (error) {
 		_logger.error("[routeway] Failed to fetch models", {
 			error: error instanceof Error ? error.message : String(error),
@@ -155,6 +173,125 @@ async function fetchRoutewayModels(
 	}
 }
 
+// =============================================================================
+// Probe
+// =============================================================================
+
+async function probeRoutewayModel(
+	apiKey: string,
+	modelId: string,
+): Promise<"ok" | "broken" | "unknown"> {
+	try {
+		const response = await fetchWithTimeout(
+			`${BASE_URL_ROUTEWAY}/chat/completions`,
+			{
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json",
+					"User-Agent": "pi-free-providers",
+				},
+				body: JSON.stringify({
+					model: modelId,
+					messages: [{ role: "user", content: "hi" }],
+					max_tokens: 1,
+				}),
+			},
+			10000, // 10 second timeout
+		);
+
+		// 5xx = upstream server error (model unavailable)
+		if (response.status >= 500) return "broken";
+		// 404 = model not found / not provisioned
+		if (response.status === 404) return "broken";
+		// 429 = rate limited (model works)
+		if (response.status === 429) return "ok";
+		// 401 = auth issue (model exists, key issue)
+		if (response.status === 401) return "ok";
+		// 400 = bad request (model exists, param issue)
+		if (response.status === 400) return "ok";
+		// 200 = success
+		if (response.ok) return "ok";
+		return "ok";
+	} catch {
+		return "unknown";
+	}
+}
+
+async function runRoutewayProbe(
+	apiKey: string,
+	modelsToTest: ProviderModelConfig[],
+	stored: { free: ProviderModelConfig[]; all: ProviderModelConfig[] },
+	reRegister: (models: ProviderModelConfig[]) => void,
+	options: { useCache?: boolean } = {},
+): Promise<string[]> {
+	const modelIdsToProbe = options.useCache
+		? new Set(
+				getModelsDueForProbe(
+					PROVIDER_ROUTEWAY,
+					modelsToTest.map((m) => m.id),
+				),
+			)
+		: undefined;
+	const probeCandidates = modelIdsToProbe
+		? modelsToTest.filter((m) => modelIdsToProbe.has(m.id))
+		: modelsToTest;
+
+	if (probeCandidates.length === 0) {
+		_logger.info("Auto-probe: Routeway probe cache is fresh");
+		return [];
+	}
+
+	const broken: string[] = [];
+	const cacheableResults: Array<{ modelId: string; status: "ok" | "broken" }> =
+		[];
+	const batchSize = 5;
+
+	for (let i = 0; i < probeCandidates.length; i += batchSize) {
+		const batch = probeCandidates.slice(i, i + batchSize);
+		const results = await Promise.all(
+			batch.map(async (m) => {
+				const status = await probeRoutewayModel(apiKey, m.id);
+				return { id: m.id, status };
+			}),
+		);
+		for (const r of results) {
+			if (r.status === "broken") broken.push(r.id);
+			if (r.status !== "unknown") {
+				cacheableResults.push({ modelId: r.id, status: r.status });
+			}
+		}
+	}
+
+	await recordModelProbeResults(PROVIDER_ROUTEWAY, cacheableResults);
+
+	if (broken.length === 0) {
+		_logger.info("Auto-probe: all checked Routeway models are routable");
+		return [];
+	}
+
+	// Auto-hide broken models in config (provider-scoped)
+	const cfg = loadConfigFile();
+	const existingHidden = new Set(cfg.hidden_models ?? []);
+	for (const id of broken) existingHidden.add(`${PROVIDER_ROUTEWAY}/${id}`);
+	saveConfig({ hidden_models: Array.from(existingHidden) });
+
+	// Re-register so hidden models disappear immediately
+	const filtered = await fetchRoutewayModels(apiKey);
+	stored.free = filtered;
+	stored.all = filtered;
+	reRegister(filtered);
+
+	_logger.info(
+		`Auto-probe: found ${broken.length} broken models (auto-hidden)`,
+	);
+	return broken;
+}
+
+// =============================================================================
+// Extension Entry Point
+// =============================================================================
+
 export default async function routewayProvider(pi: ExtensionAPI) {
 	const apiKey = getRoutewayApiKey();
 
@@ -206,6 +343,55 @@ export default async function routewayProvider(pi: ExtensionAPI) {
 		stored,
 	);
 
+	// ── Lazy auto-probe on first session_start ──────────────────────
+	let _autoProbeDone = false;
+	pi.on(
+		"session_start",
+		wrapSessionStartHandler("routeway", async () => {
+			if (_autoProbeDone || !apiKey) return;
+			_autoProbeDone = true;
+			_logger.info("Starting lazy auto-probe of Routeway models...");
+			runRoutewayProbe(apiKey, allModels, stored, reRegister, {
+				useCache: true,
+			}).catch((err) => {
+				_logger.warn("Auto-probe failed", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+			});
+		}),
+	);
+
+	// ── Probe command: test all registered models for 5xx ─────────────
+	pi.registerCommand("probe-routeway", {
+		description:
+			"Test all Routeway models for server errors and auto-hide broken ones",
+		handler: async (_args, ctx) => {
+			if (!apiKey) {
+				ctx.ui.notify("ROUTEWAY_API_KEY not set", "error");
+				return;
+			}
+
+			const modelsToTest = allModels;
+			ctx.ui.notify(`Probing ${modelsToTest.length} Routeway models…`, "info");
+
+			await runRoutewayProbe(apiKey, modelsToTest, stored, reRegister);
+
+			// Check if any were hidden (re-read config)
+			const cfgAfter = loadConfigFile();
+			const newHidden = (cfgAfter.hidden_models ?? []).filter((h) =>
+				h.startsWith(`${PROVIDER_ROUTEWAY}/`),
+			);
+			if (newHidden.length > 0) {
+				ctx.ui.notify(
+					`Found ${newHidden.length} broken models (auto-hidden):\n${newHidden.join("\n")}`,
+					"warning",
+				);
+			} else {
+				ctx.ui.notify("All Routeway models are routable ✅", "info");
+			}
+		},
+	});
+
 	const showPaid = getRoutewayShowPaid();
 	const initialModels =
 		showPaid && stored.all.length > 0 ? stored.all : freeModels;

package/providers/sambanova/sambanova.ts

@@ -31,8 +31,13 @@ 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 { createProviderProbe } from "../../lib/provider-probe.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
-import { fetchOpenAICompatibleModels } from "../../lib/util.ts";
+import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
+import {
+	fetchOpenAICompatibleModels,
+	fetchWithTimeout,
+} from "../../lib/util.ts";
 import { createReRegister, setupProvider } from "../../provider-helper.ts";
 
 const _logger = createLogger("sambanova");
@@ -112,4 +117,65 @@ export default async function sambanovaProvider(pi: ExtensionAPI) {
 	const initialModels =
 		showPaid && stored.all.length > 0 ? stored.all : freeModels;
 	reRegister(initialModels);
+
+	// ── Probe support ──────────────────────────────────────────────
+	const probe = createProviderProbe({
+		providerId: PROVIDER_SAMBANOVA,
+		probeModel: async (_apiKey: string, modelId: string) => {
+			try {
+				const response = await fetchWithTimeout(
+					`${BASE_URL_SAMBANOVA}/chat/completions`,
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${apiKey}`,
+							"Content-Type": "application/json",
+							"User-Agent": "pi-free-providers",
+						},
+						body: JSON.stringify({
+							model: modelId,
+							messages: [{ role: "user", content: "hi" }],
+							max_tokens: 1,
+						}),
+					},
+					10_000,
+				);
+				// SambaNova may return 404 for preview/unavailable models
+				if (response.status === 404 || response.status >= 500) return "broken";
+				if (response.status === 429) return "ok";
+				if (response.ok) return "ok";
+				return "ok";
+			} catch {
+				return "unknown";
+			}
+		},
+	});
+
+	// Probe command
+	pi.registerCommand(`probe-${PROVIDER_SAMBANOVA}`, {
+		description: "Test all SambaNova models for availability",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(`Probing ${allModels.length} SambaNova models…`, "info");
+			const broken = await probe.run(apiKey, allModels, {
+				onBroken: (ids) => {
+					ctx.ui.notify(
+						`Found ${ids.length} broken models (auto-hidden):\n${ids.join("\n")}`,
+						"warning",
+					);
+				},
+			});
+			if (broken.length === 0) {
+				ctx.ui.notify("All SambaNova models are accessible ✅", "info");
+			}
+		},
+	});
+
+	// Lazy auto-probe on first session_start
+	pi.on(
+		"session_start",
+		wrapSessionStartHandler(
+			`${PROVIDER_SAMBANOVA}-auto-probe`,
+			probe.autoProbeHandler(apiKey, freeModels),
+		),
+	);
 }

package/providers/together/together.ts

@@ -41,12 +41,15 @@ import {
 	PROVIDER_TOGETHER,
 } 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 { createProviderProbe } from "../../lib/provider-probe.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
-import { fetchWithRetry } from "../../lib/util.ts";
+import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
+import { fetchWithRetry, fetchWithTimeout } from "../../lib/util.ts";
 import { createReRegister, setupProvider } from "../../provider-helper.ts";
 
 const _logger = createLogger("together");
@@ -98,7 +101,7 @@ async function fetchTogetherModels(
 
 	_logger.info(`[together] Fetched ${models.length} models`);
 
-	return models
+	const mapped = models
 		.filter((m) => m.type === "chat" && m.id && !m.id.includes("embed"))
 		.map((m): ProviderModelConfig => {
 			const name = m.display_name || m.id.split("/").pop() || m.id;
@@ -126,6 +129,10 @@ async function fetchTogetherModels(
 				_pricingKnown: m.pricing !== undefined,
 			} as ProviderModelConfig & { _pricingKnown?: boolean };
 		});
+
+	return await safeEnrichModelsWithModelsDev(mapped, {
+		providerId: PROVIDER_TOGETHER,
+	});
 }
 
 // =============================================================================
@@ -191,4 +198,64 @@ export default async function togetherProvider(pi: ExtensionAPI) {
 
 	// Initial registration — show all models (trial credit provider)
 	reRegister(stored.all);
+
+	// ── Probe support ──────────────────────────────────────────────
+	const probe = createProviderProbe({
+		providerId: PROVIDER_TOGETHER,
+		probeModel: async (_apiKey: string, modelId: string) => {
+			try {
+				const response = await fetchWithTimeout(
+					`${BASE_URL_TOGETHER}/chat/completions`,
+					{
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${apiKey}`,
+							"Content-Type": "application/json",
+							"User-Agent": "pi-free-providers",
+						},
+						body: JSON.stringify({
+							model: modelId,
+							messages: [{ role: "user", content: "hi" }],
+							max_tokens: 1,
+						}),
+					},
+					10_000,
+				);
+				if (response.status === 404 || response.status >= 500) return "broken";
+				if (response.status === 429) return "ok";
+				if (response.ok) return "ok";
+				return "ok";
+			} catch {
+				return "unknown";
+			}
+		},
+	});
+
+	// Probe command
+	pi.registerCommand(`probe-${PROVIDER_TOGETHER}`, {
+		description: "Test all Together AI models for availability",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(`Probing ${allModels.length} Together AI models…`, "info");
+			const broken = await probe.run(apiKey, allModels, {
+				onBroken: (ids) => {
+					ctx.ui.notify(
+						`Found ${ids.length} broken models (auto-hidden):\n${ids.join("\n")}`,
+						"warning",
+					);
+				},
+			});
+			if (broken.length === 0) {
+				ctx.ui.notify("All Together AI models are accessible ✅", "info");
+			}
+		},
+	});
+
+	// Lazy auto-probe on first session_start
+	pi.on(
+		"session_start",
+		wrapSessionStartHandler(
+			`${PROVIDER_TOGETHER}-auto-probe`,
+			probe.autoProbeHandler(apiKey, freeModels),
+		),
+	);
 }