pi-freeflow 1.1.0 → 1.1.2

package/extensions/index.ts

@@ -88,13 +88,15 @@ function loadRelayState(): RelayState {
 	try {
 		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;
 		return {
-			enabled: Boolean(s?.enabled),
-			url: typeof s?.url === "string" ? s.url.trim() : "",
+			enabled,
+			url: typeof s?.url === "string" ? s.url.trim() : (relays[0]?.url || ""),
 			relays,
 		};
 	} catch {
-		return { enabled: false, url: "", relays: [] };
+		return { enabled: true, url: "", relays: [] };
 	}
 }
 function saveRelayState(s: RelayState): void {
@@ -158,7 +160,8 @@ function isRetriableStatus(status: number): boolean {
 		status === 408 ||
 		status === 402 ||
 		status === 403 ||
-		status === 500
+		status === 500 ||
+		status === 400
 	);
 }
 
@@ -196,12 +199,14 @@ async function relayFetch(
 		const targetUrl = candidates[i];
 		const attemptStart = Date.now();
 		try {
-			const targetHost = new URL(targetUrl).host;
+			let targetHost = "opencode.ai";
+			try {
+				if (targetUrl) targetHost = new URL(targetUrl).host;
+			} catch {}
 			const headers = new Headers(opts.headers);
 			headers.set("x-relay-target", relayTarget);
 			headers.set("x-relay-path", relayPath);
 			headers.set("host", targetHost);
-
 			const signal = opts.signal || AbortSignal.timeout(300_000);
 			const res = await fetch(targetUrl, { ...opts, headers, signal });
 			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
@@ -659,7 +664,8 @@ const KILO_MODELS: ModelDef[] = [
 	},
 ];
 const KILO_MODEL_IDS = new Set(KILO_MODELS.map((m) => m.id));
-
+const ALL_MODELS = [...KNOWN_MODELS, ...KILO_MODELS];
+const MODEL_MAP = new Map(ALL_MODELS.map((m) => [m.id, m]));
 // ── Whitelists ─────────────────────────────────────────────────────
 const ALLOWED_PATH_PATTERN = /^\/v1\/[a-zA-Z0-9/_.,\-?&=]*$/;
 const PATH_TRAVERSAL_PATTERN = /\.\./;
@@ -910,20 +916,29 @@ function sanitizeHeaders(
 function normalizeRequestBody(
 	body: Record<string, unknown>,
 	isRelay = false,
+	isKilo = false,
 ): Record<string, unknown> {
-	// 1. Tool choice normalization (OpenCode Zen only supports "auto" or undefined)
+	// 1. Tool choice & empty tools normalization
+	if (Array.isArray(body.tools) && body.tools.length === 0) {
+		delete body.tools;
+		delete body.tool_choice;
+	}
 	if (body.tool_choice === "none") {
 		delete body.tool_choice;
 		delete body.tools;
-	} else if (body.tool_choice && body.tool_choice !== "auto") {
+	} else if (!isKilo && body.tool_choice && body.tool_choice !== "auto") {
+		// OpenCode Zen only supports "auto" or undefined
 		body.tool_choice = "auto";
 	}
 
 	// 2. Reasoning normalization
+	const modelId = typeof body.model === "string" ? body.model : "";
+	const isResponsesApi = modelId === "muse-spark-1.2-contributor-free";
+
 	if (typeof body.reasoning_effort === "string") {
 		const re = body.reasoning_effort.toLowerCase();
 		if (re === "xhigh" || re === "max") {
-			body.reasoning_effort = "max";
+			body.reasoning_effort = isResponsesApi ? "xhigh" : (modelId === "x-preview-f-free" ? "max" : "xhigh");
 		} else if (re === "high" || re === "medium") {
 			body.reasoning_effort = "high";
 		} else if (re === "minimal") {
@@ -940,18 +955,27 @@ function normalizeRequestBody(
 			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 if (re === "minimal") r.effort = "minimal";
-			else r.effort = "low";
+			if (re === "xhigh" || re === "max") {
+				r.effort = "xhigh"; // OpenCode Zen Responses API strictly requires "xhigh"
+			} else if (re === "high" || re === "medium") {
+				r.effort = "high";
+			} else if (re === "minimal") {
+				r.effort = "minimal";
+			} else {
+				r.effort = "low";
+			}
 		}
 	}
 
-	// 3. Max & Min tokens clamping (OpenCode Zen requires min 16; Vercel relay caps at 64k)
+	// 3. Max & Min tokens clamping (model-specific clamp + Vercel relay clamp)
+	const modelDef = MODEL_MAP.get(modelId);
+	const modelMax = modelDef?.maxTokens ?? RELAY_MAX_TOKENS;
 	const clampTokens = (val: number): number => {
-		if (val < 16) return 16;
-		if (isRelay && val > RELAY_MAX_TOKENS) return RELAY_MAX_TOKENS;
-		return val;
+		let clamped = val;
+		if (!isKilo && clamped < 16) clamped = 16;
+		if (clamped > modelMax) clamped = modelMax;
+		if (isRelay && clamped > RELAY_MAX_TOKENS) clamped = RELAY_MAX_TOKENS;
+		return clamped;
 	};
 
 	if (typeof body.max_tokens === "number") {
@@ -1027,7 +1051,7 @@ function pipeUpstreamStream(
 // ── Start local proxy ──────────────────────────────────────────────
 function startProxy(
 	overridePort?: number,
-): Promise<{ server: http.Server; port: number }> {
+): Promise<{ server: http.Server | null; port: number }> {
 	const basePort = overridePort ?? PORT;
 
 	const server = http.createServer((req, res) => {
@@ -1081,6 +1105,11 @@ function startProxy(
 
 		// Read body to detect model for routing
 		const bodyChunks: Buffer[] = [];
+		req.on("error", (err) => {
+			log("warn", "client request error during body buffering", { error: String(err) });
+			if (!res.headersSent) res.writeHead(400, { "content-type": "application/json" });
+			res.end(JSON.stringify({ error: "bad request" }));
+		});
 		req.on("data", (chunk: Buffer) => bodyChunks.push(chunk));
 		req.on("end", async () => {
 			const bodyStr = Buffer.concat(bodyChunks).toString();
@@ -1104,7 +1133,7 @@ function startProxy(
 					// KiloCode gateway routing (free models are keyless)
 					const isStream = parsedBody.stream === true;
 					const kiloBodyObj = structuredClone(parsedBody);
-					normalizeRequestBody(kiloBodyObj, true);
+					normalizeRequestBody(kiloBodyObj, true, isKilo);
 					const response = await relayFetch(KILO_CHAT_URL, {
 						method: "POST",
 						headers: {
@@ -1142,7 +1171,7 @@ function startProxy(
 					// round-robin: any saved relay qualifies, not just single url
 					if (relayState.enabled && (relayState.url || relayState.relays.length > 0)) {
 						const fullUrl = `${UPSTREAM_OPENCODE}${req.url ?? "/"}`;
-						const activeHost = new URL(relayState.url || DEFAULT_RELAY_URL).host;
+						const activeHost = relayState.url ? new URL(relayState.url).host : "opencode.ai";
 						const relayHeaders = sanitizeHeaders(
 							req.headers,
 							activeHost,
@@ -1153,7 +1182,7 @@ function startProxy(
 								: undefined;
 							if (relayBody && parsedBody) {
 								const relayBodyObj = structuredClone(parsedBody);
-								normalizeRequestBody(relayBodyObj, true);
+								normalizeRequestBody(relayBodyObj, true, isKilo);
 								relayBody = Buffer.from(JSON.stringify(relayBodyObj));
 							}
 							const response = await relayFetch(fullUrl, {
@@ -1190,124 +1219,133 @@ function startProxy(
 							return; // relay handled the response
 						} catch (e) {
 							log("warn", "opencode relay failed, falling back to direct", {
-								error: String(e),
-							});
-							if (res.headersSent) return; // can't recover mid-stream
-						}
-					}
-					// direct path (existing, untouched)
-					let directBody = Buffer.concat(bodyChunks);
-					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) {
-						fwd["content-length"] = String(directBody.byteLength);
-					}
-					const proxy = https.request(
-						{
-							method: req.method,
-							hostname: target.hostname,
-							port: 443,
-							path: target.pathname + target.search,
-							headers: fwd,
-						},
-						(upstream) => {
-							const outHeaders: Record<string, string> = {};
-							for (const h of [
-								"content-type",
-								"cache-control",
-								"x-request-id",
-							]) {
-								const val = upstream.headers[h];
-								if (typeof val === "string") outHeaders[h] = val;
-							}
-							outHeaders["x-content-type-options"] = "nosniff";
-							res.writeHead(upstream.statusCode ?? 502, outHeaders);
-							upstream.pipe(res);
-						},
-					);
-					proxy.on("error", () => {
-						if (!res.headersSent) {
-							res.writeHead(502, { "content-type": "application/json" });
-							res.end(JSON.stringify({ error: "upstream error" }));
-						} else if (!res.writableEnded) {
-							res.end();
-						}
-					});
-					proxy.setTimeout(300_000, () => {
-						proxy.destroy(new Error("timeout"));
-					});
-					req.on("aborted", () => {
-						if (!proxy.destroyed) proxy.destroy();
-					});
-					req.on("close", () => {
-						if (!proxy.destroyed) proxy.destroy();
-					});
-					res.on("close", () => {
-						if (!proxy.destroyed) proxy.destroy();
-					});
-					// ponytail: body already buffered in bodyChunks above for model routing;
-					// req is drained so pipe() would send an empty body → upstream hang → 502.
-					proxy.end(directBody);
-				}
-			} catch (err) {
-				log("error", "proxy error", { error: String(err) });
-				if (!res.headersSent)
-					res.writeHead(502, { "content-type": "application/json" });
-				res.end(JSON.stringify({ error: "internal error" }));
-			}
-		});
-	});
-
-	return new Promise((resolve, reject) => {
-		// ponytail: auto-bump to next free port so multiple pi sessions on one
-		// machine don't fight over 18080. cap at 20 to avoid infinite scan.
-		// use server.address() for the real port: a failed listen()'s callback
-		// still fires on the next successful listen, so the closure `port` is stale.
-		let attempt = 0;
-		let settled = false;
-		const tryListen = (port: number) => {
-			server.once("error", (err: NodeJS.ErrnoException) => {
-				if (settled) return;
-				if (err.code === "EADDRINUSE" && attempt < 20) {
-					attempt++;
-					log("warn", `port ${port} taken — trying ${port + 1}`);
-					tryListen(port + 1);
-					return;
-				}
-				settled = true;
-				log("error", "server error", { code: err.code, message: err.message });
-				reject(err);
-			});
-			server.listen(port, HOST, () => {
-				if (settled) return;
-				settled = true;
-				const addr = server.address();
-				const realPort = addr && typeof addr === "object" ? addr.port : port;
-				log("info", `proxy listening on http://${HOST}:${realPort}`);
-				resolve({ server, port: realPort });
-			});
-		};
-		tryListen(basePort);
-	});
-}
-
-// Probe whether an existing freeflow proxy is already running on a port
-async function isProxyAlive(port: number): Promise<boolean> {
-	try {
-		const res = await fetch(`http://${HOST}:${port}/v1/models`, {
-			signal: AbortSignal.timeout(500),
-		});
-		const ct = res.headers.get("content-type") || "";
-		return res.ok && ct.includes("application/json");
-	} catch {
-		return false;
-	}
-}
-
+ 								error: String(e),
+ 							});
+ 							if (res.headersSent) return; // can't recover mid-stream
+ 						}
+ 					}
+ 					// direct path (existing, untouched)
+ 					let directBody = Buffer.concat(bodyChunks);
+ 					if (parsedBody) {
+ 						const directBodyObj = structuredClone(parsedBody);
+ 						normalizeRequestBody(directBodyObj, false, isKilo);
+ 						directBody = Buffer.from(JSON.stringify(directBodyObj));
+ 					}
+ 					const fwd = sanitizeHeaders(req.headers, target.hostname);
+ 					if (directBody.length > 0) {
+ 						fwd["content-length"] = String(directBody.byteLength);
+ 					}
+ 					const proxy = https.request(
+ 						{
+ 							method: req.method,
+ 							hostname: target.hostname,
+ 							port: 443,
+ 							path: target.pathname + target.search,
+ 							headers: fwd,
+ 						},
+ 						(upstream) => {
+ 							const outHeaders: Record<string, string> = {};
+ 							for (const h of [
+ 								"content-type",
+ 								"cache-control",
+ 								"x-request-id",
+ 							]) {
+ 								const val = upstream.headers[h];
+ 								if (typeof val === "string") outHeaders[h] = val;
+ 							}
+ 							outHeaders["x-content-type-options"] = "nosniff";
+ 							res.writeHead(upstream.statusCode ?? 502, outHeaders);
+ 							upstream.on("error", (streamErr) => {
+ 								log("error", "upstream stream error in direct proxy", { error: String(streamErr) });
+ 								if (!res.writableEnded) res.end();
+ 							});
+ 							upstream.pipe(res);
+ 						},
+ 					);
+ 					proxy.on("error", (proxyErr) => {
+ 						log("error", "proxy socket error", { error: String(proxyErr) });
+ 						if (!res.headersSent) {
+ 							res.writeHead(502, { "content-type": "application/json" });
+ 							res.end(JSON.stringify({ error: "upstream error" }));
+ 						} else if (!res.writableEnded) {
+ 							res.end();
+ 						}
+ 					});
+ 					proxy.setTimeout(300_000, () => {
+ 						proxy.destroy(new Error("timeout"));
+ 					});
+ 					req.on("aborted", () => {
+ 						if (!proxy.destroyed) proxy.destroy();
+ 					});
+ 					req.on("close", () => {
+ 						if (!proxy.destroyed) proxy.destroy();
+ 					});
+ 					res.on("close", () => {
+ 						if (!proxy.destroyed) proxy.destroy();
+ 					});
+ 					// ponytail: body already buffered in bodyChunks above for model routing;
+ 					// req is drained so pipe() would send an empty body → upstream hang → 502.
+ 					proxy.end(directBody);
+ 				}
+ 			} catch (err) {
+ 				log("error", "proxy error", { error: String(err) });
+ 				if (!res.headersSent)
+ 					res.writeHead(502, { "content-type": "application/json" });
+ 				res.end(JSON.stringify({ error: "internal error" }));
+ 			}
+ 		});
+ 	});
+
+ 	return new Promise((resolve, reject) => {
+ 		let attempt = 0;
+ 		let settled = false;
+ 		const tryListen = async (port: number) => {
+ 			server.once("error", async (err: NodeJS.ErrnoException) => {
+ 				if (settled) return;
+ 				if (err.code === "EADDRINUSE") {
+ 					// Re-check if the base port is alive (attached master race)
+ 					if (await isProxyAlive(basePort)) {
+ 						settled = true;
+ 						log("info", `attached to running proxy on http://${HOST}:${basePort}`);
+ 						resolve({ server: null, port: basePort });
+ 						return;
+ 					}
+ 					if (attempt < 20) {
+ 						attempt++;
+ 						log("warn", `port ${port} taken — trying ${port + 1}`);
+ 						tryListen(port + 1);
+ 						return;
+ 					}
+ 				}
+ 				settled = true;
+ 				log("error", "server error", { code: err.code, message: err.message });
+ 				reject(err);
+ 			});
+ 			server.listen(port, HOST, () => {
+ 				if (settled) return;
+ 				settled = true;
+ 				const addr = server.address();
+ 				const realPort = addr && typeof addr === "object" ? addr.port : port;
+ 				log("info", `proxy listening on http://${HOST}:${realPort}`);
+ 				resolve({ server, port: realPort });
+ 			});
+ 		};
+ 		tryListen(basePort);
+ 	});
+ }
+
+ // Probe whether an existing freeflow proxy is already running on a port
+ async function isProxyAlive(port: number): Promise<boolean> {
+ 	try {
+ 		const res = await fetch(`http://${HOST}:${port}/v1/models`, {
+ 			signal: AbortSignal.timeout(500),
+ 		});
+ 		const ct = res.headers.get("content-type") || "";
+ 		return res.ok && ct.includes("application/json");
+ 	} catch {
+ 		return false;
+ 	}
+ }
 // ── Main extension ─────────────────────────────────────────────────
 export default async function (pi: ExtensionAPI) {
 	log("info", "extension loading...");

package/package.json

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