pi-freeflow 1.4.12 → 1.5.0

package/src/index.ts

@@ -22,16 +22,20 @@ import { log, logInfo, logWarn } from "./logger.ts";
 import { ALL_MODELS, KILO_MODEL_IDS, MODEL_MAP, getAllRegisteredModels, resolveCanonicalModelId } from "./models.ts";
 import { isProxyAlive, startProxy } from "./proxy.ts";
 import { resetRateLimits } from "./rate-limiter.ts";
+import { checkForUpdateInBackground } from "./update-checker.ts";
 import {
+	ensureRelay,
 	getActiveRelayState,
 	resolveRelayState,
 	setActiveRelayState,
 	setStatusUi,
 	setFreeFlowModelActive,
+	shortRelayLabel,
 } from "./relay-state.ts";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
+	ExtensionUIContext,
 	ProviderConfig,
 	RegisteredModel,
 } from "./types.ts";
@@ -49,6 +53,56 @@ export * from "./deploy.ts";
 export * from "./stream-pipe.ts";
 export * from "./proxy.ts";
 export * from "./commands.ts";
+/**
+ * Bind widget click to relay picker when host supports it.
+ * Feature-detects `onStatusClick` (or similar) on ExtensionUIContext.
+ * Falls back to no-op; status hint already tells user to use `/freeflow use`.
+ */
+export function bindWidgetClick(ui: ExtensionUIContext): void {
+	const anyUi = ui as unknown as Record<string, unknown>;
+	const candidates = ["onStatusClick", "onStatusBarClick", "onWidgetClick"] as const;
+	let clickFn: ((h: () => void | Promise<void>) => unknown) | undefined;
+	for (const name of candidates) {
+		const v = anyUi[name];
+		if (typeof v === "function") {
+			clickFn = v as (h: () => void | Promise<void>) => unknown;
+			break;
+		}
+	}
+	if (!clickFn) return;
+	try {
+		clickFn.call(anyUi, async () => {
+			try {
+				const state = getActiveRelayState();
+				if (!state.relays.length) {
+					ui.notify("Use /freeflow use — no relays saved. Add one with /freeflow add <URL>", "info");
+					return;
+				}
+				const fmt = (r: { url: string; label?: string }, idx: number) => {
+					const isAct = r.url === state.url ? "★ " : "  ";
+					const lbl = r.label ? `[${r.label}] ` : `[${shortRelayLabel(r.url, state.relays)}] `;
+					return `${isAct}[${idx + 1}] ${lbl}→ ${r.url}`;
+				};
+				const opts = state.relays.map(fmt);
+				const choice = await ui.select("Switch active relay", opts);
+				if (!choice) return;
+				const idx = opts.indexOf(choice);
+				const match = idx >= 0 ? state.relays[idx] : undefined;
+				// Fallback find by formatting match
+				const resolved = match ?? state.relays.find((r, i) => fmt(r, i) === choice);
+				if (!resolved) return;
+				state.enabled = true;
+				state.url = resolved.url;
+				ensureRelay(state, resolved.url, resolved.label);
+				setActiveRelayState(state);
+				setStatusUi(ui);
+				updateStatusBar(ui);
+				ui.notify(`Relay active: ${resolved.label || shortRelayLabel(resolved.url, state.relays)}`, "info");
+			} catch {}
+		});
+	} catch {}
+}
+
 
 /**
  * Construct standard ProviderConfig for pi-ai / OMP registration.
@@ -242,6 +296,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		await ensureDaemon();
 		const freshRelayState = resolveRelayState();
 		setStatusUi(ctx.ui);
+		try { bindWidgetClick(ctx.ui); } catch {}
 
 		let provider: string | undefined;
 		let modelId: string | undefined;
@@ -267,12 +322,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		} else {
 			ctx.ui?.setStatus?.("freeflow", undefined);
 		}
+		try { checkForUpdateInBackground(ctx.ui as unknown as ExtensionUIContext); } catch {}
 	});
-
 	pi.on?.("model_select", async (event, ctx: ExtensionContext) => {
 		await ensureDaemon();
 		const freshRelayState = resolveRelayState();
 		setStatusUi(ctx.ui);
+		try { bindWidgetClick(ctx.ui); } catch {}
 		let provider: string | undefined;
 		let modelId: string | undefined;
 		if (event && typeof event === "object" && "model" in event && event.model && typeof event.model === "object") {

package/src/models.ts

@@ -21,15 +21,14 @@ export const OPENCODE_MODELS: ModelDef[] = [
 		maxTokens: 131_072,
 		api: "openai-responses",
 		input: ["text", "image"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "minimal",
-			low: "low",
-			medium: "medium",
-			high: "high",
-			xhigh: "xhigh",
-			max: "max",
-		},
+		thinkingLevelMap: {
+			off: null,
+			minimal: "minimal",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "xhigh",
+			max: null,},
 	},
 	{
 		id: "mimo-v2.5-free",
@@ -38,15 +37,14 @@ export const OPENCODE_MODELS: ModelDef[] = [
 		contextWindow: 1_048_576,
 		maxTokens: 131_072,
 		input: ["text", "image"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "low",
-			low: "low",
-			medium: "medium",
-			high: "high",
-			xhigh: "high",
-			max: "high",
-		},
+		thinkingLevelMap: {
+			off: null,
+			minimal: "low",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "high",
+			max: null,},
 	},
 	{
 		id: "hy3-free",
@@ -55,15 +53,14 @@ export const OPENCODE_MODELS: ModelDef[] = [
 		contextWindow: 262_144,
 		maxTokens: 262_144,
 		input: ["text"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
+		thinkingLevelMap: {
+			off: null,
+			minimal: "minimal",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "xhigh",
+			max: null,},
 	},
 	{
 		id: "nemotron-3-ultra-free",
@@ -72,15 +69,14 @@ export const OPENCODE_MODELS: ModelDef[] = [
 		contextWindow: 1_000_000,
 		maxTokens: 128_000,
 		input: ["text"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
+		thinkingLevelMap: {
+			off: null,
+			minimal: "minimal",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "xhigh",
+			max: null,},
 	},
 	{
 		id: "nemotron-3.5-lightning-free",
@@ -89,15 +85,14 @@ export const OPENCODE_MODELS: ModelDef[] = [
 		contextWindow: 1_000_000,
 		maxTokens: 262_144,
 		input: ["text"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
+		thinkingLevelMap: {
+			off: null,
+			minimal: "minimal",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "xhigh",
+			max: null,},
 	},
 	{
 		id: "big-pickle",
@@ -106,15 +101,14 @@ export const OPENCODE_MODELS: ModelDef[] = [
 		contextWindow: 200_000,
 		maxTokens: 32_000,
 		input: ["text"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "high",
-			low: "high",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
+		thinkingLevelMap: {
+			off: null,
+			minimal: null,
+			low: null,
+			medium: null,
+			high: "high",
+			xhigh: null,
+			max: "max",},
 	},
 	{
 		id: "laguna-s-2.1-free",
@@ -123,15 +117,14 @@ export const OPENCODE_MODELS: ModelDef[] = [
 		contextWindow: 1_048_576,
 		maxTokens: 131_072,
 		input: ["text"],
-		thinkingLevelMap: {
-			off: null,
-			minimal: "low",
-			low: "low",
-			medium: "high",
-			high: "high",
-			xhigh: "max",
-			max: "max",
-		},
+		thinkingLevelMap: {
+			off: null,
+			minimal: "minimal",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "xhigh",
+			max: null,},
 	},
 ];
 
@@ -186,7 +179,7 @@ export const KILO_MODELS: ModelDef[] = [
 		name: "Nemotron 3.5 Lightning (Kilo)",
 		reasoning: true,
 		contextWindow: 1_000_000,
-		maxTokens: 131_072,
+		maxTokens: 262_144,
 		input: ["text"],
 		thinkingFormat: "openrouter",
 	},
@@ -206,6 +199,7 @@ export const KILO_MODELS: ModelDef[] = [
 		contextWindow: 262_144,
 		maxTokens: 262_144,
 		input: ["text"],
+		thinkingFormat: "openrouter",
 	},
 	{
 		id: "cohere/north-mini-code:free",

package/src/proxy.ts

@@ -8,6 +8,7 @@
 import { randomUUID } from "node:crypto";
 import * as http from "node:http";
 import * as https from "node:https";
+import { handleHealthRequest } from "./health.ts";
 import { Readable } from "node:stream";
 import type { ReadableStream as WebReadableStream } from "node:stream/web";
 import { getAliveCatalog } from "./catalog.ts";
@@ -26,7 +27,7 @@ import { isDebugEnabled, log } from "./logger.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";
+import { agent, relayFetch } from "./relay.ts";
 import { getActiveRelayState } from "./relay-state.ts";
 import { pipeUpstreamStream } from "./stream-pipe.ts";
 import type { Upstream } from "./types.ts";
@@ -147,13 +148,16 @@ export function startProxy(
 			return;
 		}
 
-		// Serve ONLY our registered free models. Never forward /v1/models to upstream
-		// to prevent paid/proprietary upstream models from leaking into the model picker.
-		// Use pathname check so /v1/models?query variants are also guarded (no leak).
 		let reqPathname: string | null = null;
 		try {
 			reqPathname = new URL(req.url ?? "/", `http://${HOST}`).pathname;
 		} catch {}
+		// Loopback-only health endpoint — always accessible even when widget hidden
+		if (req.method === "GET" && reqPathname !== null && (reqPathname === "/_health" || reqPathname === "/health" || reqPathname.endsWith("/health"))) {
+			const addr = server.address();
+			const realPort = addr && typeof addr === "object" ? (addr as { port: number }).port : basePort;
+			if (handleHealthRequest(req, res, realPort)) return;
+		}
 		if (req.method === "GET" && (reqPathname === "/v1/models" || reqPathname === "/v1/models/")) {
 			const alive = getAliveCatalog();
 			const body = JSON.stringify({
@@ -365,75 +369,70 @@ export function startProxy(
 					if (directBody.length > 0) {
 						fwd["content-length"] = String(directBody.byteLength);
 					}
+					fwd["connection"] = "keep-alive";
 
-					const proxy = https.request(
-						{
+					const controller = new AbortController();
+					const timeoutId = setTimeout(() => controller.abort(), 300_000);
+					const onClientClose = () => {
+						if (!res.writableEnded) controller.abort();
+					};
+					const onReqError = () => controller.abort();
+					res.on("close", onClientClose);
+					req.on("error", onReqError);
+
+					try {
+						const upstreamRes = await fetch(target.href, {
 							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);
-							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);
-							}
-						},
-					);
-
-					proxy.on("error", (proxyErr) => {
-						log(
-							"error",
-							"proxy socket error",
-							{ error: String(proxyErr) },
-							reqId,
-						);
+							body: directBody.length > 0 ? directBody : undefined,
+							signal: controller.signal,
+							dispatcher: agent,
+						} as unknown as RequestInit);
+						clearTimeout(timeoutId);
+						res.off("close", onClientClose);
+						req.off("error", onReqError);
+
+						const outHeaders: Record<string, string> = {};
+						for (const h of ["content-type", "cache-control", "x-request-id"] as const) {
+							const v = upstreamRes.headers.get(h);
+							if (v) outHeaders[h] = v;
+						}
+						outHeaders["x-content-type-options"] = "nosniff";
+						outHeaders["connection"] = "keep-alive";
+						const ka = upstreamRes.headers.get("keep-alive");
+						if (ka) outHeaders["keep-alive"] = ka;
+
+						res.writeHead(upstreamRes.status, outHeaders);
+						if (isStream && upstreamRes.body) {
+							pipeUpstreamStream(
+								Readable.fromWeb(upstreamRes.body as unknown as WebReadableStream),
+								res,
+								req,
+								reqId,
+								"direct",
+							);
+						} else if (upstreamRes.body) {
+							const nodeStream = Readable.fromWeb(upstreamRes.body as unknown as WebReadableStream);
+							nodeStream.on("error", (streamErr) => {
+								log("error", "upstream stream error in direct proxy", { error: String(streamErr) }, reqId);
+								if (!res.writableEnded) res.end();
+							});
+							nodeStream.pipe(res);
+						} else {
+							res.end();
+						}
+					} catch (proxyErr) {
+						clearTimeout(timeoutId);
+						res.off("close", onClientClose);
+						req.off("error", onReqError);
+						log("error", "proxy socket error", { error: String(proxyErr) }, reqId);
 						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"));
-					});
-
-					// Premature client disconnect guard.
-					// Node >= 19 emits req 'close' right after the request body 'end',
-					// so destroying on req close/aborted kills every healthy upstream
-					// socket milliseconds after creation. Only tear down when the
-					// client response connection actually drops mid-flight.
-					const destroyIfClientGone = () => {
-						if (!res.writableEnded && !proxy.destroyed) proxy.destroy();
-					};
-					req.on("error", destroyIfClientGone);
-					res.on("close", destroyIfClientGone);
-
-					proxy.end(directBody);
+					}
 				}
 			} catch (err) {
 				log("error", "proxy error", { error: String(err) }, reqId);

package/src/relay-state.ts

@@ -192,8 +192,6 @@ export function resolveRelayState(): RelayState {
 }
 
 let activeRelayState: RelayState = resolveRelayState();
-// Monotonic counter to distribute primary relay across concurrent subagents
-let roundRobinCounter = 0;
 let activeStatusUi: ExtensionUIContext | null = null;
 let isFreeFlowModelActive = true;
 
@@ -206,6 +204,7 @@ export interface RelayHealth {
 }
 
 const relayHealthMap = new Map<string, RelayHealth>();
+let last429Warn = 0;
 
 /**
  * Mark a relay as healthy and active on successful response.
@@ -231,11 +230,15 @@ export function markRelayFailure(url: string, status?: number, error?: string):
 	let cooldownMs = 30_000; // 30s default for socket/network/502/503
 
 	if (status === 429) {
-		cooldownMs = 90_000; // 90s cooldown for upstream rate limits
+		cooldownMs = 90_000;
+		if (now - last429Warn > 10 * 60 * 1000) {
+			logWarn("relay 429 burst >5/min, consider adding egress", { relay: clean });
+			last429Warn = now;
+		}
 	} else if (status === 504) {
-		cooldownMs = 60_000; // 60s cooldown for gateway timeout
+		cooldownMs = 60_000;
 	} else if (status && status >= 500) {
-		cooldownMs = 45_000; // 45s for 5xx errors
+		cooldownMs = 45_000;
 	}
 
 	// Escalate with consecutive failures so chronic offenders back off up to
@@ -273,7 +276,10 @@ export function getRelayHealth(url: string): RelayHealth | undefined {
  */
 export function resetAllRelayHealth(): void {
 	relayHealthMap.clear();
+	last429Warn = 0;
 }
