pi-free 2.0.15 → 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

@@ -31,6 +31,7 @@ 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,
@@ -40,6 +41,7 @@ import {
 	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";
@@ -156,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),
@@ -255,7 +263,7 @@ async function runRoutewayProbe(
 		}
 	}
 
-	recordModelProbeResults(PROVIDER_ROUTEWAY, cacheableResults);
+	await recordModelProbeResults(PROVIDER_ROUTEWAY, cacheableResults);
 
 	if (broken.length === 0) {
 		_logger.info("Auto-probe: all checked Routeway models are routable");
@@ -337,18 +345,21 @@ export default async function routewayProvider(pi: ExtensionAPI) {
 
 	// ── Lazy auto-probe on first session_start ──────────────────────
 	let _autoProbeDone = false;
-	pi.on("session_start", 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),
+	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", {
@@ -361,10 +372,7 @@ export default async function routewayProvider(pi: ExtensionAPI) {
 			}
 
 			const modelsToTest = allModels;
-			ctx.ui.notify(
-				`Probing ${modelsToTest.length} Routeway models…`,
-				"info",
-			);
+			ctx.ui.notify(`Probing ${modelsToTest.length} Routeway models…`, "info");
 
 			await runRoutewayProbe(apiKey, modelsToTest, stored, reRegister);
 

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),
+		),
+	);
 }