pi-freeflow 1.7.1 → 1.8.1

package/README.md

@@ -1,6 +1,6 @@
 # pi-freeflow 🌊
 
-> **25 free models. Up to 1M context. Zero API keys. Infinite scale via your own relay pool.**
+> **28 free models. Up to 1M context. Zero API keys. Infinite scale via your own relay pool.**
 
 Thin by design: model list + dumb relay + log. Host `pi-ai` owns thinking, normalization & provider magic. We just make it free, fast, and unbreakable.
 
@@ -18,7 +18,7 @@ Join devs bypassing rate limits with their own relay pools. BYO, add as many as
 
 | Feature | Description | Value | Cost |
 | :--- | :--- | :--- | :--- |
-| **25 Curated Free Models** | 7 OpenCode Zen + 18 KiloCode Gateway models, up to 1M context & 512K output | Ceiling Unlocked | **$0** |
+| **28 Curated Free Models** | 8 OpenCode Zen + 20 KiloCode Gateway models, up to 1M context & 512K output | Ceiling Unlocked | **$0** |
 | **BYO Relay Pool** | Round-robin load balancing across your Cloudflare Workers & Vercel Edges | Zero Rate Limits | **$0** (your free tiers) |
 | **Adaptive Health & Error Detection** | Auto-cooldown on 429 rate limits, 504 timeouts, and socket drops | 0ms Wasted Latency | **$0** |
 | **Stream Truncation Resilience** | Stateful SSE terminal tracking (`response.failed` / `response.incomplete` injection) | Zero Host Crashes | **$0** |
@@ -32,7 +32,7 @@ Philosophy: **Thin by design.** We only ship model list + relay proxy + log. Hos
 
 ---
 
-### 25 Curated Models, One Command
+### 28 Curated Models, One Command
 
 ```bash
 /model → freeflow → pick
@@ -269,7 +269,7 @@ Current size: about 11.3k lines including tests. 230 tests pass, typecheck clean
 ### FAQ
 
 **Do I need API keys?**
-No. Kilo uses `Bearer kilo-free`, OpenCode uses `opencodeHeaders()`.
+No. Kilo uses `Bearer kilo-free`, OpenCode free models are anonymous (no header needed).
 
 **What if all relays are 429?**
 Proxy tries direct. If that is also 429, Pi shows the rate limit. That number is the global upstream cap; without relays you would hit the same wall.
@@ -277,6 +277,12 @@ Proxy tries direct. If that is also 429, Pi shows the rate limit. That number is
 **Can I use without relays?**
 Yes. `/freeflow off` → direct. Add relays later to scale.
 
+**What happens when I update to a new version?**
+The local proxy daemon is shared across sessions on port 28180. On upgrade, the new extension
+detects a stale daemon (mismatched internal version) and replaces it automatically — no manual
+kill, no restart of other sessions required. If an old daemon cannot be replaced (e.g. port held
+by an unrelated process), it falls back to reusing it with a warning.
+
 **Where's the normalizer?**
 Deleted in 1.3.0. If zai/qwen/deepseek thinking broke before, it's fixed now because host handles it.
 
@@ -324,7 +330,7 @@ pnpm smoke       # verifies extensions/index.ts loads without crashing
 ```
 src/
 ├── index.ts          # extension entry, lifecycle hooks