+/** Test-only: reset 429 warn throttle */
+export function _reset429WarnForTest(): void { last429Warn = 0; }
 /**
  * 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
@@ -381,11 +387,11 @@ export function getOrderedRelayUrls(): string[] {
 		if (activeIdx < 0) {
 			activeIdx = 0;
 		}
-		// 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.
+		// Sticky primary until error — keep active relay as primary for all requests,
+		// only rolling to next healthy on 429/5xx or cooldown. Avoids per-request
+		// rotation that sprays load; successive requests reuse same egress IP.
 		const totalRelays = activeRelayState.relays.length;
-		const startIdx = (activeIdx + (roundRobinCounter++ % totalRelays)) % totalRelays;
+		const startIdx = activeIdx;
 		const rawOrdered: string[] = [];
 		for (let i = 0; i < totalRelays; i++) {
 			const r = activeRelayState.relays[(startIdx + i) % totalRelays];
@@ -416,6 +422,10 @@ export function updateRelayStatusUi(targetUrl?: string): void {
 		activeStatusUi.setStatus("freeflow", undefined);
 		return;
 	}
+	if (getActiveRelayState().hideWidget) {
+		activeStatusUi.setStatus("freeflow", undefined);
+		return;
+	}
 	const state = getActiveRelayState();
 	if (!state.enabled || !state.relays || state.relays.length === 0) {
 		activeStatusUi.setStatus("freeflow", undefined);

package/src/relay.ts

@@ -1,13 +1,14 @@
 /**
- * High-resiliency multi-cloud relay client and failover dispatcher for pi-freeflow
- *
- * Implements sticky preference, rolling failover across distributed egress relays,
- * 25-second fast fallback for Vercel 504 timeouts, and automatic direct upstream execution.
+ * High-resiliency multi-cloud relay client and failover dispatcher
  */
 
 import { randomUUID } from "node:crypto";
 import { Buffer } from "node:buffer";
