pi-freeflow 1.0.2 → 1.0.4

package/extensions/index.ts

@@ -739,22 +739,70 @@ function checkRateLimit(ip: string, upstream: Upstream): boolean {
 // Each upstream publishes a model list; fetch it ONCE (cached) and check
 // membership. A 1-token chat probe per model was too slow (large models need
 // 10s+ for the first token). Real usability is validated at chat time (300s).
+const CATALOG_CACHE_FILE = path.join(
+	homedir(),
+	".pi",
+	"agent",
+	"pi-freeflow-catalog-cache.json",
+);
+const CATALOG_CACHE_TTL_MS = 3600_000; // 1 hour
+
+interface CatalogCacheData {
+	timestamp: number;
+	opencode: string[];
+	kilo: string[];
+}
+
+function readCatalogCache(): CatalogCacheData | null {
+	try {
+		if (!fs.existsSync(CATALOG_CACHE_FILE)) return null;
+		const raw = fs.readFileSync(CATALOG_CACHE_FILE, "utf8");
+		const data = JSON.parse(raw) as CatalogCacheData;
+		if (Date.now() - data.timestamp < CATALOG_CACHE_TTL_MS) {
+			return data;
+		}
+	} catch {}
+	return null;
+}
+
+function writeCatalogCache(opencode: string[], kilo: string[]): void {
+	try {
+		const dir = path.dirname(CATALOG_CACHE_FILE);
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		const data: CatalogCacheData = {
+			timestamp: Date.now(),
+			opencode,
+			kilo,
+		};
+		fs.writeFileSync(CATALOG_CACHE_FILE, JSON.stringify(data), "utf8");
+	} catch {}
+}
+
 let opencodeCatalogP: Promise<Set<string> | null> | null = null;
 function opencodeCatalog(): Promise<Set<string> | null> {
 	if (!opencodeCatalogP)
 		opencodeCatalogP = (async () => {
+			const disk = readCatalogCache();
+			if (disk && Array.isArray(disk.opencode) && disk.opencode.length > 0) {
+				return new Set<string>(disk.opencode);
+			}
 			try {
 				const r = await fetch(`${API}/models`, {
 					headers: opencodeHeaders(),
 					signal: AbortSignal.timeout(10_000),
 				});
-				if (!r.ok) return null;
+				if (!r.ok) {
+					// Fallback to static known models if network fails
+					return new Set<string>(KNOWN_MODELS.map((m) => m.id));
+				}
 				const d = await r.json();
-				return new Set<string>(
-					(d?.data ?? []).map((m: { id: string }) => m.id),
-				);
+				const arr = (d?.data ?? []).map((m: { id: string }) => m.id);
+				const s = new Set<string>(arr);
+				const kDisk = disk?.kilo ?? KILO_MODELS.map((m) => m.id);
+				writeCatalogCache(arr, kDisk);
+				return s;
 			} catch {
-				return null;
+				return new Set<string>(KNOWN_MODELS.map((m) => m.id));
 			}
 		})();
 	return opencodeCatalogP;
@@ -763,6 +811,10 @@ let kiloCatalogP: Promise<Set<string> | null> | null = null;
 function kiloCatalog(): Promise<Set<string> | null> {
 	if (!kiloCatalogP)
 		kiloCatalogP = (async () => {
+			const disk = readCatalogCache();
+			if (disk && Array.isArray(disk.kilo) && disk.kilo.length > 0) {
+				return new Set<string>(disk.kilo);
+			}
 			try {
 				const r = await fetch(
 					KILO_CHAT_URL.replace("/chat/completions", "/models"),
@@ -771,13 +823,17 @@ function kiloCatalog(): Promise<Set<string> | null> {
 						signal: AbortSignal.timeout(10_000),
 					},
 				);
-				if (!r.ok) return null;
+				if (!r.ok) {
+					return new Set<string>(KILO_MODELS.map((m) => m.id));
+				}
 				const d = await r.json();
-				return new Set<string>(
-					(d?.data ?? []).map((m: { id: string }) => m.id),
-				);
+				const arr = (d?.data ?? []).map((m: { id: string }) => m.id);
+				const s = new Set<string>(arr);
+				const ocDisk = disk?.opencode ?? KNOWN_MODELS.map((m) => m.id);
+				writeCatalogCache(ocDisk, arr);
+				return s;
 			} catch {
-				return null;
+				return new Set<string>(KILO_MODELS.map((m) => m.id));
 			}
 		})();
 	return kiloCatalogP;
@@ -844,6 +900,54 @@ function sanitizeHeaders(
 	return sanitized;
 }
 
+function normalizeRequestBody(
+	body: Record<string, unknown>,
+	isRelay = false,
+): Record<string, unknown> {
+	// 1. Tool choice normalization (OpenCode Zen only supports "auto" or undefined)
+	if (body.tool_choice === "none") {
+		delete body.tool_choice;
+		delete body.tools;
+	} else if (body.tool_choice && body.tool_choice !== "auto") {
+		body.tool_choice = "auto";
+	}
+
+	// 2. Reasoning normalization
+	if (typeof body.reasoning_effort === "string") {
+		const re = body.reasoning_effort.toLowerCase();
+		if (re === "xhigh" || re === "max") {
+			body.reasoning_effort = "max";
+		} else if (re === "high" || re === "medium") {
+			body.reasoning_effort = "high";
+		} else if (re === "none" || re === "off") {
+			delete body.reasoning_effort;
+		} else {
+			body.reasoning_effort = "low";
+		}
+	}
+	if (body.reasoning && typeof body.reasoning === "object") {
+		const r = body.reasoning as Record<string, unknown>;
+		if (r.effort === "none" || r.effort === "off") {
+			delete r.effort;
+		} else if (typeof r.effort === "string") {
+			const re = r.effort.toLowerCase();
+			if (re === "xhigh" || re === "max") r.effort = "max";
+			else if (re === "high" || re === "medium") r.effort = "high";
+			else r.effort = "low";
+		}
+	}
+
+	// 3. Max tokens clamp for Vercel relay
+	if (isRelay) {
+		const mt = body.max_tokens ?? body.maxTokens;
+		if (typeof mt === "number" && mt > RELAY_MAX_TOKENS) {
+			body.max_tokens = RELAY_MAX_TOKENS;
+		}
+	}
+
+	return body;
+}
+
 // ponytail: shared stream pipe — upstream abort/timeout must end response,
 // not become an uncaught exception that crashes pi.
 function pipeUpstreamStream(
@@ -1017,28 +1121,13 @@ function startProxy(
 							activeHost,
 						);
 						try {
-							// ponytail: clamp max_tokens for Vercel relay — large values
-							// cause 400 "Upstream request failed" (response size / duration
-							// limits). Direct mode stays unconstrained.
 							let relayBody = bodyChunks.length
 								? Buffer.concat(bodyChunks)
 								: undefined;
 							if (relayBody && parsedBody) {
-								const mt = parsedBody.max_tokens ?? parsedBody.maxTokens;
-								if (typeof mt === "number" && mt > RELAY_MAX_TOKENS) {
-									parsedBody.max_tokens = RELAY_MAX_TOKENS;
-								}
-								if (typeof parsedBody.reasoning_effort === "string") {
-									const re = parsedBody.reasoning_effort.toLowerCase();
-									if (re === "xhigh" || re === "max") {
-										parsedBody.reasoning_effort = "max";
-									} else if (re === "high" || re === "medium") {
-										parsedBody.reasoning_effort = "high";
-									} else {
-										parsedBody.reasoning_effort = "low";
-									}
-								}
-								relayBody = Buffer.from(JSON.stringify(parsedBody));
+								const relayBodyObj = structuredClone(parsedBody);
+								normalizeRequestBody(relayBodyObj, true);
+								relayBody = Buffer.from(JSON.stringify(relayBodyObj));
 							}
 							const response = await relayFetch(fullUrl, {
 								method: req.method || "POST",
@@ -1081,16 +1170,10 @@ function startProxy(
 					}
 					// direct path (existing, untouched)
 					let directBody = Buffer.concat(bodyChunks);
-					if (parsedBody && typeof parsedBody.reasoning_effort === "string") {
-						const re = parsedBody.reasoning_effort.toLowerCase();
-						if (re === "xhigh" || re === "max") {
-							parsedBody.reasoning_effort = "max";
-						} else if (re === "high" || re === "medium") {
-							parsedBody.reasoning_effort = "high";
-						} else {
-							parsedBody.reasoning_effort = "low";
-						}
-						directBody = Buffer.from(JSON.stringify(parsedBody));
+					if (parsedBody) {
+						const directBodyObj = structuredClone(parsedBody);
+						normalizeRequestBody(directBodyObj, false);
+						directBody = Buffer.from(JSON.stringify(directBodyObj));
 					}
 					const fwd = sanitizeHeaders(req.headers, target.hostname);
 					if (directBody.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-freeflow",
-	"version": "1.0.2",
+	"version": "1.0.4",
 	"description": "Personal multi-cloud rolling fallback relay for OpenCode Zen and KiloCode models in OMP/Pi",
 	"keywords": [
 		"pi-package",