-├── models.ts         # 25-model catalog definitions
+├── models.ts         # 28-model catalog definitions
 ├── catalog.ts        # model catalog cache (24h disk)
 ├── proxy.ts          # local proxy server (127.0.0.1:28180)
 ├── relay.ts          # relay selection & round-robin

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "pi-freeflow",
-  "type": "module",
-  "version": "1.7.1",
-  "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",
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "oh-my-pi",
-    "omp",
-    "free-models",
-    "opencode",
-    "kilocode",
-    "ai-models",
-    "relay"
-  ],
-  "author": "trefeon",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/trefeon/pi-freeflow.git"
-  },
-  "homepage": "https://github.com/trefeon/pi-freeflow#readme",
-  "engines": {
-    "node": ">=22.19.0"
-  },
-  "omp": {
-    "extensions": [
-      "./extensions"
-    ]
-  },
-  "pi": {
-    "extensions": [
-      "./extensions"
-    ]
-  },
-  "files": [
-    "extensions",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "test": "node --experimental-strip-types --test --test-concurrency=1 test/**/*.test.ts",
-    "typecheck": "tsc --noEmit",
-    "smoke": "node --experimental-strip-types -e \"import('./extensions/index.ts').then(() => console.log('✓ Smoke test passed: extensions/index.ts loaded successfully')).catch(err => { console.error(err); process.exit(1); })\"",
-    "changeset": "changeset",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs"
-  },
-  "devDependencies": {
-    "@changesets/cli": "^2.27.0",
-    "@types/node": "^22.13.9",
-    "typescript": "^5.8.2",
-    "vitepress": "^1.6.4"
-  },
-  "dependencies": {
-    "undici": "^8.10.0"
-  }
-}
+{
+  "name": "pi-freeflow",
+  "type": "module",
+  "version": "1.8.1",
+  "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",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "oh-my-pi",
+    "omp",
+    "free-models",
+    "opencode",
+    "kilocode",
+    "ai-models",
+    "relay"
+  ],
+  "author": "trefeon",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trefeon/pi-freeflow.git"
+  },
+  "homepage": "https://github.com/trefeon/pi-freeflow#readme",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "omp": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "files": [
+    "extensions",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --experimental-strip-types --test --test-concurrency=1 test/**/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "smoke": "node --experimental-strip-types -e \"import('./extensions/index.ts').then(() => console.log('✓ Smoke test passed: extensions/index.ts loaded successfully')).catch(err => { console.error(err); process.exit(1); })\"",
+    "changeset": "changeset",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.0",
+    "@types/node": "^22.13.9",
+    "typescript": "^5.8.2",
+    "vitepress": "^1.6.4"
+  },
+  "dependencies": {
+    "undici": "^8.10.0"
+  }
+}

package/src/catalog.ts

