@haoyiyin/9router 0.1.3 → 0.1.5

package/README.md

@@ -16,6 +16,24 @@ There is no built-in default endpoint. Run `/9router`, enter the 9Router base UR
 
 Environment variables are supported as a fallback: `ROUTER_API_BASE` / `ROUTER_API_KEY` (the config file takes precedence).
 
+## Combo models & thinking
+
+Combo models (`sub` / `free` / `main`, `owned_by: "combo"`) advertise no capabilities, so reasoning is off by default. If every upstream in a combo route supports thinking, opt in via `comboReasoning` in `~/.pi/agent/haoyiyin/9router.json`:
+
+```json
+{
+  "comboReasoning": true
+}
+```
+
+`true` enables the default `off..high` range. To unlock `max`/`xhigh`, pass a custom `thinkingLevelMap` (keys: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`; values: what gets sent to the router, `null` hides the level):
+
+```json
+{
+  "comboReasoning": { "thinkingLevelMap": { "max": "max", "xhigh": "xhigh" } }
+}
+```
+
 ## oc models
 
 Every 30 minutes the extension fetches models from `opencode.ai/zen/v1/models` whose ids end in `-free`, and registers them under the 9router provider as `oc/<id>`. Changes to the upstream list are picked up automatically. Cache file: `~/.cache/pi/zen-oc-models.json`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haoyiyin/9router",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "main": "src/index.ts",
   "description": "Pi extension — 9Router provider (OpenCode Free oc/-free models + router models) + fetch/search/transcribe tools",

package/src/command.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { loadConfig, saveConfig, DEFAULT_BASE } from "./config.ts";
-import { registerProvider } from "./provider.ts";
+import { registerProvider, isStaleCtxError } from "./provider.ts";
 
 // Never contains a real key. If a dialog pre-fills this placeholder as an
 // editable default, an exact match is treated as "keep the current key".
@@ -41,7 +41,9 @@ export function registerCommand(pi: ExtensionAPI): void {
 				await registerProvider(pi);
 			} catch (err) {
 				ctx.ui.notify(
-					`9Router saved, but provider re-registration failed: ${err instanceof Error ? err.message : String(err)}`,
+					isStaleCtxError(err)
+						? "9Router saved. This extension instance was replaced by a session change/reload; the new instance has re-registered the provider."
+						: `9Router saved, but provider re-registration failed: ${err instanceof Error ? err.message : String(err)}`,
 					"warning",
 				);
 			}

package/src/config.ts

@@ -7,6 +7,13 @@ export const DEFAULT_BASE = "";
 export interface RouterConfig {
   baseUrl: string;
   apiKey: string;
+  /**
+   * Opt-in to force reasoning:true onto combo models (`owned_by === "combo"`).
+   * Combo models carry no capabilities from the router, so reasoning is normally
+   * off. Set `true` for the default off..high range, or pass a custom
+   * `thinkingLevelMap` to unlock max/xhigh on the combo routes.
+   */
+  comboReasoning?: boolean | { thinkingLevelMap?: Record<string, string | null> };
 }
 
 export function configPath(): string {
@@ -17,6 +24,7 @@ export function loadConfig(): RouterConfig {
   const path = configPath();
   let fileBase: string | undefined;
   let fileKey: string | undefined;
+  let comboReasoning: RouterConfig["comboReasoning"] | undefined;
 
   if (existsSync(path)) {
     try {
@@ -24,6 +32,12 @@ export function loadConfig(): RouterConfig {
       if (parsed && typeof parsed === "object") {
         if (typeof parsed.baseUrl === "string") fileBase = parsed.baseUrl;
         if (typeof parsed.apiKey === "string") fileKey = parsed.apiKey;
+        if (
+          typeof parsed.comboReasoning === "boolean" ||
+          (parsed.comboReasoning && typeof parsed.comboReasoning === "object")
+        ) {
+          comboReasoning = parsed.comboReasoning;
+        }
       }
     } catch {
       // tolerate malformed config -> fall back to env/defaults
@@ -35,7 +49,7 @@ export function loadConfig(): RouterConfig {
 
   const apiKey = fileKey ?? process.env.ROUTER_API_KEY ?? "";
 
-  return { baseUrl, apiKey };
+  return { baseUrl, apiKey, comboReasoning };
 }
 
 export function saveConfig(cfg: RouterConfig): void {

package/src/data.ts

@@ -44,6 +44,10 @@ export interface RouterModel {
 	capabilities?: {
 		contextWindow?: number;
 		maxOutput?: number;
+		reasoning?: boolean;
+		thinkingFormat?: string;
+		thinkingCanDisable?: boolean;
+		thinkingRange?: unknown;
 		[key: string]: unknown;
 	};
 }

package/src/index.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import registerFetch from "./fetch.ts";
 import registerSearch from "./search.ts";
 import registerTranscribe from "./transcribe.ts";
-import { registerProvider } from "./provider.ts";
+import { registerProvider, isStaleCtxError } from "./provider.ts";
 import { registerCommand } from "./command.ts";
 
 export default async function (pi: ExtensionAPI): Promise<void> {
@@ -15,14 +15,27 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	await registerProvider(pi);
 
 	let refreshing = false;
+	let closed = false;
 	const timer = setInterval(
 		async () => {
 			// ponytail: models refresh by unregister+register; zen cache TTL is
 			// 30m so refetch happens naturally. Overlap guard avoids re-entrancy.
-			if (refreshing) return;
+			if (closed || refreshing) return;
 			refreshing = true;
 			try {
 				await registerProvider(pi);
+			} catch (err) {
+				// The captured `pi` goes stale after session replacement or
+				// extension reload, and pi's assertActive() throw must never
+				// escape this callback — it would crash the whole process as an
+				// uncaughtException. The new session's extension instance
+				// re-registers the provider itself, so stop this timer for good.
+				if (isStaleCtxError(err)) {
+					closed = true;
+					clearInterval(timer);
+				}
+				// Any other error (network hiccup, bad upstream payload) is
+				// swallowed: the next tick retries.
 			} finally {
 				refreshing = false;
 			}
@@ -32,4 +45,8 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	if (typeof (timer as { unref?: () => void }).unref === "function") {
 		(timer as { unref: () => void }).unref();
 	}
+	pi.on("session_shutdown", () => {
+		closed = true;
+		clearInterval(timer);
+	});
 }

package/src/provider.ts

@@ -13,7 +13,7 @@ import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-codin
 import type { ModelsDevModel, RouterModel } from "./data.ts";
 import { fetchModelsDevIndex, lookupInIndex, routerBaseUrl, routerModels } from "./data.ts";
 import { getZenFreeModels } from "./zen.ts";
-import { loadConfig } from "./config.ts";
+import { loadConfig, type RouterConfig } from "./config.ts";
 
 const DEFAULT_CONTEXT_WINDOW = 128_000;
 const DEFAULT_MAX_TOKENS = 16_384;
@@ -65,10 +65,71 @@ export function getMaxTokens(model: RouterModel, devModel?: ModelsDevModel): num
 }
 
 export function getReasoning(model: RouterModel, devModel?: ModelsDevModel): boolean {
+	if (typeof model.capabilities?.reasoning === "boolean") return model.capabilities.reasoning;
 	if (typeof devModel?.reasoning === "boolean") return devModel.reasoning;
 	return /reasoner|thinking|xhigh|high|max|pro|codex|opus|sonnet/i.test(model.id ?? "");
 }
 
+// pi understands these thinkingFormats; the router backend declares openai/deepseek
+// (and occasionally minimax/gemini-level, which pi cannot natively drive). Map the
+// known ones and fall back to openai for anything unknown/minimax/gemini-level.
+const PI_THINKING_FORMAT: Record<string, "openai" | "deepseek"> = {
+	openai: "openai",
+	deepseek: "deepseek",
+};
+
+function getThinkingFormat(model: RouterModel): "openai" | "deepseek" {
+	return PI_THINKING_FORMAT[model.capabilities?.thinkingFormat ?? ""] ?? "openai";
+}
+
+/**
+ * Derive pi's thinkingLevelMap from the router's advertised capabilities.
+ * DeepSeek exposes low/high/max (mirrors pi's own deepseek catalog); openai-style
+ * models keep the default off..high range, only hiding `off` when thinking cannot
+ * be disabled. No map is returned when the backend does not declare reasoning.
+ */
+export function getThinkingLevelMap(
+	model: RouterModel,
+): ProviderModelConfig["thinkingLevelMap"] | undefined {
+	const cap = model.capabilities;
+	if (cap?.reasoning !== true) return undefined;
+	if (cap.thinkingFormat === "deepseek") {
+		return { minimal: null, low: "low", medium: null, high: "high", max: "max" };
+	}
+	if (cap.thinkingCanDisable === false) return { off: null };
+	return undefined;
+}
+
+/**
+ * Combo models (`owned_by === "combo"`) carry no capabilities from the router, so
+ * reasoning is normally off. Operators who guarantee their combo routes only hit
+ * thinking-capable upstreams can opt in via `comboReasoning` in 9router.json:
+ * `true` for the default off..high range, or an object with a custom
+ * `thinkingLevelMap` to unlock max/xhigh.
+ */
+export function resolveComboOptIn(
+	comboReasoning: RouterConfig["comboReasoning"],
+): { reasoning: true; thinkingLevelMap: ProviderModelConfig["thinkingLevelMap"] | undefined } | null {
+	if (!comboReasoning) return null;
+	return {
+		reasoning: true,
+		thinkingLevelMap:
+			comboReasoning === true
+				? undefined
+				: (comboReasoning.thinkingLevelMap as ProviderModelConfig["thinkingLevelMap"]),
+	};
+}
+
+/**
+ * True if `err` is pi's stale-extension-ctx error, thrown when a captured
+ * `pi`/command ctx is used after session replacement (newSession / fork /
+ * switchSession) or extension reload. A stale instance can never recover —
+ * the new session's extension instance re-registers everything itself.
+ */
+export function isStaleCtxError(err: unknown): boolean {
+	return err instanceof Error && /stale after session replacement|ctx is stale/.test(err.message);
+}
+
 export async function registerProvider(pi: ExtensionAPI): Promise<void> {
 	const cfg = loadConfig();
 
@@ -108,15 +169,25 @@ export async function registerProvider(pi: ExtensionAPI): Promise<void> {
 		if (!id || seen.has(id)) continue;
 		seen.add(id);
 		const devModel = lookupInIndex(id, devIndex);
+		const thinkingFormat = getThinkingFormat(model);
+		const comboOptIn = model.owned_by === "combo" ? resolveComboOptIn(cfg.comboReasoning) : null;
 		out.push({
 			id,
 			name: getModelName(model, devModel),
-			reasoning: getReasoning(model, devModel),
+			reasoning: comboOptIn ? comboOptIn.reasoning : getReasoning(model, devModel),
 			input: getInputTypes(model, devModel),
 			cost: ZERO_COST,
 			contextWindow: getContextWindow(model, devModel),
 			maxTokens: getMaxTokens(model, devModel),
-			compat: COMPAT,
+			thinkingLevelMap: comboOptIn ? comboOptIn.thinkingLevelMap : getThinkingLevelMap(model),
+			compat: {
+				...COMPAT,
+				supportsReasoningEffort: true,
+				thinkingFormat,
+				...(thinkingFormat === "deepseek"
+					? { requiresReasoningContentOnAssistantMessages: true }
+					: {}),
+			},
 		});
 	}