pi-free 2.2.4 → 2.2.6

package/providers/qoder/models.ts

@@ -1,19 +1,28 @@
 /**
  * Qoder model definitions and cache management.
  *
- * Qoder provides a static set of models (all at zero cost) with the option
- * to dynamically discover more from the `/algo/api/v2/model/list` endpoint.
- * The dynamic list is cached at `~/.pi/agent/qoder-models-cache.json` with
- * a 1-hour TTL and falls back to the static models on cache miss or API error.
+ * Qoder operates on a credits-based pricing model:
+ *   - Community Edition (free): basic models with daily message limits
+ *   - Pro / Pro+ / Ultra (paid): premium models via monthly credits
  *
- * ALL Qoder models are free — no pricing data needed.
+ * The dynamic model list API is currently unavailable (legacy api3 endpoint
+ * is decommissioned). We keep a static curated list and classify models as
+ * basic (free tier) or premium (paid credits) by model ID.
+ *
+ * Dynamic model discovery is disabled until Qoder publishes a model-list
+ * endpoint on api2-v2. Stale legacy cache entries are ignored and static
+ * models in `staticModels` remain the source of truth.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import { buildAuthHeaders } from "./cosy.ts";
+import { createLogger } from "../../lib/logger.ts";
+
+const _logger = createLogger("qoder");
+
+export type QoderModelConfig = ProviderModelConfig;
 
 // ─── Cache ───────────────────────────────────────────────────────────────────
 
@@ -26,14 +35,29 @@ const ZERO_COST = Object.freeze({
 	cacheWrite: 0,
 });
 
+// ─── Basic (free-tier) model IDs ─────────────────────────────────────────────
+// These are the Qoder-branded router models available on Community Edition.
+// Named models (DeepSeek, Qwen, GLM, Kimi, MiniMax) are premium and cost credits.
+// This set is the single source of truth for basic-model classification.
+const BASIC_MODEL_IDS = new Set([
+	"auto",
+	"ultimate",
+	"performance",
+	"efficient",
+	"lite",
+]);
+
 // ─── Static model list ───────────────────────────────────────────────────────
 
 /**
  * Static model definitions for Qoder.
- * All models are free (zero cost) — no paid tier exists.
- * These serve as the fallback when the dynamic API is unreachable.
+ * Basic models (free tier) are identified by membership in BASIC_MODEL_IDS.
+ * Premium models consume credits and require a paid plan.
+ *
+ * Model IDs are validated against the live api2-v2 endpoint; invalid IDs
+ * (dfmodel, gm51model, qmodel_latest) are excluded here.
  */