@@ -34,7 +34,7 @@ import type {
 export const DEAD_MODEL_IDS = new Set<string>(["deepseek-v4-flash-free", "x-preview-f-free"]);
 /**
  * In-memory cache of currently active/available free models.
- * Initialized with all 25 verified models for 0ms instant availability.
+ * Initialized with all 28 verified models for 0ms instant availability.
  */
 let aliveCatalog: RegisteredModel[] = ALL_MODELS.map((m) => ({
 	...m,
@@ -328,6 +328,6 @@ export async function refreshCatalog(force = false): Promise<RegisteredModel[]>
 	} catch (err) {
 		logDebug("Failed reading stale catalog cache", { error: String(err) });
 	}
-	// No valid cache — return in-memory static 25 (host will refresh if needed)
+	// No valid cache — return in-memory static 28 (host will refresh if needed)
 	return aliveCatalog;
 }

package/src/config.ts

@@ -6,8 +6,21 @@ import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 import type { Upstream } from "./types.ts";
 
+// Package version — stale-daemon detection in the shared-port reuse path.
+let PKG_VERSION = "0.0.0";
+try {
+	const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
+	const raw: unknown = JSON.parse(readFileSync(pkgPath, "utf8"));
+	if (raw && typeof raw === "object" && "version" in raw) {
+		const v = raw.version;
+		if (typeof v === "string" && v) PKG_VERSION = v;
+	}
+} catch {}
+export { PKG_VERSION };
+
 // ── Upstream endpoints ──────────────────────────────────────────────
 export const UPSTREAM_OPENCODE = "https://opencode.ai/zen";
 export const KILO_CHAT_URL = "https://api.kilo.ai/api/gateway/chat/completions";

package/src/health.ts

@@ -6,8 +6,7 @@
 import type * as http from "node:http";
 import { ALL_MODELS } from "./models.ts";
 import { getActiveRelayState, getRelayHealth, isRelayHealthy } from "./relay-state.ts";
-import { PORT } from "./config.ts";
-import { getClientIP } from "./proxy.ts";
+import { PKG_VERSION, PORT } from "./config.ts";
 
 export interface HealthRelayInfo {
 	url: string;
@@ -24,8 +23,8 @@ export interface HealthData {
 	enabled: boolean;
 	relays: HealthRelayInfo[];
 	catalog: number;
+	version: string;
 }
-
 /**
  * Collect current health snapshot.
  * @param portOverride - actual listening port (defaults to config PORT)
@@ -50,6 +49,7 @@ export function getHealthData(portOverride?: number): HealthData {
 		enabled: Boolean(state.enabled),
 		relays,
 		catalog: ALL_MODELS.length,
+		version: PKG_VERSION,
 	};
 }
 
@@ -76,13 +76,18 @@ export function handleHealthRequest(
 		return false;
 	}
 
-	const isHealthPath =
-		pathname === "/_health" || pathname === "/health" || pathname.endsWith("/health");
+	const isHealthPath = pathname === "/_health" || pathname === "/health";
 	if (req.method !== "GET" || !isHealthPath) {
 		return false;
 	}
 
-	const clientIP = getClientIP(req);
+	const sock: unknown = req.socket;
+	let rawIp = "";
+	if (sock && typeof sock === "object" && "remoteAddress" in sock) {
+		const v = sock.remoteAddress;
+		if (typeof v === "string") rawIp = v;
+	}
+	const clientIP = rawIp.startsWith("::ffff:") ? rawIp.slice(7) : rawIp;
 	if (!isLoopbackIP(clientIP)) {
 		const body = JSON.stringify({ error: "forbidden" });
 		res.writeHead(403, { "content-type": "application/json", "content-length": Buffer.byteLength(body) });

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * pi-freeflow — Modular, high-resiliency LLM extension for Pi & Oh My Pi (OMP)
  *
- * Provides access to 25 free models (7 OpenCode Zen + 18 KiloCode Gateway) with:
+ * Provides access to 28 free models (8 OpenCode Zen + 20 KiloCode Gateway) with:
  * - Single-port daemon reuse on 28180 across concurrent subagents
  * - Multi-cloud rolling egress relays (Vercel Edge, Cloudflare, Deno)
  * - 0ms instant startup with verified static catalog and background live health checks
@@ -18,10 +18,10 @@ import {
 	setAliveCatalog,
 } from "./catalog.ts";
 import { createCommandSpec, updateStatusBar } from "./commands.ts";
-import { HOST, LEGACY_PORT, ONBOARDED_FLAG_FILE, PORT } from "./config.ts";
+import { HOST, LEGACY_PORT, ONBOARDED_FLAG_FILE, PKG_VERSION, PORT } from "./config.ts";
 import { log, logInfo, logWarn } from "./logger.ts";
 import { ALL_MODELS, KILO_MODEL_IDS, MODEL_MAP, resolveCanonicalModelId } from "./models.ts";
-import { isProxyAlive, startProxy } from "./proxy.ts";
+import { getDaemonVersion, isProxyAlive, killPortHolder, startProxy } from "./proxy.ts";
 import { resetRateLimits } from "./rate-limiter.ts";
 import { checkForUpdateInBackground } from "./update-checker.ts";
 import {
@@ -114,7 +114,7 @@ export function buildProviderConfig(
 ): ProviderConfig {
 	return {
 		baseUrl: `http://${HOST}:${port}/v1`,
-		apiKey: "placeholder",
+		apiKey: "public",
 		api: "openai-completions",
 		compat: { supportsDeveloperRole: false },
 		models: models.map((m) => {
@@ -174,18 +174,81 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	// 2. Single-Port Shared Pattern: Check if daemon is already running (e.g. parent session)
 	// Dual-probe: probe current PORT first; if missing, check LEGACY_PORT so existing v1.4.9
 	// sessions on 18080 are seamlessly reused without split-brain or duplicate daemons.
+	// Stale-daemon heal: if the alive daemon reports a different version (e.g. 1.7.1 vs 1.8.0
+	// after an upgrade), the auth fix never loads for the new session. Detect via /_health
+	// and best-effort replace the stale holder so old users are auto-healed.
 	let alreadyRunning = await isProxyAlive(PORT);
 	if (alreadyRunning) {
-		logInfo(
-			`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${PORT}`,
-		);
-		actualPort = PORT;
+		const remoteVer = await getDaemonVersion(PORT);
+		if (remoteVer !== null && remoteVer !== PKG_VERSION) {
+			logWarn(`stale proxy daemon v${remoteVer} on :${PORT} (need v${PKG_VERSION}) — replacing`, {
+				remoteVer,
+				expected: PKG_VERSION,
+			});
+			const killed = await killPortHolder(PORT);
+			if (killed) {
+				for (let i = 0; i < 10; i++) {
+					await new Promise<void>((r) => setTimeout(r, 200));
+					if (!(await isProxyAlive(PORT))) break;
+				}
+			}
+			if (!(await isProxyAlive(PORT))) {
+				try {
+					const r = await startProxy();
+					server = r.server;
+					actualPort = r.port;
+					alreadyRunning = false;
+				} catch (e) {
+					log("error", "stale daemon replaced but fresh bind failed — reusing stale as fallback", {
+						error: String(e),
+					});
+					actualPort = PORT;
+				}
+			} else {
+				logInfo(`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${PORT} (stale kill did not free port)`);
+				actualPort = PORT;
+			}
+		} else {
+			logInfo(`Reusing existing pi-freeflow proxy daemon on http://${HOST}:${PORT}`);
+			actualPort = PORT;
+		}
 	} else if (PORT !== LEGACY_PORT && (await isProxyAlive(LEGACY_PORT))) {
-		logInfo(
-			`Reusing existing legacy pi-freeflow proxy daemon on http://${HOST}:${LEGACY_PORT}`,
-		);
-		alreadyRunning = true;
-		actualPort = LEGACY_PORT;
+		const remoteVer = await getDaemonVersion(LEGACY_PORT);
+		if (remoteVer !== null && remoteVer !== PKG_VERSION) {
+			logWarn(`stale legacy daemon v${remoteVer} on :${LEGACY_PORT} (need v${PKG_VERSION}) — replacing`, {
+				remoteVer,
+				expected: PKG_VERSION,
+			});
+			const killed = await killPortHolder(LEGACY_PORT);
+			if (killed) {
+				for (let i = 0; i < 10; i++) {
+					await new Promise<void>((r) => setTimeout(r, 200));
+					if (!(await isProxyAlive(LEGACY_PORT))) break;
+				}
+			}
+			if (!(await isProxyAlive(LEGACY_PORT)) && !(await isProxyAlive(PORT))) {
+				try {
+					const r = await startProxy();
+					server = r.server;
+					actualPort = r.port;
+					alreadyRunning = false;
+				} catch (e) {
+					log("error", "stale legacy daemon replaced but fresh bind failed — reusing as fallback", {
+						error: String(e),
+					});
+					alreadyRunning = true;
+					actualPort = LEGACY_PORT;
+				}
+			} else {
+				logInfo(`Reusing existing legacy pi-freeflow proxy daemon on http://${HOST}:${LEGACY_PORT}`);
+				alreadyRunning = true;
+				actualPort = LEGACY_PORT;
+			}
+		} else {
+			logInfo(`Reusing existing legacy pi-freeflow proxy daemon on http://${HOST}:${LEGACY_PORT}`);
+			alreadyRunning = true;
+			actualPort = LEGACY_PORT;
+		}
 	} else {
 		try {
 			const r = await startProxy();
@@ -200,8 +263,6 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			return;
 		}
 	}
-
-	// 3. Instant 0ms Static Catalog Registration
 	// Register static models immediately on boot so Pi/OMP picker is populated with zero latency!
 	const registeredCatalog: RegisteredModel[] = ALL_MODELS.map((m) => ({
 		...m,
@@ -215,27 +276,80 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			buildProviderConfig(models, actualPort),
 		);
 	};
-	registerCatalog(registeredCatalog);
-	// Self-heal: if this session attached to an external daemon that later died,
-	// re-bind on the next lifecycle event so model calls recover without a restart.
 	let ensuringDaemon = false;
 	const ensureDaemon = async (): Promise<void> => {
 		if (ensuringDaemon) return;
 		ensuringDaemon = true;
 		try {
-			if (await isProxyAlive(actualPort)) return;
-			// If actualPort died, check if another daemon is alive on PORT or LEGACY_PORT before binding
+			if (await isProxyAlive(actualPort)) {
+				const v = await getDaemonVersion(actualPort);
+				if (v === null || v === PKG_VERSION) return;
+				logWarn(`proxy on :${actualPort} is stale v${v} (need v${PKG_VERSION}) — replacing`, {
+					remoteVer: v,
+					expected: PKG_VERSION,
+				});
+				const killed = await killPortHolder(actualPort);
+				if (killed) {
+					for (let i = 0; i < 10; i++) {
+						await new Promise<void>((r) => setTimeout(r, 200));
+						if (!(await isProxyAlive(actualPort))) break;
+					}
+				}
+				if (await isProxyAlive(actualPort)) return;
+			}
 			if (await isProxyAlive(PORT)) {
-				actualPort = PORT;
-				registerCatalog(getAliveCatalog());
-				logInfo(`Re-attached to proxy daemon on http://${HOST}:${PORT}`);
-				return;
+				const v = await getDaemonVersion(PORT);
+				if (v !== null && v !== PKG_VERSION) {
+					logWarn(`proxy on :${PORT} is stale v${v} (need v${PKG_VERSION}) — replacing`, {
+						remoteVer: v,
+						expected: PKG_VERSION,
+					});
+					const killed = await killPortHolder(PORT);
+					if (killed) {
+						for (let i = 0; i < 10; i++) {
+							await new Promise<void>((r) => setTimeout(r, 200));
+							if (!(await isProxyAlive(PORT))) break;
+						}
+					}
+					if (await isProxyAlive(PORT)) {
+						actualPort = PORT;
+						registerCatalog(getAliveCatalog());
+						logInfo(`Re-attached to proxy daemon on http://${HOST}:${PORT} (stale kill did not free port)`);
+						return;
+					}
+				} else {
+					actualPort = PORT;
+					registerCatalog(getAliveCatalog());
+					logInfo(`Re-attached to proxy daemon on http://${HOST}:${PORT}`);
+					return;
+				}
 			}
 			if (PORT !== LEGACY_PORT && (await isProxyAlive(LEGACY_PORT))) {
-				actualPort = LEGACY_PORT;
-				registerCatalog(getAliveCatalog());
-				logInfo(`Re-attached to legacy proxy daemon on http://${HOST}:${LEGACY_PORT}`);
-				return;
+				const v = await getDaemonVersion(LEGACY_PORT);
+				if (v !== null && v !== PKG_VERSION) {
+					logWarn(`legacy proxy on :${LEGACY_PORT} is stale v${v} (need v${PKG_VERSION}) — replacing`, {
+						remoteVer: v,
+						expected: PKG_VERSION,
+					});
+					const killed = await killPortHolder(LEGACY_PORT);
+					if (killed) {
+						for (let i = 0; i < 10; i++) {
+							await new Promise<void>((r) => setTimeout(r, 200));
+							if (!(await isProxyAlive(LEGACY_PORT))) break;
+						}
+					}
+					if (await isProxyAlive(LEGACY_PORT)) {
+						actualPort = LEGACY_PORT;
+						registerCatalog(getAliveCatalog());
+						logInfo(`Re-attached to legacy proxy daemon on http://${HOST}:${LEGACY_PORT} (stale kill did not free port)`);
+						return;
+					}
+				} else {
+					actualPort = LEGACY_PORT;
+					registerCatalog(getAliveCatalog());
+					logInfo(`Re-attached to legacy proxy daemon on http://${HOST}:${LEGACY_PORT}`);
+					return;
+				}
 			}
 			const r = await startProxy();
 			if (r.server) server = r.server;
@@ -310,7 +424,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 						? `Relay pool ready: ${freshRelayState.relays.length} relay(s). Run /freeflow for pool management.`
 						: "Relay pool empty — direct mode. Run /freeflow deploy to add your own egress.";
 				ctx.ui?.notify?.(
-					`freeflow ready: 25 free models via local proxy 127.0.0.1:28180. ${hint}`,
+					`freeflow ready: 28 free models via local proxy 127.0.0.1:28180. ${hint}`,
 					"info",
 				);
 			}

package/src/models.ts

@@ -1,9 +1,9 @@
 /**
  * Static model definitions and upstream routing catalogs for pi-freeflow
  *
- * Defines the 25 verified free models:
- * - 7 OpenCode Zen models (1 Responses API + 6 Chat Completions)
- * - 18 KiloCode Keyless Gateway models (17 OpenRouter format + 1 Standard format)
+ * Defines the 28 verified free models:
+ * - 8 OpenCode Zen models (1 Responses API + 7 Chat Completions)
+ * - 20 KiloCode Keyless Gateway models (19 OpenRouter format + 1 Standard format)
  */
 
 import type { ModelDef, ThinkingLevelMap, Upstream } from "./types.ts";
@@ -126,6 +126,22 @@ export const OPENCODE_MODELS: ModelDef[] = [
 			xhigh: "xhigh",
 			max: null,},
 	},
+	{
+		id: "ling-3.0-flash-fin-free",
+		name: "Ling 3.0 Flash Fin (256K)",
+		reasoning: true,
+		contextWindow: 262_144,
+		maxTokens: 131_072,
+		input: ["text"],
+		thinkingLevelMap: {
+			off: null,
+			minimal: "minimal",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "xhigh",
+			max: null,},
+	},
 ];
 
 /**
@@ -328,6 +344,26 @@ export const KILO_MODELS: ModelDef[] = [
 	thinkingFormat: "openrouter",
 	thinkingLevelMap: KILO_REASONING_MAP,
 },
+{
+	id: "thinkingmachines/inkling:free",
+	name: "Inkling (1M)",
+	reasoning: true,
+	contextWindow: 1_048_576,
+	maxTokens: 262_144,
+	input: ["text", "image"],
+	thinkingFormat: "openrouter",
+	thinkingLevelMap: KILO_REASONING_MAP,
+},
+{
+	id: "thinkingmachines/inkling-small:free",
+	name: "Inkling Small (1M)",
+	reasoning: true,
+	contextWindow: 1_048_576,
+	maxTokens: 262_144,
+	input: ["text", "image"],
+	thinkingFormat: "openrouter",
+	thinkingLevelMap: KILO_REASONING_MAP,
+},
 ];
 
 /**
@@ -352,6 +388,8 @@ export const MODEL_ALIASES: Record<string, string> = {
 	"minimax-m2.7": "minimax/minimax-m2.7:free",
 	"minimax-m3": "minimax/minimax-m3:free",
 	"ling-3.0-flash-fin": "inclusionai/ling-3.0-flash-fin:free",
+	"inkling": "thinkingmachines/inkling:free",
+	"inkling-small": "thinkingmachines/inkling-small:free",
 	// provider-prefixed short aliases (slash-normalized)
 	"hy3:free": "tencent/hy3:free",
 	"laguna-s-2.1:free": "poolside/laguna-s-2.1:free",
@@ -379,7 +417,7 @@ export const KILO_MODEL_IDS = new Set<string>([
 ]);
 
 /**
- * Combined list of all 25 static free models (canonical)
+ * Combined list of all 28 static free models (canonical)
  */
 export const ALL_MODELS: ModelDef[] = [...OPENCODE_MODELS, ...KILO_MODELS];
 

package/src/proxy.ts

@@ -6,6 +6,7 @@
  */
 
 import { randomUUID } from "node:crypto";
+import { execSync } from "node:child_process";
 import * as http from "node:http";
 import * as https from "node:https";
 import { handleHealthRequest } from "./health.ts";
@@ -85,13 +86,12 @@ export function sanitizeHeaders(
 	incoming: http.IncomingHttpHeaders,
 	targetHost: string,
 ): Record<string, string> {
-	// Positive allowlist: only headers the proxy is meant to relay. Everything
-	// else (host, cookie, x-forwarded-*, client x-relay-*) is dropped so a
-	// browser/extension cannot smuggle headers into the upstream request.
+	// authorization is deliberately NOT forwarded: the host provider registers
+	// with a dummy key (placeholder), and zen free models are keyless — sending
+	// that fake key upstream gets 401 Invalid API key. Kilo injects its own key.
 	const allowed: Record<string, true> = {
 		"content-type": true,
 		accept: true,
-		authorization: true,
 		"x-request-id": true,
 	};
 	const sanitized: Record<string, string> = {};
@@ -113,6 +113,7 @@ export function sanitizeHeaders(
 	return sanitized;
 }
 export async function isProxyAlive(port: number): Promise<boolean> {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) return false;
 	try {
 		const res = await fetch(`http://${HOST}:${port}/v1/models`, {
 			signal: AbortSignal.timeout(500),
@@ -124,6 +125,62 @@ export async function isProxyAlive(port: number): Promise<boolean> {
 	}
 }
 
+export async function getDaemonVersion(port: number): Promise<string | null> {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+	try {
+		const res = await fetch(`http://${HOST}:${port}/_health`, {
+			signal: AbortSignal.timeout(800),
+		});
+		if (!res.ok) return null;
+		const data: unknown = await res.json();
+		if (data && typeof data === "object" && "version" in data) {
+			const v = data.version;
+			if (typeof v === "string" && v) return v;
+		}
+		// Alive but no version field = pre-1.8.0 daemon (never embedded it) — stale.
+		return "";
+	} catch {
+		return null;
+	}
+}
+
+export async function killPortHolder(port: number): Promise<boolean> {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) return false;
+	try {
+		if (process.platform === "win32") {
+			try {
+				const out = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8", timeout: 3000 }) as string;
+				for (const line of out.split("\n")) {
+					if (!line.includes("LISTENING")) continue;
+					if (!line.includes(`:${port}`)) continue;
+					const parts = line.trim().split(/\s+/);
+					const pid = parts[parts.length - 1];
+					if (!pid || !/^\d+$/.test(pid)) continue;
+					// Windows netstat report: 127.0.0.1:38180 ... LISTENING/PID
+					if (Number(pid) === process.pid) continue; // never self-kill
+					execSync(`taskkill /F /PID ${pid}`, { timeout: 3000, stdio: "ignore" });
+					return true;
+				}
+			} catch {}
+			return false;
+		}
+		try {
+			const out = execSync(`lsof -ti tcp:${port} 2>/dev/null || fuser -n tcp ${port} 2>/dev/null`, {
+				encoding: "utf8",
+				timeout: 3000,
+			}) as string;
+			const pid = out.trim().split(/\s+/)[0];
+			if (!pid || !/^\d+$/.test(pid)) return false;
+			execSync(`kill -9 ${pid}`, { timeout: 3000, stdio: "ignore" });
+			return true;
+		} catch {
+			return false;
+		}
+	} catch {
+		return false;
+	}
+}
+
 /**
  * Tagged abort reason for the proxy-internal header-wait timeout.
  * relayFetch rethrows AbortErrors untouched, and stream-pipe recognizes
@@ -180,7 +237,7 @@ export function startProxy(
 			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"))) {
+		if (req.method === "GET" && reqPathname !== null && (reqPathname === "/_health" || reqPathname === "/health")) {
 			const addr = server.address();
 			const realPort = addr && typeof addr === "object" ? (addr as { port: number }).port : basePort;
 			if (handleHealthRequest(req, res, realPort)) return;