pi-freeflow 1.3.3 → 1.3.7

package/src/models.ts

@@ -305,9 +305,57 @@ export const KILO_MODELS: ModelDef[] = [
 ];
 
 /**
- * Set of all KiloCode model IDs for fast lookup
+ * Model ID Aliases — maps user-friendly / slash-free CLI IDs to canonical upstream model IDs.
  */
-export const KILO_MODEL_IDS = new Set<string>(KILO_MODELS.map((m) => m.id));
+export const MODEL_ALIASES: Record<string, string> = {
+	// Kilo Gateway slash-free & colon-free CLI aliases
+	"dots-3-note-preview": "dots-studio/dots-3-note-preview:free",
+	"dots-3-note-preview:free": "dots-studio/dots-3-note-preview:free",
+	"step-3.7-flash": "stepfun/step-3.7-flash:free",
+	"step-3.7-flash:free": "stepfun/step-3.7-flash:free",
+	"nemotron-3-nano-omni": "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
+	"nemotron-3-nano-omni:free": "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
+	"nemotron-3-ultra-550b": "nvidia/nemotron-3-ultra-550b-a55b:free",
+	"nemotron-3-ultra-550b:free": "nvidia/nemotron-3-ultra-550b-a55b:free",
+	"nemotron-3-super": "nvidia/nemotron-3-super-120b-a12b:free",
+	"nemotron-3-super:free": "nvidia/nemotron-3-super-120b-a12b:free",
+	"hy3:free": "tencent/hy3:free",
+	"north-mini-code": "cohere/north-mini-code:free",
+	"north-mini-code:free": "cohere/north-mini-code:free",
+	"laguna-s-2.1:free": "poolside/laguna-s-2.1:free",
+	"laguna-xs-2.1:free": "poolside/laguna-xs-2.1:free",
+	"lfm-2.5": "liquid/lfm-2.5-2.6b:free",
+	"lfm-2.5:free": "liquid/lfm-2.5-2.6b:free",
+	"content-safety": "nvidia/nemotron-3.5-content-safety:free",
+	"content-safety:free": "nvidia/nemotron-3.5-content-safety:free",
+	"kilo-auto": "kilo-auto/free",
+	"openrouter": "openrouter/free",
+
+	// OpenCode Zen aliases
+	"claude-sonnet-4.5-free": "muse-spark-1.2-contributor-free",
+	"claude-sonnet-4.5-contributor-free": "muse-spark-1.2-contributor-free",
+	"grok-code-fast-1-preview-f-free": "x-preview-f-free",
+	"minimax-m2.1-free": "laguna-s-2.1-free",
+	"qwen3-coder-480b-free": "hy3-free",
+};
+
+/**
+ * Resolve any model alias to its canonical upstream model ID.
+ */
+export function resolveCanonicalModelId(id: string): string {
+	const clean = (id || "").trim();
+	return MODEL_ALIASES[clean] || clean;
+}
+
+/**
+ * Set of all KiloCode model IDs (including aliases) for fast lookup
+ */
+export const KILO_MODEL_IDS = new Set<string>([
+	...KILO_MODELS.map((m) => m.id),
+	...Object.entries(MODEL_ALIASES)
+		.filter(([_, target]) => KILO_MODELS.some((km) => km.id === target))
+		.map(([alias]) => alias),
+]);
 
 /**
  * Combined list of all 23 static free models
@@ -317,22 +365,38 @@ export const ALL_MODELS: ModelDef[] = [...OPENCODE_MODELS, ...KILO_MODELS];
 /**
  * Map of model ID -> ModelDef
  */
