pi-freeflow 1.3.6 → 1.3.8

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "pi-freeflow",
 	"type": "module",
-	"version": "1.3.6",
+	"version": "1.3.8",
 	"description": "Thin provider for OMP/Pi — model list + dumb relay proxy + log; host pi-ai owns thinking/normalization",
 	"main": "extensions/index.ts",
 	"types": "src/index.ts",

package/src/commands.ts

@@ -19,6 +19,8 @@ import {
 	ensureRelay,
 	findRelay,
 	getActiveRelayState,
+	getRelayHealth,
+	isRelayHealthy,
 	removeRelay,
 	saveRelayState,
 	setActiveRelayState,
@@ -254,7 +256,13 @@ export function createCommandSpec(
 					const star = r.url === relayState.url ? "★" : " ";
 					const shortName = r.label ? `[${r.label}]` : `[${shortRelayLabel(r.url, relayState.relays)}]`;
 					const paddedName = shortName.padEnd(16, " ");
-					return `${star} [${idx + 1}] ${paddedName} → ${r.url}`;
+					const health = getRelayHealth(r.url);
+					const isCooling = health && Date.now() < health.cooldownUntil;
+					const remainingSec = isCooling ? Math.ceil((health.cooldownUntil - Date.now()) / 1000) : 0;
+					const healthBadge = isCooling
+						? ` ⚠️ [cooling ${remainingSec}s: ${health.lastStatus ? `HTTP ${health.lastStatus}` : "error"}]`
+						: " ✓";
+					return `${star} [${idx + 1}] ${paddedName} → ${r.url}${healthBadge}`;
 				});
 				const activeLabel = shortRelayLabel(relayState.url, relayState.relays);
 				const activeIdx = Math.max(

package/src/proxy.ts

@@ -273,6 +273,7 @@ export function startProxy(
 							res,
 							req,
 							reqId,
+							relayPreview.url,
 						);
 					} else {
 						const data = await response.text();
@@ -328,6 +329,7 @@ export function startProxy(
 										res,
 										req,
 										reqId,
+										relayState.url,
 									);
 								} else {
 									const data = await response.text();
@@ -392,16 +394,20 @@ export function startProxy(
 							}
 							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) },
-									reqId,
-								);
-								if (!res.writableEnded) res.end();
-							});
-							upstream.pipe(res);
+							if (isStream) {
+								pipeUpstreamStream(upstream, res, req, reqId, "direct");
+							} else {
+								upstream.on("error", (streamErr) => {
+									log(
+										"error",
+										"upstream stream error in direct proxy",
+										{ error: String(streamErr) },
+										reqId,
+									);
+									if (!res.writableEnded) res.end();
+								});
+								upstream.pipe(res);
+							}
 						},
 					);
 

package/src/relay-state.ts

@@ -170,6 +170,81 @@ let activeRelayState: RelayState = resolveRelayState();
 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.
  * session's master daemon, while never clobbering this process's own
@@ -280,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];
 }
 

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/stream-pipe.ts

@@ -9,7 +9,7 @@ import { randomUUID } from "node:crypto";
 import type * as http from "node:http";
 import type { Readable } from "node:stream";
 import { isDebugEnabled, log } from "./logger.ts";
