@haoyiyin/9router 0.1.4 → 0.1.6

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 from the router, so their reasoning is decided by `comboReasoning` in `~/.pi/agent/haoyiyin/9router.json`. It defaults to **on** (assumes combo routes hit thinking-capable upstreams) with the standard `off..high` range. Opt out per machine with:
+
+```json
+{
+  "comboReasoning": false
+}
+```
+
+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.4",
+  "version": "0.1.6",
   "type": "module",
   "main": "src/index.ts",
   "description": "Pi extension — 9Router provider (OpenCode Free oc/-free models + router models) + fetch/search/transcribe tools",

package/src/config.ts

@@ -7,6 +7,14 @@ export const DEFAULT_BASE = "";
 export interface RouterConfig {
   baseUrl: string;
   apiKey: string;
+  /**
+   * Force reasoning:true onto combo models (`owned_by === "combo"`).
+   * Combo models carry no capabilities from the router, so this switch decides
+   * their reasoning status. Defaults to `true` (combo routes are assumed to hit
+   * thinking-capable upstreams); set `false` to opt out, 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 +25,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 +33,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 +50,7 @@ export function loadConfig(): RouterConfig {
 
   const apiKey = fileKey ?? process.env.ROUTER_API_KEY ?? "";
 
-  return { baseUrl, apiKey };
+  return { baseUrl, apiKey, comboReasoning: comboReasoning ?? true };
 }
 
 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/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,65 @@ 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 expose off..max, 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" };
+	}
+	// openai-style: reasoning_effort takes the level name directly. Unlock
+	// xhigh/max, and hide off when thinking cannot be disabled.
+	return {
+		...(cap.thinkingCanDisable === false ? { off: null } : {}),
+		xhigh: "xhigh",
+		max: "max",
+	};
+}
+
+/**
+ * Combo models (`owned_by === "combo"`) carry no capabilities from the router, so
+ * their reasoning is decided by `comboReasoning` in 9router.json: default `true`
+ * (off..high range), `false` disables, 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 /
@@ -118,15 +173,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 }
+					: {}),
+			},
 		});
 	}