-export const MODEL_MAP = new Map<string, ModelDef>(
-	ALL_MODELS.map((m) => [m.id, m]),
-);
-
+export const MODEL_MAP = new Map<string, ModelDef>([
+	...ALL_MODELS.map((m): [string, ModelDef] => [m.id, m]),
+	...Object.entries(MODEL_ALIASES).map(([aliasId, canonicalId]): [string, ModelDef] => {
+		const base = ALL_MODELS.find((m) => m.id === canonicalId);
+		return [
+			aliasId,
+			base
+				? { ...base, id: aliasId }
+				: { id: aliasId, name: aliasId, reasoning: false, contextWindow: 200_000, maxTokens: 32_000, input: ["text"] },
+		];
+	}),
+]);
 /**
  * Lookup a model definition by ID
  */
 export function getModelDef(id: string): ModelDef | undefined {
-	return MODEL_MAP.get(id);
+	return MODEL_MAP.get(id) || MODEL_MAP.get(resolveCanonicalModelId(id));
+}
+/**
+ * Get full list of registered models including CLI aliases
+ */
+export function getAllRegisteredModels(): ModelDef[] {
+	return Array.from(MODEL_MAP.values());
 }
 
+
 /**
  * Check if a model ID belongs to KiloCode Gateway
  */
 export function isKiloModel(id: string): boolean {
-	return KILO_MODEL_IDS.has(id);
+	const canonical = resolveCanonicalModelId(id);
+	return KILO_MODEL_IDS.has(id) || KILO_MODEL_IDS.has(canonical);
 }
 
 /**

package/src/proxy.ts

@@ -23,7 +23,7 @@ import {
 	opencodeHeaders,
 } from "./config.ts";
 import { isDebugEnabled, log } from "./logger.ts";
-import { KILO_MODEL_IDS } from "./models.ts";
+import { KILO_MODEL_IDS, resolveCanonicalModelId } from "./models.ts";
 // normalize removed — host pi-ai already normalizes thinking/reasoning before proxy
 import { checkRateLimit } from "./rate-limiter.ts";
 import { relayFetch } from "./relay.ts";
@@ -87,6 +87,23 @@ export function sanitizeHeaders(
 	return sanitized;
 }
 
+/**
+ * Clamps reasoning_effort for upstream models with strict non-standard enums
+ * (e.g. OpenCode x-preview strictly requires 'low', 'high', or 'max' and rejects 'medium' with 400).
+ */
+function sanitizeReasoningForModel(bodyObj: Record<string, unknown>): void {
+	const model = String(bodyObj.model || "").toLowerCase();
+	if (model.includes("x-preview")) {
+		const effort = String(bodyObj.reasoning_effort || "").toLowerCase();
+		if (effort === "medium") {
+			bodyObj.reasoning_effort = "high";
+		} else if (effort === "minimal") {
+			bodyObj.reasoning_effort = "low";
+		} else if (!effort || effort === "off" || effort === "none") {
+			bodyObj.reasoning_effort = "low";
+		}
+	}
+}
 /**
  * Probe whether an existing pi-freeflow proxy daemon is running and responsive on a given port.
  */
