@haoyiyin/9router 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haoyiyin/9router",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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/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

@@ -69,6 +69,16 @@ export function getReasoning(model: RouterModel, devModel?: ModelsDevModel): boo
 	return /reasoner|thinking|xhigh|high|max|pro|codex|opus|sonnet/i.test(model.id ?? "");
 }
 
+/**
+ * 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();