pi-free 2.0.14 → 2.1.0

package/providers/cline/cline.ts

@@ -15,15 +15,26 @@
  */
 
 import type { OAuthCredentials } from "@earendil-works/pi-ai";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@earendil-works/pi-coding-agent";
 import { getClineShowPaid } from "../../config.ts";
 import { BASE_URL_CLINE, PROVIDER_CLINE } from "../../constants.ts";
+import {
+	DEFAULT_PROVIDER_CACHE_TTL_MS,
+	isProviderCacheFresh,
+	loadProviderCache,
+	saveProviderCache,
+} from "../../lib/provider-cache.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { createToggleState } from "../../lib/toggle-state.ts";
 import { logWarning } from "../../lib/util.ts";
 import { enhanceWithCI } from "../../provider-helper.ts";
 import { loginCline, refreshClineToken } from "./cline-auth.ts";
 import { fetchClineModels } from "./cline-models.ts";
+import { streamClineXml } from "./cline-xml-bridge.ts";
 
 // =============================================================================
 // Cline API headers (must match real Cline VS Code extension exactly)
@@ -68,153 +79,26 @@ function toApiKey(credentials: OAuthCredentials): string {
 	return token.startsWith("workos:") ? token : `workos:${token}`;
 }
 
-// =============================================================================
-// Context shaping — Cline's API requires a specific message envelope
-// =============================================================================
-
-const TASK_PROGRESS_BLOCK = `
-# task_progress List (Optional - Plan Mode)
-
-While in PLAN MODE, if you've outlined concrete steps or requirements for the user, you may include a preliminary todo list using the task_progress parameter.
-
-1. To create or update a todo list, include the task_progress parameter in the next tool call
-2. Review each item and update its status:
-   - Mark completed items with: - [x]
-   - Keep incomplete items as: - [ ]
-3. Modify the list as needed
-4. Ensure the list accurately reflects the current state`;
-
-function buildEnvironmentDetails(): string {
-	const cwd = process.cwd();
-	return `<environmentDetails>
-# Visual Studio Code Visible Files
-(No visible files)
-
-# Visual Studio Code Open Tabs
-(No open tabs)
-
-# Current Working Directory (${cwd}) Files
-(No files)
-
-# Context Window Usage
-0 / 204.8K tokens used (0%)
-
-# Current Mode
-PLAN MODE
-</environmentDetails>`;
-}
-
-function extractText(content: unknown): string {
-	if (typeof content === "string") return content.trim();
-	if (Array.isArray(content)) {
-		return (content as any[])
-			.filter((p: any) => p?.type === "text" && typeof p?.text === "string")
-			.map((p: any) => p.text)
-			.join("\n\n")
-			.trim();
-	}
-	return "";
-}
-
-function isClineWrapped(content: unknown): boolean {
-	if (!Array.isArray(content)) return false;
-	const texts = (content as any[])
-		.filter((p: any) => p?.type === "text" && typeof p?.text === "string")
-		.map((p: any) => p.text as string);
-	return (
-		texts.some((t) => /<task>[\s\S]*<\/task>/.test(t)) &&
-		texts.some((t) => t.includes("task_progress List")) &&
-		texts.some((t) => t.includes("<environmentDetails>"))
-	);
-}
-
-function extractTaskBody(content: unknown): string {
-	if (!Array.isArray(content)) return "";
-	for (const p of content as any[]) {
-		if (p?.type !== "text" || typeof p?.text !== "string") continue;
-		const m = p.text.match(/<task>([\s\S]*?)<\/task>/);
-		if (m?.[1]) return m[1].trim();
-	}
-	return "";
-}
-
-function findLastClineWrappedMessage(messages: any[]): {
-	index: number;
-	transcript: string;
-} {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		if (messages[i]?.role !== "user") continue;
-		if (!isClineWrapped(messages[i]?.content)) continue;
-		return { index: i, transcript: extractTaskBody(messages[i].content) };
-	}
-	return { index: -1, transcript: "" };
-}
-
-function buildTranscriptParts(
-	messages: any[],
-	startIdx: number,
-	baseTranscript: string,
-): string[] {
-	const parts: string[] = baseTranscript ? [baseTranscript] : [];
-
-	for (let i = startIdx; i < messages.length; i++) {
-		const msg = messages[i];
-		const role = msg?.role ?? "user";
-		if (role === "system") continue;
-		if (role === "user" && isClineWrapped(msg?.content)) continue;
-		const text = extractText(msg?.content).trim();
-		if (!text) continue;
-
-		if (role === "tool") {
-			parts.push(`<tool_result>\n${text}\n</tool_result>`);
-		} else if (role !== "assistant") {
-			parts.push(`[${role}]\n${text}`);
-		}
-	}
-
-	return parts;
-}
-
-function buildCollapsedMessage(messages: any[], transcript: string): any[] {
-	const collapsed: any[] = [];
-	const systemMsg = messages.find((m: any) => m?.role === "system");
-	if (systemMsg) {
-		const systemText = extractText(systemMsg.content);
-		if (systemText) collapsed.push({ role: "system", content: systemText });
-	}
-
-	collapsed.push({
-		role: "user",
-		content: [
-			{ type: "text", text: `<task>\n${transcript}\n</task>` },
-			{ type: "text", text: TASK_PROGRESS_BLOCK },
-			{ type: "text", text: buildEnvironmentDetails() },
-		],
-	});
-
-	return collapsed;
-}
-
-function shapeMessagesForCline(messages: any[]): any[] {
-	const { index: lastWrappedIdx, transcript: baseTranscript } =
-		findLastClineWrappedMessage(messages);
-
-	const startIdx = lastWrappedIdx >= 0 ? lastWrappedIdx + 1 : 0;
-	const parts = buildTranscriptParts(messages, startIdx, baseTranscript);
-	const transcript = parts.join("\n\n").trim() || "(no conversation yet)";
-
-	return buildCollapsedMessage(messages, transcript);
-}
-
 // =============================================================================
 // Extension entry point
 // =============================================================================
 
 export default async function clineProvider(pi: ExtensionAPI) {
-	let allModels = await fetchClineModels(false).catch((err) => {
-		logWarning("cline", "Failed to fetch models at startup", err);
-		return [];
-	});
+	let allModels: ProviderModelConfig[];
+	const cachedModels = loadProviderCache(PROVIDER_CLINE);
+	if (cachedModels && cachedModels.length > 0) {
+		allModels = cachedModels;
+	} else {
+		allModels = await fetchClineModels(false).catch((err) => {
+			logWarning("cline", "Failed to fetch models at startup", err);
+			return [];
+		});
+		if (allModels.length > 0) {
+			saveProviderCache(PROVIDER_CLINE, allModels).catch((err) => {
+				logWarning("cline", "Failed to save model cache", err);
+			});
+		}
+	}
 	let freeModels = allModels.filter((m) =>
 		isFreeModel({ ...m, provider: PROVIDER_CLINE }, allModels),
 	);
@@ -228,9 +112,11 @@ export default async function clineProvider(pi: ExtensionAPI) {
 	const reRegister = (m: typeof allModels) => {
 		pi.registerProvider(PROVIDER_CLINE, {
 			baseUrl: BASE_URL_CLINE,
-			api: "openai-completions" as const,
+			api: "cline-xml-tools" as const,
 			authHeader: false,
 			headers: buildClineHeaders(),
+			streamSimple: (model, context, options) =>
+				streamClineXml(model as any, context, options, buildClineHeaders()),
 			models: enhanceWithCI(m),
 			oauth: {
 				name: "Cline",
@@ -241,12 +127,23 @@ export default async function clineProvider(pi: ExtensionAPI) {
 		});
 	};
 
+	const applyModelList = (models: ProviderModelConfig[]) => {
+		allModels = models;
+		freeModels = allModels.filter((m) =>
+			isFreeModel({ ...m, provider: PROVIDER_CLINE }, allModels),
+		);
+		stored.all = allModels;
+		stored.free = freeModels;
+		toggleState.setModels(stored);
+		toggleState.applyCurrent(reRegister);
+	};
+
 	registerWithGlobalToggle(PROVIDER_CLINE, stored, (m) => reRegister(m), false);
 	toggleState.applyCurrent(reRegister);
 
 	pi.registerCommand("toggle-cline", {
 		description: "Toggle between free and all Cline models",
-		handler: async (_args, ctx) => {
+		handler: (_args, ctx) => {
 			const applied = toggleState.toggle(reRegister);
 			const freeCount = stored.free.length;
 			const paidCount = stored.all.length - freeCount;
@@ -262,6 +159,7 @@ export default async function clineProvider(pi: ExtensionAPI) {
 					"info",
 				);
 			}
+			return Promise.resolve();
 		},
 	});
 
@@ -288,41 +186,34 @@ export default async function clineProvider(pi: ExtensionAPI) {
 		ctx.ui.setStatus(`${PROVIDER_CLINE}-status`, status);
 	});
 
-	pi.on("before_agent_start", async (_event, ctx) => {
+	pi.on("before_agent_start", (_event, ctx) => {
 		if (ctx.model?.provider !== PROVIDER_CLINE) return;
 		_currentTaskId = generateUlid();
 		toggleState.applyCurrent(reRegister);
 	});
 
-	pi.on("context", async (event, ctx) => {
-		if (ctx.model?.provider !== PROVIDER_CLINE) return;
-		const sourceMessages = Array.isArray(event.messages) ? event.messages : [];
-		return { messages: shapeMessagesForCline(sourceMessages) };
-	});
-
-	pi.on("session_start", async (_event, ctx) => {
-		try {
-			const fresh = await fetchClineModels(false);
-			if (fresh.length > 0) {
-				allModels = fresh;
-				freeModels = allModels.filter((m) =>
-					isFreeModel({ ...m, provider: PROVIDER_CLINE }, allModels),
-				);
-				stored.all = allModels;
-				stored.free = freeModels;
-				toggleState.setModels(stored);
-				toggleState.applyCurrent(reRegister);
-				if (ctx.model?.provider === PROVIDER_CLINE) {
-					const freeCount = stored.free.length;
-					const paidCount = stored.all.length - freeCount;
-					ctx.ui.notify(
-						`Cline: ${freeCount} free, ${paidCount} paid models available`,
-						"info",
-					);
-				}
+	let refreshInFlight: Promise<void> | undefined;
+	pi.on(
+		"session_start",
+		wrapSessionStartHandler("cline", () => {
+			if (refreshInFlight) return Promise.resolve();
+			if (isProviderCacheFresh(PROVIDER_CLINE, DEFAULT_PROVIDER_CACHE_TTL_MS)) {
+				return Promise.resolve();
 			}
-		} catch (err) {
-			logWarning("cline", "Failed to refresh models at session start", err);
-		}
-	});
+
+			refreshInFlight = fetchClineModels(false)
+				.then(async (fresh) => {
+					if (fresh.length === 0) return;
+					await saveProviderCache(PROVIDER_CLINE, fresh);
+					applyModelList(fresh);
+				})
+				.catch((err) => {
+					logWarning("cline", "Failed to refresh models at session start", err);
+				})
+				.finally(() => {
+					refreshInFlight = undefined;
+				});
+			return Promise.resolve();
+		}),
+	);
 }

package/providers/crofai/crofai.ts

@@ -28,6 +28,7 @@ import {
 	PROVIDER_CROFAI,
 } from "../../constants.ts";
 import { createLogger } from "../../lib/logger.ts";
+import { safeEnrichModelsWithModelsDev } from "../../lib/model-metadata.ts";
 import {
 	getProxyModelCompat,
 	isLikelyReasoningModel,
@@ -98,7 +99,7 @@ async function fetchCrofaiModels(
 
 	_logger.info(`[crofai] Fetched ${models.length} models`);
 
-	return models
+	const mapped = models
 		.filter((m) => m.id)
 		.map((m): ProviderModelConfig => {
 			const name = m.name || m.id;
@@ -125,6 +126,10 @@ async function fetchCrofaiModels(
 					m.pricing?.cache_prompt !== undefined,
 			} as ProviderModelConfig & { _pricingKnown?: boolean };
 		});
+
+	return await safeEnrichModelsWithModelsDev(mapped, {
+		providerId: PROVIDER_CROFAI,
+	});
 }
 
 // =============================================================================

package/providers/deepinfra/deepinfra.ts

@@ -40,12 +40,15 @@ import {
 	PROVIDER_DEEPINFRA,
 } 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("deepinfra");
@@ -99,7 +102,7 @@ async function fetchDeepinfraModels(
 
 	_logger.info(`[deepinfra] Fetched ${models.length} models`);
 
-	return models
+	const mapped = models
 		.filter((m) => {
 			const id = m.id.toLowerCase();
 			// Filter out non-chat models
@@ -139,6 +142,10 @@ async function fetchDeepinfraModels(
 				_pricingKnown: meta?.pricing !== undefined,
 			} as ProviderModelConfig & { _pricingKnown?: boolean };
 		});
+
+	return await safeEnrichModelsWithModelsDev(mapped, {
+		providerId: PROVIDER_DEEPINFRA,
+	});
 }
 
 // =============================================================================
@@ -205,4 +212,64 @@ export default async function deepinfraProvider(pi: ExtensionAPI) {
 	// Initial registration — DeepInfra is a trial-credit provider,
 	// so always show all models. Users see them immediately on setup.
 	reRegister(allModels);
+
+	// ── Probe support ──────────────────────────────────────────────
+	const probe = createProviderProbe({
+		providerId: PROVIDER_DEEPINFRA,
+		probeModel: async (_apiKey: string, modelId: string) => {
+			try {
+				const response = await fetchWithTimeout(
+					`${BASE_URL_DEEPINFRA}/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_DEEPINFRA}`, {
+		description: "Test all DeepInfra models for availability",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(`Probing ${allModels.length} DeepInfra 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 DeepInfra models are accessible ✅", "info");
+			}
+		},
+	});
+
+	// Lazy auto-probe on first session_start
+	pi.on(
+		"session_start",
+		wrapSessionStartHandler(
+			`${PROVIDER_DEEPINFRA}-auto-probe`,
+			probe.autoProbeHandler(apiKey, freeModels),
+		),
+	);
 }