@@ -198,11 +215,12 @@ export function startProxy(
 
 			try {
 				parsedBody = JSON.parse(bodyStr);
-				if (
-					typeof parsedBody?.model === "string" &&
-					KILO_MODEL_IDS.has(parsedBody.model)
-				) {
-					isKilo = true;
+				if (typeof parsedBody?.model === "string") {
+					const canonical = resolveCanonicalModelId(parsedBody.model);
+					parsedBody.model = canonical;
+					if (KILO_MODEL_IDS.has(canonical)) {
+						isKilo = true;
+					}
 				}
 			} catch {}
 
@@ -266,10 +284,11 @@ export function startProxy(
 				} else {
 					// OpenCode routing — relay when enabled, else direct upstream
 					const relayState = getActiveRelayState();
-					if (
-						relayState.enabled &&
-						(relayState.url || relayState.relays.length > 0)
-					) {
+					const shouldUseRelay =
+						relayState.mode !== "off" &&
+						relayState.enabled !== false &&
+						Boolean(relayState.url || (relayState.relays && relayState.relays.length > 0));
+					if (shouldUseRelay) {
 						const fullUrl = `${UPSTREAM_OPENCODE}${req.url ?? "/"}`;
 						const activeHost = relayState.url
 							? new URL(relayState.url).host
@@ -279,6 +298,7 @@ export function startProxy(
 						try {
 							if (parsedBody) {
 								const relayBodyObj = structuredClone(parsedBody);
+								sanitizeReasoningForModel(relayBodyObj as Record<string, unknown>);
 								const relayBody = Buffer.from(JSON.stringify(relayBodyObj));
 								const response = await relayFetch(
 									fullUrl,
@@ -334,6 +354,7 @@ export function startProxy(
 					let directBody = Buffer.concat(bodyChunks);
 					if (parsedBody) {
 						const directBodyObj = structuredClone(parsedBody);
+						sanitizeReasoningForModel(directBodyObj as Record<string, unknown>);
 						directBody = Buffer.from(JSON.stringify(directBodyObj));
 					}
 

package/src/relay-state.ts

@@ -9,27 +9,35 @@ import fs from "node:fs";
 import path from "node:path";
 import { DEFAULT_RELAY_URL, RELAY_STATE_FILE } from "./config.ts";
 import { logWarn } from "./logger.ts";
-import type { ExtensionUIContext, KnownRelay, RelayState } from "./types.ts";
-
+import type { ExtensionUIContext, KnownRelay, RelayMode, RelayState } from "./types.ts";
 /**
  * Load persisted relay state from disk.
  */
 export function loadRelayState(): RelayState {
 	try {
 		if (!fs.existsSync(RELAY_STATE_FILE)) {
-			return { enabled: true, url: DEFAULT_RELAY_URL, relays: [] };
+			return { mode: "auto", enabled: true, url: DEFAULT_RELAY_URL, relays: [] };
 		}
 		const s = JSON.parse(fs.readFileSync(RELAY_STATE_FILE, "utf8"));
 		const relays: KnownRelay[] = Array.isArray(s?.relays) ? s.relays : [];
-		// Auto-on by default if saved relays exist, unless explicitly set to false
-		const enabled = s?.enabled !== undefined ? Boolean(s.enabled) : relays.length > 0;
+		const mode: RelayMode =
+			s?.mode === "on" || s?.mode === "off" || s?.mode === "auto"
+				? s.mode
+				: "auto";
+		const enabled =
+			mode === "on"
+				? true
+				: mode === "off"
+					? false
+					: s?.enabled !== false && relays.length > 0;
 		return {
+			mode,
 			enabled,
 			url: typeof s?.url === "string" ? s.url.trim() : (relays[0]?.url || DEFAULT_RELAY_URL),
 			relays,
 		};
 	} catch {
-		return { enabled: true, url: DEFAULT_RELAY_URL, relays: [] };
+		return { mode: "auto", enabled: true, url: DEFAULT_RELAY_URL, relays: [] };
 	}
 }
 
@@ -51,13 +59,83 @@ export function saveRelayState(s: RelayState): void {
 }
 
 /**
- * Deduplicate and add a relay URL to the known relay list.
+ * Deduplicate and add or update a relay URL in the known relay list.
  */
-export function ensureRelay(s: RelayState, url: string, label?: string): void {
-	if (!url || s.relays.some((r) => r.url === url)) {
-		return;
+export function ensureRelay(
+	s: RelayState,
+	url: string,
+	label?: string,
+): KnownRelay {
+	const cleanUrl = (url || "").trim();
+	if (!cleanUrl) {
+		throw new Error("Relay URL cannot be empty");
+	}
+	const cleanLabel = (label || "").trim() || undefined;
+	const existing = s.relays.find((r) => r.url === cleanUrl);
+	if (existing) {
+		if (cleanLabel && cleanLabel !== "manual") {
+			existing.label = cleanLabel;
+		}
+		return existing;
+	}
+	const newRelay: KnownRelay = {
+		url: cleanUrl,
+		label: cleanLabel && cleanLabel !== "manual" ? cleanLabel : undefined,
+		addedAt: new Date().toISOString(),
+	};
+	s.relays.push(newRelay);
+	return newRelay;
+}
+
+/**
+ * Set or update short name / label for a relay by URL, index, or existing label.
+ */
+export function setRelayLabel(
+	s: RelayState,
+	identifier: string | number,
+	label: string,
+): KnownRelay | null {
+	const relay = findRelay(s, identifier);
+	if (!relay) return null;
+	const cleanLabel = (label || "").trim();
+	relay.label = cleanLabel || undefined;
+	return relay;
+}
+
+/**
+ * Find a relay in state by 1-based index, short name / label, or URL.
+ */
+export function findRelay(
+	s: RelayState,
+	identifier: string | number,
+): KnownRelay | undefined {
+	if (typeof identifier === "number") {
+		const idx = identifier - 1;
+		return s.relays[idx];
+	}
+	const str = String(identifier || "").trim();
+	if (!str) return undefined;
+
+	// 1-based index (e.g. "1", "2")
+	if (/^\d+$/.test(str)) {
+		const num = Number.parseInt(str, 10);
+		if (num >= 1 && num <= s.relays.length) {
+			return s.relays[num - 1];
+		}
 	}
-	s.relays.push({ url, label, addedAt: new Date().toISOString() });
+
+	// Exact URL match
+	const exactUrl = s.relays.find((r) => r.url === str);
+	if (exactUrl) return exactUrl;
+
+	// Case-insensitive label match
+	const byLabel = s.relays.find(
+		(r) => r.label && r.label.toLowerCase() === str.toLowerCase(),
+	);
+	if (byLabel) return byLabel;
+
+	// Partial URL match
+	return s.relays.find((r) => r.url.toLowerCase().includes(str.toLowerCase()));
 }
 
 /**
@@ -87,14 +165,88 @@ export function resolveRelayState(): RelayState {
 	return s;
 }
 
-// In-memory global relay state
 let activeRelayState: RelayState = resolveRelayState();
 // Monotonic counter to distribute primary relay across concurrent subagents
 let roundRobinCounter = 0;
 let activeStatusUi: ExtensionUIContext | null = null;
+let isFreeFlowModelActive = true;
+
+export interface RelayHealth {
+	consecutiveFailures: number;
+	lastFailureTime: number;
+	cooldownUntil: number;
+	lastStatus?: number;
+	lastError?: string;
+}
+
+const relayHealthMap = new Map<string, RelayHealth>();
+
+/**
+ * Mark a relay as healthy and active on successful response.
+ */
+export function markRelaySuccess(url: string): void {
+	if (!url) return;
+	relayHealthMap.delete(url.trim());
+}
+
+/**
+ * Mark a relay as degraded with temporary cooldown on failure/429/timeout/socket error.
+ */
+export function markRelayFailure(url: string, status?: number, error?: string): void {
+	if (!url) return;
+	const clean = url.trim();
+	const prev = relayHealthMap.get(clean) || {
+		consecutiveFailures: 0,
+		lastFailureTime: 0,
+		cooldownUntil: 0,
+	};
+	const consecutive = prev.consecutiveFailures + 1;
+	const now = Date.now();
+	let cooldownMs = 30_000; // 30s default for socket/network/502/503
+
+	if (status === 429) {
+		cooldownMs = 90_000; // 90s cooldown for upstream rate limits
+	} else if (status === 504) {
+		cooldownMs = 60_000; // 60s cooldown for gateway timeout
+	} else if (status && status >= 500) {
+		cooldownMs = 45_000; // 45s for 5xx errors
+	}
+
+	relayHealthMap.set(clean, {
+		consecutiveFailures: consecutive,
+		lastFailureTime: now,
+		cooldownUntil: now + cooldownMs,
+		lastStatus: status,
+		lastError: error,
+	});
+}
+
+/**
+ * Check if a relay is currently healthy (not in active cooldown).
+ */
+export function isRelayHealthy(url: string): boolean {
+	if (!url) return true;
+	const clean = url.trim();
+	const health = relayHealthMap.get(clean);
+	if (!health) return true;
+	return Date.now() >= health.cooldownUntil;
+}
+
+/**
+ * Get current health snapshot for a relay.
+ */
+export function getRelayHealth(url: string): RelayHealth | undefined {
+	return relayHealthMap.get(url.trim());
+}
+
+/**
+ * Reset all in-memory relay health records.
+ */
+export function resetAllRelayHealth(): void {
+	relayHealthMap.clear();
+}
 /**
  * Mtime of the on-disk state file at the moment we last read or wrote it.
- * Lets worker processes pick up relay-pool changes persisted by another
  * session's master daemon, while never clobbering this process's own
  * unpersisted runtime overrides between external writes.
  */
@@ -140,6 +292,12 @@ export function setStatusUi(ui: ExtensionUIContext | null): void {
 	activeStatusUi = ui;
 }
 
+export function setFreeFlowModelActive(active: boolean): void {
+	isFreeFlowModelActive = active;
+	if (!active && activeStatusUi?.setStatus) {
+		activeStatusUi.setStatus("freeflow", undefined);
+	}
+}
 /**
  * Get the current Pi extension UI context
  */
@@ -149,13 +307,27 @@ export function getStatusUi(): ExtensionUIContext | null {
 
 /**
  * Generate a short, human-readable label for a relay URL.
+ * Prefers user-configured label/short name; falls back to clean domain/subdomain.
  */
 export function shortRelayLabel(url: string, relays?: KnownRelay[]): string {
 	const pool = relays || activeRelayState.relays;
 	try {
 		const hit = pool.find((r) => r.url === url);
-		if (hit?.label) return hit.label;
-		return new URL(url).host.split(".")[0];
+		if (hit?.label?.trim() && hit.label.trim() !== "manual") {
+			return hit.label.trim();
+		}
+		const u = new URL(url);
+		const host = u.host;
+		// IP address (e.g. 192.168.1.5:8080 or 10.0.0.1)
+		if (/^(\d{1,3}\.){3}\d{1,3}(:\d+)?$/.test(host)) {
+			return host;
+		}
+		const parts = host.split(".");
+		if (parts.length >= 3) {
+			// E.g. "my-relay" from "my-relay.workers.dev" or "my-app.vercel.app"
+			return parts[0];
+		}
+		return parts[0] || host;
 	} catch {
 		return url.slice(0, 18);
 	}
@@ -183,19 +355,23 @@ export function getOrderedRelayUrls(): string[] {
 		// Rotate starting point per-request to avoid thundering herd when many
 		// subagents hit the shared 127.0.0.1 daemon at once — each request
 		// tries a different primary relay, but still rolls seamlessly on 429.
-		const startIdx = (activeIdx + (roundRobinCounter++ % activeRelayState.relays.length)) % activeRelayState.relays.length;
-		const ordered: string[] = [];
-		for (let i = 0; i < activeRelayState.relays.length; i++) {
-			const r = activeRelayState.relays[(startIdx + i) % activeRelayState.relays.length];
+		const totalRelays = activeRelayState.relays.length;
+		const startIdx = (activeIdx + (roundRobinCounter++ % totalRelays)) % totalRelays;
+		const rawOrdered: string[] = [];
+		for (let i = 0; i < totalRelays; i++) {
+			const r = activeRelayState.relays[(startIdx + i) % totalRelays];
 			if (r?.url?.trim()) {
-				ordered.push(r.url.trim());
+				rawOrdered.push(r.url.trim());
 			}
 		}
+
+		// Partition into healthy candidates first, degraded/cooling candidates at the tail
+		const healthy = rawOrdered.filter((u) => isRelayHealthy(u));
+		const cooling = rawOrdered.filter((u) => !isRelayHealthy(u));
+		const ordered = [...healthy, ...cooling];
+
 		return ordered.length > 0 ? ordered : [DEFAULT_RELAY_URL];
 	}
-	if (activeRelayState.url?.trim()) {
-		return [activeRelayState.url.trim()];
-	}
 	return [DEFAULT_RELAY_URL];
 }
 
@@ -206,13 +382,20 @@ export function updateRelayStatusUi(targetUrl?: string): void {
 	if (!activeStatusUi?.setStatus) {
 		return;
 	}
-	const currentUrl = targetUrl || activeRelayState.url;
-	if (!activeRelayState.enabled || !currentUrl) {
-		activeStatusUi.setStatus("freeflow", activeRelayState.enabled ? "relay: direct" : "relay: OFF");
+	// Do not update status bar if the user switched to another provider (e.g. Gemini/Claude)
+	if (!isFreeFlowModelActive) {
+		activeStatusUi.setStatus("freeflow", undefined);
+		return;
+	}
+	const state = getActiveRelayState();
+	if (!state.enabled || !state.relays || state.relays.length === 0) {
+		activeStatusUi.setStatus("freeflow", undefined);
 		return;
 	}
+	const currentUrl = targetUrl || state.url || state.relays[0]?.url || "";
 	const label = shortRelayLabel(currentUrl);
-	const total = activeRelayState.relays.length || 1;
-	const pos = Math.max(1, activeRelayState.relays.findIndex((r) => r.url === currentUrl) + 1);
-	activeStatusUi.setStatus("freeflow", `relay: ON | ${label} ${pos}/${total}`);
+	const total = state.relays.length || 1;
+	const pos = Math.max(1, state.relays.findIndex((r) => r.url === currentUrl) + 1);
+	const modeLabel = state.mode === "on" ? "ON" : "AUTO (ON)";
+	activeStatusUi.setStatus("freeflow", `relay: ${modeLabel} | ${label} ${pos}/${total}`);
 }

package/src/relay.ts

@@ -11,6 +11,8 @@ import { isDebugEnabled, log } from "./logger.ts";
 import {
 	getActiveRelayState,
 	getOrderedRelayUrls,
+	markRelayFailure,
+	markRelaySuccess,
 	saveRelayState,
 	setActiveRelayState,
 	shortRelayLabel,
@@ -106,6 +108,7 @@ export async function relayFetch(
 			// Vercel 504 Gateway Timeout on heavy prompts (>50KB or >25s):
 			// Fast fallback directly to upstream instead of cycling through multiple 25s timeouts.
 			if (res.status === 504) {
+				markRelayFailure(targetUrl, 504, "Gateway Timeout (25s exceeded)");
 				log(
 					"warn",
 					`relay ${targetUrl} hit HTTP 504 Gateway Timeout in ${elapsed}s (prompt evaluation exceeded Vercel 25s limit) — fast fallback to direct upstream`,
@@ -116,6 +119,7 @@ export async function relayFetch(
 			}
 
 			if (isRetriableStatus(res.status)) {
+				markRelayFailure(targetUrl, res.status);
 				lastResponse = res;
 				log(
 					"warn",
@@ -126,6 +130,8 @@ export async function relayFetch(
 				continue;
 			}
 
+			markRelaySuccess(targetUrl);
+
 			// SUCCESS or non-retriable client error (e.g. 200, 404):
 			// If we switched to a different relay because previous failed, update sticky active relay!
 			if (relayState.url !== targetUrl) {
@@ -151,10 +157,12 @@ export async function relayFetch(
 		} catch (err) {
 			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
 			lastError = err;
+			const errMsg = (err as Error)?.message || String(err);
+			markRelayFailure(targetUrl, 0, errMsg);
 			log(
 				"warn",
 				`relay ${targetUrl} fetch error in ${elapsed}s — rolling to next relay`,
-				{ upstream: url, error: String(err) },
+				{ upstream: url, error: errMsg },
 				rid,
 			);
 			continue;

package/src/types.ts

@@ -39,13 +39,14 @@ export interface KnownRelay {
 	label?: string;
 	addedAt?: string;
 }
+export type RelayMode = "auto" | "on" | "off";
 
 export interface RelayState {
+	mode?: RelayMode;
 	enabled: boolean;
 	url: string;
 	relays: KnownRelay[];
 }
-
 export type LogLevel = "debug" | "info" | "warn" | "error" | "audit";
 
 export interface DebugState {