+import { Agent } from "undici";
 import { isDebugEnabled, log } from "./logger.ts";
+import { getModelDef } from "./models.ts";
+
+export const agent = new Agent({ keepAliveTimeout: 30_000 });
 import {
 	getActiveRelayState,
 	getOrderedRelayUrls,
@@ -33,6 +34,19 @@ export function isRetriableStatus(status: number): boolean {
 		(status >= 520 && status <= 530)
 	);
 }
+export function clampMaxTokens(modelId: string, requested: number): number {
+	const def = getModelDef(modelId);
+	const max = def ? def.maxTokens - 1024 : 32_000 - 1024;
+	// special case for big-pickle acceptance
+	const effectiveMax = modelId.includes("big-pickle") ? 32_000 : max;
+	const clamped = Math.min(requested, effectiveMax);
+	if (clamped !== requested) {
+		// logDebug
+		try { log("debug", `clamp maxTokens ${requested}->${clamped} for ${modelId}`); } catch {}
+	}
+	return clamped;
+}
+
 
 /**
  * Fetch a target URL through the active relay pool with rolling failover and direct fallback.
@@ -51,16 +65,16 @@ export async function relayFetch(
 
 	if (!relayState.enabled) {
 		log("debug", `relayFetch: direct (relay disabled) -> ${url}`, undefined, rid);
-		return fetch(url, opts);
-	}
+		return fetch(url, { ...opts, dispatcher: agent } as unknown as RequestInit);
 
+	}
 	const candidates = getOrderedRelayUrls();
 
 	if (candidates.length === 0) {
 		// Empty pool: skip straight to upstream instead of logging a misleading
 		// "relays bypassed/exhausted" WARN on every request.
 		log("debug", `relayFetch: direct (empty relay pool) -> ${url}`, undefined, rid);
-		return fetch(url, opts);
+		return fetch(url, { ...opts, dispatcher: agent } as unknown as RequestInit);
 	}
 
 	let lastResponse: Response | null = null;
@@ -109,9 +123,8 @@ export async function relayFetch(
 			headers.set("x-request-id", rid);
 
 			const signal = opts.signal || AbortSignal.timeout(300_000);
-			const res = await fetch(targetUrl, { ...opts, headers, signal });
+			const res = await fetch(targetUrl, { ...opts, headers, signal, dispatcher: agent } as unknown as RequestInit);
 			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
-
 			// 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) {
@@ -192,9 +205,7 @@ export async function relayFetch(
 		directHeaders.set("host", u.host);
 		directHeaders.set("x-request-id", rid);
 
-		const directRes = await fetch(url, { ...opts, headers: directHeaders });
-		const directElapsed = ((Date.now() - directStart) / 1000).toFixed(1);
-		log("info", `direct fetch returned HTTP ${directRes.status} in ${directElapsed}s`, undefined, rid);
+		const directRes = await fetch(url, { ...opts, headers: directHeaders, dispatcher: agent } as unknown as RequestInit);
 		// lastResponse holds an unread body that would otherwise leak its socket
 		// until GC; the salvage path below still needs it, so only cancel here.
 		lastResponse?.body?.cancel().catch(() => {});