-
+import { markRelayFailure } from "./relay-state.ts";
 /**
  * Pipes an upstream readable stream to a client HTTP response.
  *
@@ -23,6 +23,7 @@ export function pipeUpstreamStream(
 	res: http.ServerResponse,
 	req: http.IncomingMessage,
 	reqId?: string,
+	relayUrl?: string,
 ): void {
 	const rid = reqId || randomUUID().slice(0, 8);
 	let totalChunks = 0;
@@ -31,6 +32,8 @@ export function pipeUpstreamStream(
 	let thinkingBytes = 0;
 	let firstChunkAt: number | null = null;
 	const startAt = Date.now();
+	const isResponsesApi = req.url?.includes("/responses") ?? false;
+	let hasTerminalEvent = false;
 
 	const sniffThinking = (chunk: Buffer | string): boolean => {
 		const s =
@@ -47,12 +50,53 @@ export function pipeUpstreamStream(
 		);
 	};
 
+	const checkTerminalEvent = (s: string): boolean => {
+		return (
+			s.includes("response.completed") ||
+			s.includes("response.done") ||
+			s.includes("response.failed") ||
+			s.includes("response.incomplete") ||
+			s.includes("[DONE]")
+		);
+	};
+
+	const ensureTerminalEvent = (isError = false, errorMsg?: string) => {
+		if (hasTerminalEvent || res.writableEnded) return;
+		if (relayUrl && relayUrl !== "direct") {
+			markRelayFailure(relayUrl, 0, errorMsg || "stream truncated prematurely");
+		}
+		if (isResponsesApi && totalChunks > 0) {
+			try {
+				if (isError) {
+					res.write(
+						`\nevent: response.failed\ndata: {"type":"response.failed","response":{"status":"failed","error":{"code":"stream_error","message":${JSON.stringify(errorMsg || "Upstream stream disconnected unexpectedly")}}}}\n\n`,
+					);
+				} else {
+					res.write(
+						`\nevent: response.incomplete\ndata: {"type":"response.incomplete","response":{"status":"incomplete","incomplete_details":{"reason":"cancelled"}}}\n\n`,
+					);
+				}
+				hasTerminalEvent = true;
+				log(
+					"warn",
+					`injected synthetic response.${isError ? "failed" : "incomplete"} for prematurely truncated stream`,
+					{ totalChunks, totalBytes, isError, errorMsg },
+					rid,
+				);
+			} catch {}
+		} else if (!isResponsesApi && totalChunks > 0) {
+			try {
+				res.write("\ndata: [DONE]\n\n");
+				hasTerminalEvent = true;
+			} catch {}
+		}
+	};
+
 	try {
 		if (typeof res.flushHeaders === "function") {
 			res.flushHeaders();
 		}
 	} catch {}
-
 	nodeStream.on("data", (chunk: Buffer | string) => {
 		try {
 			if (firstChunkAt === null) {
@@ -82,6 +126,14 @@ export function pipeUpstreamStream(
 				}
 			}
 
+			const strPreview =
+				typeof chunk === "string"
+					? chunk
+					: chunk.toString("utf8", 0, Math.min(chunk.length, 2000));
+			if (!hasTerminalEvent && checkTerminalEvent(strPreview)) {
+				hasTerminalEvent = true;
+			}
+
 			res.write(chunk);
 			const maybeFlush = res as unknown as { flush?: () => void };
 			if (typeof maybeFlush.flush === "function") {
@@ -91,15 +143,18 @@ export function pipeUpstreamStream(
 	});
 
 	nodeStream.on("error", (e: unknown) => {
+		const errorMsg = (e as Error)?.message || String(e);
 		log(
 			"error",
 			"upstream stream error",
-			{ error: String(e), totalChunks, thinkingChunks },
+			{ error: errorMsg, totalChunks, thinkingChunks, hasTerminalEvent },
 			rid,
 		);
 		try {
 			if (!res.headersSent) {
 				res.writeHead(502, { "content-type": "application/json" });
+			} else {
+				ensureTerminalEvent(true, errorMsg);
 			}
 			if (!res.writableEnded) {
 				res.end();
@@ -109,6 +164,9 @@ export function pipeUpstreamStream(
 
 	nodeStream.on("end", () => {
 		const elapsed = ((Date.now() - startAt) / 1000).toFixed(1);
+		if (!hasTerminalEvent && totalChunks > 0) {
+			ensureTerminalEvent(false);
+		}
 		if (thinkingChunks > 0) {
 			log(
 				"info",
@@ -131,6 +189,9 @@ export function pipeUpstreamStream(
 
 	nodeStream.on("close", () => {
 		try {
+			if (!hasTerminalEvent && totalChunks > 0) {
+				ensureTerminalEvent(true, "stream closed prematurely");
+			}
 			if (!res.writableEnded) res.end();
 		} catch {}
 	});