pi-zro-provider 1.3.23 → 1.3.25

package/AGENTS.md

@@ -19,6 +19,7 @@ When a model needs overrides, new properties, or corrections, edit the appropria
 | `patch.json` | Per-model overrides keyed by model ID. Add reasoning flags, compat settings, pricing corrections, thinking level maps, etc. Applied on top of `models.json` at runtime and for README generation. |
 | `custom-models.json` | Models that don't exist in the provider API (hidden models, router endpoints, cross-provider aliases). Merged after patch. Format: array of full model objects (same schema as `models.json` entries). |
 | `index.ts` | Provider extension code: model sync, streaming wrapper, footer-status wiring. |
+| `sync-policy.ts` | Quiet startup sync policy (TTL, key fingerprint, cross-process lock). Provider-agnostic and shared verbatim across pi-*-provider repos — keep it free of provider specifics. |
 | `status.ts` | Footer-status presentation: config schema, USD/token formatters, progressive-disclosure tiers, width-aware widget. Pure module — no pi imports; exercised by `tests/status.smoke.ts`. |
 | `scripts/update-models.js` | The sync script itself (edit only if changing how models are fetched/transformed). |
 

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.3.25
+
+- Quiet startup sync: background `/api/cli/models` revalidation runs only with an API key, only when the disk cache is older than 1 hour (`PI_PROVIDER_SYNC_TTL_MS`, `0` = always), missing, or fetched with a different key (including a new `zro login`), and only in one pi process at a time (lock file next to the cache). Failed refreshes back off for 5 minutes; sessions that skip adopt a cache refreshed by another process.
+- Never store the API key: key changes are detected via a salted sha256 fingerprint in `cache/zro-models.sync.json`. The cache file format is unchanged.
+- Footer account prefetch at session start: skipped without a UI (`pi -p`, child agents) or with `account: "off"`, and shared across pi processes through `cache/zro-account.json` (60 s window, same lock/fingerprint rules). Post-run and model-switch balance polling also skip without a UI; `/zro-status refresh` still fetches.
+- Write the model cache atomically and swallow API key resolution failures in `session_start`.
+- Add vitest coverage for the sync policy and the session_start integration.
+
 ## 1.3.23
 
 - Validate provider registration and session lifecycle against Pi 1.0.0; update the pinned development SDK.

package/README.md

@@ -19,6 +19,7 @@ _GLM-5.2, Kimi K3, and DeepSeek V4 / V4.1 Flash — run through the Zro inferenc
 - **Native reasoning effort** — every model ships an endpoint-verified `piLevel` → level-id map (`glm-5.2`, `glm-5.3-flash`, `deepseek-v4-flash-0731`: full `off`–`max` ladder; `deepseek-v4.1-flash`: `low`/`high`/`max` — catalog has no `none`, and `xhigh`/`max` both send `max`; `kimi-k3`: `low`/`high`/`max` — the proxy rejects `medium` there), so `/thinking low` etc. maps exactly to what the Zro proxy accepts. Quirks: `glm-5.3-flash` silently disables thinking at `low`, so `minimal`/`low` map to `minimal`; `glm-5.3` mirrors flash's full ladder — Z.ai officially removed `none` for the 5.3 family, but the proxy accepts it and streams cleanly (occasionally a short chain-of-thought preamble surfaces in `content` before the answer), and `xhigh`/`max` both send `max`
 - **OpenAI-compatible API** at `https://zro.moonmath.ai/v1`
 - **Official catalog sync** from Zro's `/api/cli/models` endpoint — same one `zro models` uses