-export const staticModels: ProviderModelConfig[] = [
+export const staticModels: QoderModelConfig[] = [
 	{
 		id: "auto",
 		name: "Qoder Auto",
@@ -88,15 +112,6 @@ export const staticModels: ProviderModelConfig[] = [
 		contextWindow: 1_000_000,
 		maxTokens: 32_768,
 	},
-	{
-		id: "qmodel_latest",
-		name: "Qwen3.7 Max (Qoder)",
-		reasoning: false,
-		input: ["text", "image"] as ("text" | "image")[],
-		cost: ZERO_COST,
-		contextWindow: 1_000_000,
-		maxTokens: 32_768,
-	},
 	{
 		id: "dmodel",
 		name: "DeepSeek V4 Pro (Qoder)",
@@ -106,24 +121,6 @@ export const staticModels: ProviderModelConfig[] = [
 		contextWindow: 1_000_000,
 		maxTokens: 32_768,
 	},
-	{
-		id: "dfmodel",
-		name: "DeepSeek V4 Flash (Qoder)",
-		reasoning: true,
-		input: ["text", "image"] as ("text" | "image")[],
-		cost: ZERO_COST,
-		contextWindow: 1_000_000,
-		maxTokens: 32_768,
-	},
-	{
-		id: "gm51model",
-		name: "GLM 5.1 (Qoder)",
-		reasoning: true,
-		input: ["text", "image"] as ("text" | "image")[],
-		cost: ZERO_COST,
-		contextWindow: 180_000,
-		maxTokens: 32_768,
-	},
 	{
 		id: "kmodel",
 		name: "Kimi K2.6 (Qoder)",
@@ -144,74 +141,30 @@ export const staticModels: ProviderModelConfig[] = [
 	},
 ];
 
-// ─── Dynamic model API ───────────────────────────────────────────────────────
+// ─── Helpers ─────────────────────────────────────────────────────────────────
 
-interface QoderModelEntry {
-	key?: string;
-	enable?: boolean;
-	display_name?: string;
-	max_input_tokens?: number;
-	max_output_tokens?: number;
-	context_config?: Record<string, { token_count?: number }>;
-	is_vl?: boolean;
-	is_reasoning?: boolean;
-	thinking_config?: { enabled?: { efforts?: unknown } };
-	source?: string;
-	[key: string]: unknown;
+/** Check if a model is a basic (free-tier) model. */
+export function isBasicModel(model: ProviderModelConfig): boolean {
+	return BASIC_MODEL_IDS.has(model.id);
 }
 
 // ─── Cache management ────────────────────────────────────────────────────────
 
-function modelEntryToConfig(
-	entry: QoderModelEntry,
-): ProviderModelConfig | null {
-	const key = entry.key;
-	if (!key || !entry.enable) return null;
-
-	const display = entry.display_name || key;
-	const ctxLen = resolveContextLength(entry);
-	const isVL = Boolean(entry.is_vl);
-	const isReasoning = Boolean(entry.is_reasoning) || Boolean(entry.thinking_config);
-	const input: ("text" | "image")[] = isVL ? ["text", "image"] : ["text"];
-
-	return {
-		id: key,
-		name: display,
-		reasoning: isReasoning,
-		input,
-		cost: ZERO_COST,
-		contextWindow: ctxLen,
-		maxTokens: entry.max_output_tokens || 32_768,
-	};
-}
-
-function resolveContextLength(entry: QoderModelEntry): number {
-	let ctxLen = entry.max_input_tokens || 180_000;
-	if (entry.context_config && typeof entry.context_config === "object") {
-		for (const val of Object.values(entry.context_config)) {
-			if (
-				val &&
-				typeof val === "object" &&
-				typeof (val as Record<string, unknown>).token_count === "number"
-			) {
-				const tc = (val as Record<string, number>).token_count;
-				if (tc > ctxLen) ctxLen = tc;
-			}
-		}
-	}
-	return ctxLen;
-}
-
 /** Get models from cache, falling back to static models. */
-export function getCachedModels(): ProviderModelConfig[] {
-	if (existsSync(CACHE_PATH)) {
+export function getCachedModels(): QoderModelConfig[] {
+	if (existsSync(CACHE_PATH) && !isCacheStale()) {
 		try {
 			const data = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
 			if (data && Array.isArray(data.models)) {
-				return data.models as ProviderModelConfig[];
+				return data.models as QoderModelConfig[];
 			}
-		} catch {
-			// Fall through to static
+		} catch (err) {
+			_logger.warn(
+				"Failed to read Qoder model cache; falling back to static models",
+				{
+					error: err instanceof Error ? err.message : String(err),
+				},
+			);
 		}
 	}
 	return staticModels;
@@ -224,81 +177,11 @@ export function isCacheStale(): boolean {
 		const data = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
 		if (!data || typeof data.updatedAt !== "number") return true;
 		return Date.now() - data.updatedAt > 3_600_000; // 1 hour
-	} catch {
-		return true;
-	}
-}
-
-/**
- * Fetch available models from Qoder's dynamic model list API and cache them.
- * Falls back silently if the API is unreachable.
- */
-export async function updateQoderModelsCache(
-	authToken: string,
-	userID: string,
-	name: string,
-	email: string,
-): Promise<void> {
-	const modelListURL = "https://api3.qoder.sh/algo/api/v2/model/list";
-	try {
-		const headers = buildAuthHeaders(null, modelListURL, {
-			userID,
-			authToken,
-			name,
-			email,
+	} catch (err) {
+		_logger.warn("Failed to check Qoder cache staleness; treating as stale", {
+			error: err instanceof Error ? err.message : String(err),
 		});
-
-		const response = await fetch(modelListURL, {
-			method: "GET",
-			headers: {
-				Accept: "application/json",
-				...headers,
-			},
-		});
-
-		if (!response.ok) return;
-
-		const resData = (await response.json()) as {
-			chat?: QoderModelEntry[];
-		};
-		const chatModels = resData.chat || [];
-		if (chatModels.length === 0) return;
-
-		const newModels: ProviderModelConfig[] = [];
-		const configs: Record<string, QoderModelEntry> = {};
-
-		for (const entry of chatModels) {
-			const model = modelEntryToConfig(entry);
-			if (!model) continue;
-			configs[model.id] = entry;
-			newModels.push(model);
-		}
-
-		if (newModels.length === 0) return;
-
-		// Ensure the auto router model is present
-		if (!newModels.some((m) => m.id === "auto")) {
-			newModels.unshift({
-				id: "auto",
-				name: "Qoder Auto",
-				reasoning: true,
-				input: ["text", "image"] as ("text" | "image")[],
-				cost: ZERO_COST,
-				contextWindow: 180_000,
-				maxTokens: 32_768,
-			});
-		}
-
-		const cacheData = {
-			updatedAt: Date.now(),
-			models: newModels,
-			configs,
-		};
-
-		mkdirSync(dirname(CACHE_PATH), { recursive: true });
-		writeFileSync(CACHE_PATH, JSON.stringify(cacheData, null, 2), "utf-8");
-	} catch {
-		// Best-effort
+		return true;
 	}
 }
 
@@ -306,15 +189,20 @@ export async function updateQoderModelsCache(
  * Get the cached model config for a specific model key.
  * Used to determine per-model settings (reasoning, max tokens, etc.) at stream time.
  */
-export function getCachedModelConfig(modelKey: string): QoderModelEntry | null {
-	if (existsSync(CACHE_PATH)) {
+export function getCachedModelConfig(
+	modelKey: string,
+): Record<string, unknown> | null {
+	if (existsSync(CACHE_PATH) && !isCacheStale()) {
 		try {
 			const data = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
 			if (data?.configs?.[modelKey]) {
-				return data.configs[modelKey] as QoderModelEntry;
+				return data.configs[modelKey] as Record<string, unknown>;
 			}
-		} catch {
-			// Fall through
+		} catch (err) {
+			_logger.warn("Failed to read Qoder model config cache", {
+				modelKey,
+				error: err instanceof Error ? err.message : String(err),
+			});
 		}
 	}
 	return null;

package/providers/qoder/qoder.ts

@@ -3,15 +3,17 @@
  *
  * Registers the Qoder provider with Pi, providing free access to top-tier
  * LLM models (DeepSeek V4 Pro/Flash, Qwen3.7 Plus/Max, GLM 5.1, Kimi K2.6,
- * MiniMax M3) through Qoder's proprietary API.
+ * MiniMax M3) through Qoder's OpenAI-compatible API.
  *
  * Qoder uses a custom authentication protocol (PAT exchange + COSY signing)
- * and a non-standard streaming API. All models are completely free — no
- * paid tier exists.
+ * and a credits-based pricing model:
+ *   - Community Edition (free): basic models with daily message limits
+ *   - Pro / Pro+ / Ultra (paid): premium models via monthly credits
  *
  * Usage:
  *   Install pi-free, then run /login qoder to authenticate
  *   (PAT paste or browser OAuth)
+ *   /toggle-qoder switches between basic (free-tier) and all models
  *
  * Environment variables:
  *   QODER_PERSONAL_ACCESS_TOKEN — PAT for headless auth (optional)
@@ -24,15 +26,17 @@ import type {
 	ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
 import { BASE_URL_QODER, PROVIDER_QODER } from "../../constants.ts";
+import { getProviderShowPaid } from "../../config.ts";
 import {
 	getCachedModels,
-	isCacheStale,
-	updateQoderModelsCache,
+	isBasicModel,
+	type QoderModelConfig,
 } from "./models.ts";
 import { getCachedCredentials, loginQoder, refreshQoderToken } from "./auth.ts";
 import { streamQoder } from "./stream.ts";
 import { enhanceWithCI } from "../../provider-helper.ts";
-import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { registerWithGlobalToggle } from "../../lib/registry.ts";
+import { createToggleState } from "../../lib/toggle-state.ts";
 
 // =============================================================================
 // Extension Entry Point
@@ -42,33 +46,21 @@ export default async function qoderProvider(pi: ExtensionAPI) {
 	const logger = (await import("../../lib/logger.ts")).createLogger("qoder");
 
 	// Initial model fetch
-	let allModels: ProviderModelConfig[] = getCachedModels();
-	let freeModels: ProviderModelConfig[] = allModels.filter((m) =>
-		isFreeModel({ ...m, provider: PROVIDER_QODER }, allModels),
-	);
-	const stored = { free: freeModels, all: allModels };
+	const allModels: QoderModelConfig[] = getCachedModels();
+	const basicModels: QoderModelConfig[] = allModels.filter(isBasicModel);
+	const stored = { free: basicModels, all: allModels };
+
+	const toggleState = createToggleState({
+		providerId: PROVIDER_QODER,
+		initialShowPaid: getProviderShowPaid(PROVIDER_QODER),
+		initialModels: stored,
+	});
 
 	// ── OAuth config (defined before reRegister so it's always available) ──
 	const oauthConfig = {
 		name: "Qoder (Browser OAuth / PAT)",
 		login: async (callbacks: any): Promise<OAuthCredentials> => {
-			const cred = await loginQoder(callbacks);
-
-			// After login, refresh models from API
-			try {
-				const accessToken = cred.access as string;
-				const creds = getCachedCredentials();
-				await refreshModels(
-					accessToken,
-					creds?.userID || "qoder-user",
-					creds?.name || "Qoder User",
-					creds?.email || "user@qoder.com",
-				);
-			} catch {
-				// Best-effort
-			}
-
-			return cred;
+			return loginQoder(callbacks);
 		},
 		refreshToken: refreshQoderToken,
 		getApiKey: (cred: OAuthCredentials) => cred.access,
@@ -86,67 +78,40 @@ export default async function qoderProvider(pi: ExtensionAPI) {
 		});
 	};
 
-	// ── Helper: refresh models from API and re-register ──
-	const refreshModels = async (
-		accessToken: string,
-		userID: string,
-		name: string,
-		email: string,
-	) => {
-		await updateQoderModelsCache(accessToken, userID, name, email);
-		const fresh = getCachedModels();
-		if (fresh.length > 0) {
-			allModels = fresh;
-			freeModels = fresh.filter((m) =>
-				isFreeModel({ ...m, provider: PROVIDER_QODER }, fresh),
-			);
-			stored.all = allModels;
-			stored.free = freeModels;
-			reRegister(allModels);
-			logger.info(`[qoder] Models refreshed: ${allModels.length}`);
-		}
-	};
-
 	// Register with global toggle system so it participates in /toggle-free
 	registerWithGlobalToggle(PROVIDER_QODER, stored, (m) => reRegister(m), false);
 
-	// If user is already authenticated and cache is stale, refresh at startup
-	// (mirrors kilo/cline pattern: check cache freshness before hitting network)
-	try {
-		const cachedCreds = getCachedCredentials();
-		if (cachedCreds?.access && isCacheStale()) {
-			await refreshModels(
-				cachedCreds.access as string,
-				cachedCreds.userID || "qoder-user",
-				cachedCreds.name || "Qoder User",
-				cachedCreds.email || "user@qoder.com",
-			);
-		}
-	} catch {
-		// Best-effort: fall back to cached / static models
-	}
-
-	// Initial registration
-	reRegister(allModels);
-
-	// Refresh models cache on session_start if stale (>1h old)
-	pi.on("session_start", async (_event, ctx) => {
-		try {
-			const accessToken =
-				await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_QODER);
-			if (!accessToken || !isCacheStale()) return;
-			const creds = getCachedCredentials();
-			await refreshModels(
-				accessToken,
-				creds?.userID || "qoder-user",
-				creds?.name || "Qoder User",
-				creds?.email || "user@qoder.com",
-			);
-		} catch {
-			// Best-effort: fall back to existing cache / static models
-		}
+	// Per-provider toggle: /toggle-qoder (basic free-tier ↔ all models)
+	pi.registerCommand("toggle-qoder", {
+		description: "Toggle between basic (free-tier) and all Qoder models",
+		handler: async (_args, ctx) => {
+			try {
+				const applied = toggleState.toggle(reRegister);
+				const basicCount = stored.free.length;
+				const premiumCount = stored.all.length - basicCount;
+				if (applied.mode === "all") {
+					ctx.ui.notify(
+						`qoder: showing all ${stored.all.length} models (${basicCount} basic, ${premiumCount} premium)`,
+						"info",
+					);
+				} else {
+					ctx.ui.notify(
+						`qoder: showing ${stored.free.length} basic (free-tier) models`,
+						"info",
+					);
+				}
+			} catch (err) {
+				logger.error("[qoder] toggle failed", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+				ctx.ui.notify("qoder: toggle failed", "error");
+			}
+		},
 	});
 
+	// Initial registration respects the configured show-paid mode.
+	toggleState.applyCurrent(reRegister);
+
 	logger.info(`[qoder] Provider registered with ${allModels.length} models`);
 }