+- **Quiet live model sync** — the catalog refreshes in the background, at most hourly and by one pi process at a time ([details](#model-sync))
 - **Zro login reuse** — if you've run `zro login`, the extension picks up `~/.config/zro/credentials.json` automatically (no duplicated keys)
 - **Footer status widget** — session spend/requests and account plan / available spend / usage packs / 30-day activity at a glance
 
@@ -118,7 +119,10 @@ A Neuralwatt-style status line sits below the editor. It appears after the
 session's first Zro turn completes (never before — no half-empty line on
 fresh sessions or other providers), refreshes its balance when the agent run
 fully settles, and makes no status-related API calls in sessions that never
-use Zro:
+use Zro. The account prefetch at session start runs only in interactive
+sessions (not `pi -p` or child agents) and is shared across pi processes: one
+fetches `/api/cli/status` and writes `~/.pi/agent/cache/zro-account.json`, and
+sessions starting within the next 60 seconds render from that file instead:
 
 ```
 ⚡ $0.42 · 7 req                   Pro ◆ $12.34 avail · $2.50 pack · 1.2k req/30d
@@ -191,6 +195,7 @@ Get your API key from [zro.moonmath.ai](https://zro.moonmath.ai).
 | `ZRO_API_KEY` | No | Your Zro API key (env var fallback) |
 | `ZRO_ENDPOINT_ROOT` | No | Override the endpoint root (default `https://zro.moonmath.ai`) |
 | `ZRO_AUTH_URL` | No | Override the authentication/API host (used by `zro login`; the extension resolves catalog/status from it too) |
+| `PI_PROVIDER_SYNC_TTL_MS` | No | Model sync freshness window in ms (default `3600000`; `0` = revalidate every session start) |
 
 ## Configuration
 
@@ -226,6 +231,24 @@ currently empty.
 corrections. It is currently empty because every live field comes from Zro's
 canonical model catalog.
 
+## Model sync
+
+Startup never waits on the network. pi starts with the cached catalog (`~/.pi/agent/cache/zro-models.json`,
+falling back to the bundled `models.json`) and revalidates against `/api/cli/models` in the background — only when:
+
+- a Zro API key is configured (auth.json, `ZRO_API_KEY`, or a `zro login`; no key, no request),
+- the cache is older than 1 hour, missing, or was fetched with a different API key (so a new `zro login`
+  refreshes it right away), and
+- no other pi process is already refreshing it (a `zro-models.lock` file next to the cache).
+
+So `/new`, `/reload`, `pi -p` and fan-out child agents share one cache instead of each calling the API; a
+session that skips the fetch still picks up a cache another process refreshed. A failed refresh is retried after
+5 minutes at the earliest. `PI_PROVIDER_SYNC_TTL_MS` changes the window (`0` revalidates on every session start).
+Only a hash fingerprint of the key is stored (`zro-models.sync.json`), never the key itself.
+
+The footer's startup account prefetch follows the same rules with its own 60-second window
+(`zro-account.json`, see [Footer Status](#footer-status)); balance polls after each agent run are unchanged.
+
 ## Updating Models
 
 Run the update script to fetch the latest models from the Zro catalog:

package/index.ts

@@ -13,6 +13,10 @@
  * Model resolution strategy: Stale-While-Revalidate
  *   1. Serve stale immediately: disk cache → embedded models.json (zero-latency)
  *   2. Revalidate in background: live API /api/cli/models → merge with embedded → cache → hot-swap
+ *      Quiet startup sync (sync-policy.ts): only with an API key, only when the
+ *      disk cache is older than the TTL (1h, PI_PROVIDER_SYNC_TTL_MS) or the key
+ *      changed (incl. a new `zro login`), and only one pi process at a time
+ *      (lock file next to the cache).
  *   3. patch.json + custom-models.json applied on top of whichever source won
  *
  * Merge order: [live|cache|embedded] → apply patch.json → merge custom-models.json
@@ -39,7 +43,10 @@
  *   session's first Zro turn completes, so fresh sessions and other
  *   providers' sessions see no half-empty line. Account status is prefetched
  *   on session start or model select when a Zro model is active, so the
- *   first turn ends with data already cached. It is polled again on pi's
+ *   first turn ends with data already cached. That startup prefetch runs
+ *   only in interactive sessions (ctx.hasUI) with a key and account != off,
+ *   and is shared across pi processes: one process fetches (lock next to
+ *   cache/zro-account.json), the others reuse that file for 60s. It is polled again on pi's
  *   agent_settled event (fires only once no automatic retry, compaction, or
  *   queued continuation can follow) — and nowhere else, so sessions without
  *   Zro turns make zero status-related API calls. Between polls the balance
@@ -124,6 +131,7 @@ import {
 import fs from "fs";
 import { homedir } from "os";
 import path from "path";
+import { acquireModelSync, cacheChangedSinceLoad, keyFingerprint, markCacheLoaded, syncMetaPath, writeFileAtomic } from "./sync-policy";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -339,7 +347,8 @@ function loadCachedModels(): JsonModel[] | null {
 function cacheModels(models: JsonModel[]): void {
 	try {
 		fs.mkdirSync(CACHE_DIR, { recursive: true });
-		fs.writeFileSync(CACHE_PATH, JSON.stringify(models, null, 2) + "\n");
+		// Atomic (tmp + rename): other pi processes may be reading the cache right now.
+		writeFileAtomic(CACHE_PATH, JSON.stringify(models, null, 2) + "\n");
 	} catch {
 		// Cache write failure is non-fatal
 	}
@@ -405,6 +414,7 @@ function withDeprecated(models: JsonModel[]): JsonModel[] {
 }
 
 function loadStaleModels(embeddedModels: JsonModel[]): JsonModel[] {
+	markCacheLoaded(CACHE_PATH); // stat before read: lets session_start spot newer caches
 	const cached = loadCachedModels();
 	if (!cached || cached.length === 0) return embeddedModels;
 
@@ -418,13 +428,28 @@ function loadStaleModels(embeddedModels: JsonModel[]): JsonModel[] {
 	return cached;
 }
 
-async function revalidateModels(apiKey: string | undefined, embeddedModels: JsonModel[], signal?: AbortSignal): Promise<JsonModel[] | null> {
-	if (!apiKey) return null;
-	const liveModels = await fetchLiveModels(apiKey, signal);
-	if (!liveModels || liveModels.length === 0) return null;
-	const merged = mergeWithEmbedded(liveModels, embeddedModels);
-	cacheModels(merged);
-	return merged;
+/**
+ * Background revalidation, gated by the quiet startup sync policy
+ * (sync-policy.ts): no key → no fetch; fresh cache (TTL) → no fetch; another
+ * process already fetching → no fetch. When skipped, a cache that another
+ * process refreshed since we loaded it is adopted from disk instead.
+ * `apiKey` is the key actually in use (auth.json → ZRO_API_KEY → zro CLI
+ * credentials), so a new `zro login` changes its fingerprint and forces a
+ * refresh. `force` bypasses the TTL; it is still single-flight.
+ */
+async function revalidateModels(apiKey: string | undefined, embeddedModels: JsonModel[], signal?: AbortSignal, force = false): Promise<JsonModel[] | null> {
+	const lease = acquireModelSync({ cachePath: CACHE_PATH, apiKey, force });
+	if (!lease) return cacheChangedSinceLoad(CACHE_PATH) ? loadStaleModels(embeddedModels) : null;
+	let merged: JsonModel[] | null = null;
+	try {
+		const liveModels = apiKey ? await fetchLiveModels(apiKey, signal) : null;
+		if (!liveModels || liveModels.length === 0) return null;
+		merged = mergeWithEmbedded(liveModels, embeddedModels);
+		cacheModels(merged);
+		return merged;
+	} finally {
+		lease.release(merged ? "fetched" : signal?.aborted ? "aborted" : "failed");
+	}
 }
 
 // ─── API Key Resolution (via ModelRegistry) ────────────────────────────────────
@@ -698,19 +723,7 @@ function refreshAccountStatus(apiKey: string | undefined, signal: AbortSignal |
 		try {
 			const data = await fetchJsonGet(STATUS_URL, apiKey, signal);
 			if (data === null) return;
-			const billing = data?.billing;
-			if (billing && typeof billing === "object") {
-				if (typeof billing.totalRemaining === "number") account.availableUsd = billing.totalRemaining;
-				if (typeof billing.usagePacks?.remaining === "number") account.usagePackUsd = billing.usagePacks.remaining;
-				const planName = billing.plan?.name;
-				if (typeof planName === "string" && planName.trim()) account.planName = planName.trim();
-			}
-			const activity = data?.activity30d;
-			if (activity && typeof activity === "object") {
-				if (typeof activity.requests === "number") account.activity30dRequests = activity.requests;
-				if (typeof activity.totalTokens === "number") account.activity30dTokens = activity.totalTokens;
-			}
-			if (typeof data?.key?.alias === "string" && data.key.alias.trim()) account.keyAlias = data.key.alias.trim();
+			Object.assign(account, parseAccountSnapshot(data));
 			metaFetched = true;
 		} finally {
 			statusInFlight = null;
@@ -719,6 +732,103 @@ function refreshAccountStatus(apiKey: string | undefined, signal: AbortSignal |
 	return statusInFlight;
 }
 
+/** The account fields /api/cli/status reports; only fields present in the response are set. */
+type AccountSnapshot = Partial<Omit<AccountState, "rate">>;
+
+function parseAccountSnapshot(data: any): AccountSnapshot {
+	const snapshot: AccountSnapshot = {};
+	const billing = data?.billing;
+	if (billing && typeof billing === "object") {
+		if (typeof billing.totalRemaining === "number") snapshot.availableUsd = billing.totalRemaining;
+		if (typeof billing.usagePacks?.remaining === "number") snapshot.usagePackUsd = billing.usagePacks.remaining;
+		const planName = billing.plan?.name;
+		if (typeof planName === "string" && planName.trim()) snapshot.planName = planName.trim();
+	}
+	const activity = data?.activity30d;
+	if (activity && typeof activity === "object") {
+		if (typeof activity.requests === "number") snapshot.activity30dRequests = activity.requests;
+		if (typeof activity.totalTokens === "number") snapshot.activity30dTokens = activity.totalTokens;
+	}
+	if (typeof data?.key?.alias === "string" && data.key.alias.trim()) snapshot.keyAlias = data.key.alias.trim();
+	return snapshot;
+}
+
+// ─── Startup Account Prefetch (shared across pi processes) ────────────────────
+// /new, /reload and every other pi process start would each hit
+// /api/cli/status. The startup prefetch instead reuses the quiet-sync lease
+// with its own cache file: one process fetches and writes the parsed snapshot
+// to cache/zro-account.json; others render from that file while it is younger
+// than ACCOUNT_SYNC_TTL_MS. 60s keeps the balance current (spend moves it, and
+// the agent_settled poll reconciles after each run anyway) while collapsing
+// bursts of session starts into one request. A snapshot is only adopted when
+// it was fetched with the same key, and never when older than
+// ACCOUNT_ADOPT_MAX_AGE_MS (e.g. while another process holds the lock) — the
+// first turn's retry fetches instead.
+const ACCOUNT_CACHE_PATH = path.join(CACHE_DIR, `${PROVIDER_ID}-account.json`);
+const ACCOUNT_SYNC_TTL_MS = 60_000;
+const ACCOUNT_ADOPT_MAX_AGE_MS = 10 * 60_000;
+
+function adoptAccountCache(apiKey: string): void {
+	try {
+		const meta = JSON.parse(fs.readFileSync(syncMetaPath(ACCOUNT_CACHE_PATH), "utf8"));
+		if (meta?.keyFingerprint !== keyFingerprint(apiKey)) return;
+		if (Date.now() - fs.statSync(ACCOUNT_CACHE_PATH).mtimeMs > ACCOUNT_ADOPT_MAX_AGE_MS) return;
+		const snapshot = JSON.parse(fs.readFileSync(ACCOUNT_CACHE_PATH, "utf8"));
+		if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) return;
+		Object.assign(account, parseCachedSnapshot(snapshot));
+		if (accountHasData(account)) metaFetched = true;
+	} catch {
+		// Missing/corrupt cache: the first turn's retry fetches instead.
+	}
+}
+
+/** Re-validate a snapshot read from disk (written by any extension version/process). */
+function parseCachedSnapshot(raw: Record<string, unknown>): AccountSnapshot {
+	const snapshot: AccountSnapshot = {};
+	for (const field of ["availableUsd", "usagePackUsd", "activity30dRequests", "activity30dTokens"] as const) {
+		if (typeof raw[field] === "number" && Number.isFinite(raw[field])) snapshot[field] = raw[field] as number;
+	}
+	for (const field of ["planName", "keyAlias"] as const) {
+		if (typeof raw[field] === "string" && (raw[field] as string).trim()) snapshot[field] = raw[field] as string;
+	}
+	return snapshot;
+}
+
+/** Session-start prefetch: deduped across processes (see above). Never throws. */
+async function prefetchAccountStatus(apiKey: string | undefined, signal: AbortSignal): Promise<void> {
+	if (!apiKey) return;
+	const lease = acquireModelSync({
+		cachePath: ACCOUNT_CACHE_PATH,
+		apiKey,
+		ttlMs: ACCOUNT_SYNC_TTL_MS,
+		isValidCache: (d) => d != null,
+	});
+	if (!lease) {
+		adoptAccountCache(apiKey);
+		return;
+	}
+	let written = false;
+	try {
+		lastStatusFetchAt = Date.now();
+		const data = await fetchJsonGet(STATUS_URL, apiKey, signal);
+		if (data === null || signal.aborted) return;
+		const snapshot = parseAccountSnapshot(data);
+		Object.assign(account, snapshot);
+		metaFetched = true;
+		try {
+			fs.mkdirSync(CACHE_DIR, { recursive: true });
+			writeFileAtomic(ACCOUNT_CACHE_PATH, JSON.stringify(snapshot) + "\n");
+			written = true;
+		} catch {
+			// Non-fatal: other processes fetch for themselves.
+		}
+	} catch {
+		// Never surface prefetch failures.
+	} finally {
+		lease.release(written ? "fetched" : signal.aborted ? "aborted" : "failed");
+	}
+}
+
 // ─── Status Rendering ─────────────────────────────────────────────────────────
 
 const WIDGET_KEY = "zro";
@@ -855,7 +965,7 @@ function commitPending(ctx: ExtensionContext): void {
 	if (pendingSawOutOfCredits) {
 		pendingSawOutOfCredits = false;
 		// Re-fetch now so the balance reflects exhaustion immediately
-		updateStatusAfter(refreshAccountStatus(cachedApiKey, statusAbort?.signal ?? undefined, true), ctx);
+		if (ctx.hasUI) updateStatusAfter(refreshAccountStatus(cachedApiKey, statusAbort?.signal ?? undefined, true), ctx);
 		if (!outOfCreditsNotified && ctx.hasUI) {
 			outOfCreditsNotified = true;
 			ctx.ui.notify("Zro has run out of available spend — top up at zro.moonmath.ai", "error");
@@ -1097,29 +1207,36 @@ export default function (pi: ExtensionAPI) {
 		// over anything that touched provider registration during load.
 		pi.registerProvider(PROVIDER_ID, makeProviderConfig());
 
-		resolveApiKey(ctx.modelRegistry).then(() => {
-			// A session replacement while the key resolved invalidated the
-			// captured ctx (fast-resume, /new, /fork); nothing below may touch it.
-			if (epoch !== statusEpoch) return;
-			// Prefetch account status only when a Zro model is active
-			// (pi-neuralwatt also prefetches so the first turn ends with data, but
-			// gating here avoids API calls in sessions that never use the provider).
-			if (currentProviderId(ctx) === PROVIDER_ID) {
-				updateStatusAfter(refreshAccountStatus(cachedApiKey, statusSignal, true), ctx);
-			}
-			revalidateModels(cachedApiKey, embeddedModels, signal).then((freshBase) => {
+		// Fire-and-forget: never await network here — startup must not block on
+		// the provider API. Nothing is awaited and every rejection is swallowed.
+		void resolveApiKey(ctx.modelRegistry)
+			.then(() => {
+				// A session replacement while the key resolved invalidated the
+				// captured ctx (fast-resume, /new, /fork); nothing below may touch it.
+				if (epoch !== statusEpoch) return null;
+				// Prefetch account status only in interactive sessions (print mode
+				// and child agents render no footer) when a Zro model is active
+				// (pi-neuralwatt also prefetches so the first turn ends with data, but
+				// gating here avoids API calls in sessions that never use the provider).
+				if (ctx.hasUI && statusConfig.account !== "off" && currentProviderId(ctx) === PROVIDER_ID) {
+					updateStatusAfter(prefetchAccountStatus(cachedApiKey, statusSignal), ctx);
+				}
+				return revalidateModels(cachedApiKey, embeddedModels, signal);
+			})
+			.then((freshBase) => {
 				if (freshBase && epoch === statusEpoch && !signal.aborted) {
 					currentModels = buildModels(freshBase, customModels, patches);
 					pi.registerProvider(PROVIDER_ID, makeProviderConfig());
 				}
-			});
-		});
+			})
+			.catch(() => { /* keep serving the stale catalog */ });
 	});
 
 	pi.on("model_select", (event, ctx) => {
 		updateStatus(ctx);
 		const model: any = (event as any).model;
-		if (model?.provider === PROVIDER_ID && cachedApiKey) {
+		// Headless runs (print mode, child agents) render no account status.
+		if (ctx.hasUI && model?.provider === PROVIDER_ID && cachedApiKey) {
 			updateStatusAfter(refreshAccountStatus(cachedApiKey, statusAbort?.signal ?? undefined, false), ctx);
 		}
 	});
@@ -1130,7 +1247,7 @@ export default function (pi: ExtensionAPI) {
 		commitPending(ctx);
 		// If the session_start/model_select status fetch raced or failed, retry
 		// once we have real activity so the very first turn shows the balance.
-		if (sessionStats.requests > 0 && account.availableUsd === null && !metaFetched) {
+		if (ctx.hasUI && sessionStats.requests > 0 && account.availableUsd === null && !metaFetched) {
 			await refreshAccountStatus(cachedApiKey, statusAbort?.signal ?? undefined, false);
 		}
 		updateStatus(ctx);
@@ -1141,7 +1258,7 @@ export default function (pi: ExtensionAPI) {
 	// /api/cli/status is both fresh and not redundant. Gated on session activity
 	// so sessions without Zro turns make zero API calls here.
 	pi.on("agent_settled", async (_event, ctx) => {
-		if (sessionStats.requests > 0 || sessionStats.spend > 0) {
+		if (ctx.hasUI && (sessionStats.requests > 0 || sessionStats.spend > 0)) {
 			await refreshAccountStatus(cachedApiKey, statusAbort?.signal ?? undefined, false);
 			updateStatus(ctx);
 		}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "pi-zro-provider",
-  "version": "1.3.23",
+  "version": "1.3.25",
   "description": "Zro provider extension for pi - GLM-5.2, GLM-5.3 Flash, Kimi K3, DeepSeek V4 Flash & DeepSeek V4.1 Flash through the Zro inference endpoint",
   "type": "module",
   "main": "index.ts",
   "scripts": {
     "clean": "echo 'nothing to clean'",
     "build": "echo 'nothing to build'",
-    "check": "tsc --noEmit && node tests/status.smoke.ts && node scripts/test-pi-compat.mjs",
+    "check": "tsc --noEmit && vitest run && node tests/status.smoke.ts && node scripts/test-pi-compat.mjs",
+    "test": "vitest run",
     "smoke": "node tests/status.smoke.ts",
     "update-models": "node scripts/update-models.js",
     "test:pi": "node scripts/test-pi-compat.mjs"
@@ -33,11 +34,15 @@
       "./index.ts"
     ]
   },
+  "overrides": {
+    "brace-expansion": "5.0.12"
+  },
   "devDependencies": {
-    "@earendil-works/pi-ai": "1.0.0",
-    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@earendil-works/pi-coding-agent": "1.1.0",
     "@types/node": "^24.10.1",
-    "typescript": "6.0.3"
+    "typescript": "6.0.3",
+    "vitest": "4.1.7"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/scripts/test-pi-compat.mjs

@@ -13,7 +13,7 @@ globalThis.fetch = async () => new Response('', { status: 503 });
 let session;
 try {
   const { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, VERSION } = await import('@earendil-works/pi-coding-agent');
-  assert.equal(VERSION, '1.0.0', 'test the actual pinned Pi host, not a stale override');
+  assert.equal(VERSION, '1.1.0', 'test the actual pinned Pi host, not a stale override');
   const manifest = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
   for (const name of ['@earendil-works/pi-ai', '@earendil-works/pi-agent-core', '@earendil-works/pi-coding-agent', '@earendil-works/pi-tui', 'typebox']) {
     assert.equal(manifest.dependencies?.[name], undefined, `${name}: host packages must not be runtime dependencies`);
@@ -58,7 +58,7 @@ try {
       { id: label, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }], usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5, total_cost: 0.001 } },
     ];
     const result = await modelRuntime.streamSimple(model, { messages: [
-      { role: 'system', content: 'Offline Pi 1.0 transcript', timestamp: 0 },
+      { role: 'system', content: 'Offline Pi 1.1.0 transcript', timestamp: 0 },
       { role: 'user', content: label, timestamp: 1 },
     ] }, {
       maxTokens: 32,
@@ -77,13 +77,13 @@ try {
     assert.equal(result.usage.totalTokens, 5);
     assert.equal(requestBody.user, label, 'request-scoped instrumentation must not cross concurrent streams');
     assert.equal(requestBody.max_tokens ?? requestBody.max_completion_tokens, 32);
-    assert.ok(requestBody.messages.some(message => typeof message.content === 'string' && message.content.includes('Offline Pi 1.0 transcript')));
+    assert.ok(requestBody.messages.some(message => typeof message.content === 'string' && message.content.includes('Offline Pi 1.1.0 transcript')));
     assert.deepEqual(hooks.slice(0, 2), ['payload', 'response']);
     assert.equal(hooks.filter(hook => hook === 'stream').length, 2);
   }));
   assert.equal(globalThis.fetch, offlineFetch, 'Zro must never monkey-patch global fetch');
   await session.extensionRunner.emit({ type: 'session_shutdown' });
-  assert.deepEqual(errors, [], 'Pi 1.0 startup and shutdown must be clean');
+  assert.deepEqual(errors, [], 'Pi 1.1.0 startup and shutdown must be clean');
   console.log(`${manifest.name}: Pi ${VERSION} manifest, ${models.length} models, startup/shutdown, concurrent streams and instrumentation OK`);
 } finally {
   session?.dispose();