@herbertgao/pi-extensions 2026.9.12 → 2026.9.13

package/node_modules/pi-multi-account/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-multi-account",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "description": "Automatic multi-account failover & rotation for Pi Agent across Anthropic (Claude), OpenAI/ChatGPT Codex, Kimi For Coding, Cursor, Qwen/Alibaba, and Ollama. Auto-discovers authenticated accounts, grows the rotation on login, and drops accounts on logout, expiry, or quota/rate-limit errors",
   "type": "module",
   "license": "MIT",
@@ -78,10 +78,12 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.85.1"
+    "@earendil-works/pi-coding-agent": ">=0.85.1 <0.88.0",
+    "@earendil-works/pi-ai": ">=0.85.1 <0.88.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-ai": "0.85.1",
     "@types/node": "^22.20.1",
     "typescript": "^6.0.3"
   },
@@ -92,7 +94,6 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.14.0",
-    "@earendil-works/pi-ai": "^0.85.1",
     "proper-lockfile": "4.1.2"
   },
   "overrides": {

package/node_modules/pi-multi-account/provider-payload-stream.ts

@@ -1,39 +1,47 @@
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-
 type Shape = (payload: any, model: any, options: any) => any;
 type Api = { streamSimple: (model: any, context: any, options: any) => any };
-const requireLocal = createRequire(import.meta.url);
-let registry: { getApiProvider: (api: string) => Api | undefined } | undefined;
+let registry: Promise<typeof import("@earendil-works/pi-ai/compat")> | undefined;
 
-function nativeApi(api: string): Api {
-	if (!registry) {
-		// Pi >= 0.80 moved the API registry to /compat. Resolve lazily so merely
-		// listing OAuth providers does not require loading a transport.
-		for (const entry of ["@earendil-works/pi-ai/compat", "@earendil-works/pi-ai"]) {
-			try {
-				const candidate = requireLocal(fileURLToPath(import.meta.resolve(entry)));
-				if (typeof candidate.getApiProvider === "function") { registry = candidate; break; }
-			} catch { /* Try the older public entry point. */ }
-		}
-	}
-	const provider = registry?.getApiProvider(api);
-	if (!provider) throw new Error(`Pi native API is unavailable: ${api}`);
+async function nativeApi(api: string): Promise<Api> {
+	// A bare import is essential: Pi binds it to the running host's module (including
+	// bundled/virtual hosts). createRequire/import.meta.resolve bypass that binding and
+	// can pair a new transcript with an old, extension-local transport (#65/#66).
+	// Lazy loading preserves account discovery when the optional transport is unavailable.
+	registry ??= import("@earendil-works/pi-ai/compat").catch((error) => {
+		registry = undefined;
+		throw error;
+	});
+	const native = await registry;
+	const provider = native.getApiProvider?.(api as any);
+	if (!provider) throw new Error(`Pi host API is unavailable: ${api}`);
 	return provider;
 }
 
 /** Provider-level shaping applies to every public Pi client, including calls
  * outside the interactive agent's before_provider_request event lifecycle. */
-export function createPayloadStream(shape: Shape, resolveApi = nativeApi) {
-	return (model: any, context: any, options: any = {}) => resolveApi(model.api).streamSimple(model, context, {
-		...options,
-		onPayload: async (payload: any, actualModel: any) => {
-			const replacement = await options.onPayload?.(payload, actualModel);
-			const current = replacement === undefined ? payload : replacement;
-			const shaped = await shape(current, actualModel, options);
-			return shaped === undefined ? current : shaped;
-		},
-	});
+export function createPayloadStream(shape: Shape, resolveApi: (api: string) => Api | Promise<Api> = nativeApi) {
+	return (model: any, context: any, options: any = {}) => {
+		const start = (api: Api) => api.streamSimple(model, context, {
+			...options,
+			onPayload: async (payload: any, actualModel: any) => {
+				const replacement = await options.onPayload?.(payload, actualModel);
+				const current = replacement === undefined ? payload : replacement;
+				const shaped = await shape(current, actualModel, options);
+				return shaped === undefined ? current : shaped;
+			},
+		});
+		const api = resolveApi(model.api);
+		if (!(api instanceof Promise)) return start(api);
+		const stream = api.then(start);
+		// Stream functions must return synchronously. Both consumers await the SAME native
+		// stream; no reserialization, context conversion or second request is introduced.
+		// Observe setup rejection even if a caller discards the returned stream.
+		void stream.catch(() => {});
+		return {
+			async *[Symbol.asyncIterator]() { yield* await stream; },
+			async result() { return (await stream).result(); },
+		};
+	};
 }
 
 export const cursorPayloadStream = createPayloadStream((payload, _model, options) => {

package/node_modules/pi-multi-account/usage.ts

@@ -192,6 +192,11 @@ function headerValue(headers: unknown, name: string): string | undefined {
 	return undefined;
 }
 
+function headerBoolean(headers: unknown, name: string): boolean | undefined {
+	const value = headerValue(headers, name)?.toLowerCase();
+	return value === "true" ? true : value === "false" ? false : undefined;
+}
+
 function headerWindow(headers: unknown, prefix: "primary" | "secondary"): UsageWindow | undefined {
 	const usedPercent = percent(headerValue(headers, `x-codex-${prefix}-used-percent`));
 	const resetAt = epochMs(headerValue(headers, `x-codex-${prefix}-reset-at`));
@@ -222,8 +227,8 @@ export function parseCodexUsageHeaders(
 		primary,
 		secondary,
 		credits: {
-			hasCredits: headerValue(headers, "x-codex-credits-has-credits")?.toLowerCase() === "true",
-			unlimited: headerValue(headers, "x-codex-credits-unlimited")?.toLowerCase() === "true",
+			hasCredits: headerBoolean(headers, "x-codex-credits-has-credits"),
+			unlimited: headerBoolean(headers, "x-codex-credits-unlimited"),
 			balance: headerValue(headers, "x-codex-credits-balance"),
 		},
 	};
@@ -1009,6 +1014,30 @@ export function windowLabel(
 	return `${Math.max(1, Math.round(seconds / 3_600))}h`;
 }
 
+/**
+ * Preserve display identity across partial updates for the same credential only.
+ * Never carry quota windows, credits or serviceability forward under next.fetchedAt:
+ * those fields control routing and an old verdict must not acquire a new lease merely
+ * because response headers refreshed a different field.
+ */
+export function mergeUsageSnapshot(
+	previous: UsageSnapshot | undefined,
+	next: UsageSnapshot,
+): UsageSnapshot {
+	if (
+		!previous ||
+		previous.provider !== next.provider ||
+		!next.credentialHash ||
+		previous.credentialHash !== next.credentialHash
+	)
+		return next;
+	return {
+		...next,
+		account: next.account ?? previous.account,
+		plan: next.plan ?? previous.plan,
+	};
+}
+
 export function formatUsageCompact(snapshot: UsageSnapshot, now = Date.now()): string {
 	const who = shortAccount(snapshot.account);
 	const parts = [

package/node_modules/pi-typesafe/README.md

@@ -138,7 +138,9 @@ const answer = await ask(typesafe, {
 if (!answer.ok) return { skipped: answer.errorCode === "budget" };  // never throws
 ```
 
-Your extension owns its own user consent and budget; `/typesafe enable` applies only to this package's tool. Check `authState()` rather than your own consent flag before you report that judgments are on. Every export — the client, `ask`, batching, the usage ledger, auth state, and the `pi-typesafe/calibrate` and `pi-typesafe/ui` entry points — is in [docs/api.md](docs/api.md).
+Your extension owns its own user consent and budget; `/typesafe enable` applies only to this package's tool. Check `authState()` rather than your own consent flag before you report that judgments are on.
+
+Judgments can also go through OpenRouter: `createTypeSafe({ backend: "openrouter" })` sends them to `openrouter.ai` with the key from `OPENROUTER_API_KEY`. That backend has no login store, so `/typesafe login` does not apply to it. Pass the same `backend` to `authState`, `keySituation`, and `ensureApiKey`, or the status you report describes the TypeSafe key while the requests use another one. The `/typesafe` commands and the `typesafe_evaluate` tool always use the TypeSafe backend. Every export — the client, `ask`, batching, the usage ledger, auth state, and the `pi-typesafe/calibrate` and `pi-typesafe/ui` entry points — is in [docs/api.md](docs/api.md).
 
 ## Development
 

package/node_modules/pi-typesafe/dist/auth.d.ts

@@ -1,3 +1,4 @@
+import type { TypeSafeBackend } from "./backends.js";
 import type { KeySource } from "./credentials.js";
 import { TypeSafeIntegrationError } from "./errors.js";
 import type { IntegrationErrorCode } from "./errors.js";
@@ -14,6 +15,8 @@ export interface AuthFailure {
  * that judgments will happen — an enabled extension with no key used to look identical to a working one.
  */
 export interface AuthState {
+    /** The judgment backend this state describes; each backend has its own key. */
+    readonly backend: TypeSafeBackend;
     /** Same kinds as KeySituation: where the key in effect comes from. */
     readonly kind: "environment" | "stored" | "missing" | "unusable";
     readonly source?: KeySource;
@@ -21,9 +24,12 @@ export interface AuthState {
     readonly path: string;
     /** Why a stored key cannot be used, when that is the case. */
     readonly reason?: string;
-    /** Short human label for the key source: `TYPESAFE_API_KEY`, `/typesafe login`, `no key`, `unusable key`. */
+    /** Short human label for the key source: `TYPESAFE_API_KEY`, `OPENROUTER_API_KEY`, `/typesafe login`, `no key`, `unusable key`. */
     readonly keyName: string;
-    /** True when the key in effect was accepted by api.typesafe.ai (login verifies it; a successful request proves it). */
+    /**
+     * True when the key in effect was accepted by the backend (login verifies a TypeSafe key; a successful request proves
+     * any key). The record is shared across backends: switching backends keeps the last outcome until the next request.
+     */
     readonly verified: boolean;
     readonly verifiedAt?: string;
     /** The last failure, cleared by the next successful request. */
@@ -33,9 +39,10 @@ export interface AuthState {
 }
 /** The auth-state file: one small, owner-only record that outlives the process that wrote it. */
 export declare function authStatePath(): string;
-/** What the key situation, the last outcome, and the clock add up to. Never throws. */
+/** What the key situation, the last outcome, and the clock add up to for one backend. Never throws. */
 export declare function authState(options?: {
     path?: string;
+    backend?: TypeSafeBackend;
 }): AuthState;
 /** Record that the key was accepted: login verification, or any successful request. Clears the last failure. */
 export declare function recordAuthVerified(at?: Date): void;

package/node_modules/pi-typesafe/dist/auth.js

@@ -1,5 +1,6 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { DEFAULT_BACKEND, TYPESAFE_KEY_ENV, backendConfig, usesTypesafeKey } from "./backends.js";
 import { credentialsPath, keySituation, keySourceLabel, piTypesafeDir } from "./credentials.js";
 import { TypeSafeIntegrationError } from "./errors.js";
 const AUTH_VERSION = 1;
@@ -49,15 +50,17 @@ function writeState(path, state) {
         catch { /* best-effort cleanup only */ }
     }
 }
-/** What the key situation, the last outcome, and the clock add up to. Never throws. */
+/** What the key situation, the last outcome, and the clock add up to for one backend. Never throws. */
 export function authState(options = {}) {
     const path = options.path ?? authStatePath();
-    const situation = keySituation();
+    const backend = options.backend ?? DEFAULT_BACKEND;
+    const situation = keySituation(backend);
     const stored = readState(path);
     const source = situation.kind === "environment" ? "environment" : situation.kind === "stored" ? "stored" : undefined;
     const rejected = stored.lastFailure?.code === "http" && stored.lastFailure.status !== undefined && REJECTED_STATUSES.has(stored.lastFailure.status);
     const usable = source !== undefined && !rejected;
     return {
+        backend,
         kind: situation.kind,
         ...(source === undefined ? {} : { source }),
         path: situation.kind === "unusable" ? situation.path : credentialsPath(),
@@ -96,19 +99,22 @@ export function clearAuthState() {
  * state instead of reporting "enabled".
  */
 export function describeAuth(state = authState()) {
+    const config = backendConfig(state.backend ?? DEFAULT_BACKEND);
+    const label = `${config.label} key`;
     const since = state.lastFailure ? ` Last failure: ${state.lastFailure.message}${state.lastFailure.at ? ` (${state.lastFailure.at})` : ""}` : "";
     if (state.kind === "missing") {
-        return { level: "error", text: `TypeSafe key: missing — every Jev judgment is skipped until a key is configured (/typesafe login or TYPESAFE_API_KEY).${since}` };
+        const how = usesTypesafeKey(config) ? `a key is configured (/typesafe login or ${TYPESAFE_KEY_ENV})` : `${config.keyEnv} is set in the environment`;
+        return { level: "error", text: `${label}: missing — every Jev judgment is skipped until ${how}.${since}` };
     }
     if (state.kind === "unusable") {
-        return { level: "error", text: `TypeSafe key: unusable (${state.reason ?? "unknown reason"}) — judgments are skipped until the key is fixed.${since}` };
+        return { level: "error", text: `${label}: unusable (${state.reason ?? "unknown reason"}) — judgments are skipped until the key is fixed.${since}` };
     }
     const rejected = state.lastFailure?.code === "http" && state.lastFailure.status !== undefined && REJECTED_STATUSES.has(state.lastFailure.status);
     if (rejected) {
-        return { level: "error", text: `TypeSafe key: ${state.keyName} was rejected.${since}` };
+        return { level: "error", text: `${label}: ${state.keyName} was rejected.${since}` };
     }
     if (!state.verified) {
-        return { level: "warning", text: `TypeSafe key: ${state.keyName} (not verified yet — the first request proves it).${since}` };
+        return { level: "warning", text: `${label}: ${state.keyName} (not verified yet — the first request proves it).${since}` };
     }
-    return { level: "ok", text: `TypeSafe key: ${state.keyName} (verified${state.verifiedAt ? ` ${state.verifiedAt}` : ""}).${since}` };
+    return { level: "ok", text: `${label}: ${state.keyName} (verified${state.verifiedAt ? ` ${state.verifiedAt}` : ""}).${since}` };
 }

package/node_modules/pi-typesafe/dist/backends.d.ts

@@ -0,0 +1,31 @@
+export type TypeSafeBackend = "typesafe" | "openrouter";
+export interface BackendConfig {
+    /** Human name for status lines: "TypeSafe", "OpenRouter". */
+    label: string;
+    host: string;
+    /** The environment variable that carries this backend's key. Absent means the TypeSafe key resolution applies. */
+    keyEnv?: string;
+    /** Request path, when the backend does not serve the SDK's own `/v1/systemone`. */
+    path?: string;
+    /** Request path for the model list, when the backend does not serve the SDK's own `/v1/models`. */
+    modelsPath?: string;
+    /** Field the model list arrives in, when the backend does not use the SDK's own `models`. */
+    modelsField?: string;
+    /** Entry field carrying the id callers pass as `model:`, when the SDK's own `name` is only a label. */
+    modelsIdField?: string;
+    /** Whether the model list checks the key. A public list accepts any key, so it proves nothing. Absent means it does. */
+    modelsVerifyKey?: boolean;
+}
+/** The backend every key and auth function assumes when none is named. */
+export declare const DEFAULT_BACKEND: TypeSafeBackend;
+/** The environment variable and login store that the default backend reads. */
+export declare const TYPESAFE_KEY_ENV = "TYPESAFE_API_KEY";
+/** Registry of known judgment backends. Extendable by callers. */
+export declare const DECISIONS_BACKENDS: Record<TypeSafeBackend, BackendConfig>;
+/** The registry entry for a backend name; a `configuration` error for a name the registry does not know. */
+export declare function backendConfig(name: TypeSafeBackend): BackendConfig;
+/**
+ * Whether a backend's key comes from the TypeSafe resolution (`TYPESAFE_API_KEY`, then the login store) or only from
+ * its own environment variable. Only the TypeSafe backend has a login store; every other backend is environment-only.
+ */
+export declare function usesTypesafeKey(backend: BackendConfig): boolean;

package/node_modules/pi-typesafe/dist/backends.js

@@ -0,0 +1,33 @@
+import { TypeSafeIntegrationError } from "./errors.js";
+/** The backend every key and auth function assumes when none is named. */
+export const DEFAULT_BACKEND = "typesafe";
+/** The environment variable and login store that the default backend reads. */
+export const TYPESAFE_KEY_ENV = "TYPESAFE_API_KEY";
+/** Registry of known judgment backends. Extendable by callers. */
+export const DECISIONS_BACKENDS = {
+    typesafe: { label: "TypeSafe", host: "https://api.typesafe.ai", keyEnv: TYPESAFE_KEY_ENV },
+    openrouter: {
+        label: "OpenRouter",
+        host: "https://openrouter.ai",
+        keyEnv: "OPENROUTER_API_KEY",
+        path: "/api/alpha/decisions",
+        modelsPath: "/api/v1/models",
+        modelsField: "data",
+        modelsIdField: "id",
+        modelsVerifyKey: false,
+    },
+};
+/** The registry entry for a backend name; a `configuration` error for a name the registry does not know. */
+export function backendConfig(name) {
+    const backend = DECISIONS_BACKENDS[name];
+    if (!backend)
+        throw new TypeSafeIntegrationError("configuration", `Unknown judgment backend "${name}". Valid backends: ${Object.keys(DECISIONS_BACKENDS).join(", ")}.`);
+    return backend;
+}
+/**
+ * Whether a backend's key comes from the TypeSafe resolution (`TYPESAFE_API_KEY`, then the login store) or only from
+ * its own environment variable. Only the TypeSafe backend has a login store; every other backend is environment-only.
+ */
+export function usesTypesafeKey(backend) {
+    return (backend.keyEnv ?? TYPESAFE_KEY_ENV) === TYPESAFE_KEY_ENV;
+}

package/node_modules/pi-typesafe/dist/client.d.ts

@@ -1,15 +1,9 @@
 import type { Fetch, Questions, SystemOneRequest, SystemOneResult } from "@typesafe-ai/sdk";
+import type { TypeSafeBackend } from "./backends.js";
 import type { BatchEvaluation, BatchOptions } from "./batch.js";
 import type { BlockedCap, SpendCaps, UsageLedger, UsageReport } from "./usage.js";
-export type TypeSafeBackend = "typesafe" | "openrouter";
-export interface BackendConfig {
-    host: string;
-    keyEnv?: string;
-    /** Request path, when the backend does not serve the SDK's own `/v1/systemone`. */
-    path?: string;
-}
-/** Registry of known judgment backends. Extendable by callers. */
-export declare const DECISIONS_BACKENDS: Record<TypeSafeBackend, BackendConfig>;
+export { DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+export type { BackendConfig, TypeSafeBackend } from "./backends.js";
 export interface TypeSafeOptions {
     /** Defaults to TYPESAFE_API_KEY, then the key saved by `/typesafe login`; never returned. */
     apiKey?: string;

package/node_modules/pi-typesafe/dist/client.js

@@ -1,20 +1,59 @@
 import { TypeSafeClient } from "@typesafe-ai/sdk";
 import { recordAuthFailure, recordAuthVerified } from "./auth.js";
+import { DEFAULT_BACKEND, TYPESAFE_KEY_ENV, backendConfig, usesTypesafeKey } from "./backends.js";
 import { evaluateAll, evaluateMany } from "./batch.js";
 import { keySituation } from "./credentials.js";
 import { TypeSafeIntegrationError, safeError } from "./errors.js";
 import { DEFAULT_MAX_INPUT_BYTES, assertWithinByteLimit, prepareEvaluationRequest } from "./schema.js";
 import { DEFAULT_USD_PER_MTOK, capsFromEnvironment, estimateUsd, mergeCaps, openUsageLedger } from "./usage.js";
-/** The path the SDK appends to whatever base URL it is given. */
+export { DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+/** The paths the SDK appends to whatever base URL it is given. */
 const SDK_PATH = "/v1/systemone";
-/** Registry of known judgment backends. Extendable by callers. */
-export const DECISIONS_BACKENDS = {
-    typesafe: { host: "https://api.typesafe.ai", keyEnv: "TYPESAFE_API_KEY" },
-    openrouter: { host: "https://openrouter.ai", keyEnv: "OPENROUTER_API_KEY", path: "/api/alpha/decisions" },
-};
-/** Send the SDK's fixed path to the backend's own, preserving any caller-supplied transport. */
-function backendFetch(path, inner = fetch) {
-    return (input, init) => inner(String(input).replace(SDK_PATH, path), init);
+const SDK_MODELS_PATH = "/v1/models";
+/**
+ * Send the SDK's fixed paths to the backend's own, preserving any caller-supplied transport. A backend that serves
+ * its model list under another path also gets that list renamed to the field the SDK reads.
+ */
+function backendFetch(backend, inner = fetch) {
+    const { path, modelsPath, modelsField } = backend;
+    return async (input, init) => {
+        const url = String(input);
+        const models = modelsPath !== undefined && url.includes(SDK_MODELS_PATH);
+        const rewrite = models ? modelsPath : path;
+        const response = await inner(rewrite === undefined ? url : url.replace(models ? SDK_MODELS_PATH : SDK_PATH, rewrite), init);
+        return models && modelsField !== undefined ? translateModels(response, backend) : response;
+    };
+}
+/**
+ * Hand the SDK the list it expects: the field it reads, and the entry value callers pass as `model:` when the backend
+ * labels models differently. Status and headers survive; a body without the declared field is passed through
+ * unchanged, so the SDK still reports its own shape error.
+ */
+async function translateModels(response, backend) {
+    const { modelsField, modelsIdField } = backend;
+    const text = await response.text();
+    let wire;
+    try {
+        wire = JSON.parse(text);
+    }
+    catch {
+        wire = undefined;
+    }
+    const list = modelsField !== undefined && wire !== null && typeof wire === "object" ? wire[modelsField] : undefined;
+    const headers = new Headers(response.headers);
+    // The body is replaced, so a copied length would describe the old one.
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    const send = (body) => new Response(body, { status: response.status, statusText: response.statusText, headers });
+    if (!Array.isArray(list))
+        return send(text);
+    const models = list.map(entry => {
+        if (modelsIdField === undefined || entry === null || typeof entry !== "object")
+            return entry;
+        const id = entry[modelsIdField];
+        return typeof id === "string" && id.length > 0 ? { ...entry, name: id } : entry;
+    });
+    return send(JSON.stringify({ models }));
 }
 /** Default attempts per client instance; the extension quotes the same number in its consent copy. */
 export const DEFAULT_MAX_REQUESTS = 20;
@@ -80,37 +119,20 @@ function capsDescription(caps) {
 /** A bounded, server-side TypeSafe client independent of Pi's runtime. */
 export function createTypeSafe(options = {}) {
     let apiKey = options.apiKey?.trim();
-    // Resolve backend and host.
-    const backendName = options.backend;
-    let baseURL = "https://api.typesafe.ai";
-    let keyEnv = "TYPESAFE_API_KEY";
-    let backendPath;
-    if (backendName !== undefined) {
-        const backend = DECISIONS_BACKENDS[backendName];
-        if (!backend)
-            throw new TypeSafeIntegrationError("configuration", `Unknown judgment backend "${backendName}". Valid backends: ${Object.keys(DECISIONS_BACKENDS).join(", ")}.`);
-        baseURL = backend.host;
-        keyEnv = backend.keyEnv ?? "TYPESAFE_API_KEY";
-        backendPath = backend.path;
-    }
+    const backendName = options.backend ?? DEFAULT_BACKEND;
+    const backend = backendConfig(backendName);
+    const baseURL = backend.host;
     if (!apiKey) {
-        // Backend-specific env var first (e.g. OPENROUTER_API_KEY), then fall back to
-        // the standard TYPESAFE_API_KEY / stored-key resolution.
-        if (backendName !== undefined && keyEnv !== "TYPESAFE_API_KEY") {
-            const fromEnv = process.env[keyEnv]?.trim();
-            if (fromEnv)
-                apiKey = fromEnv;
-        }
-        if (!apiKey) {
-            const situation = keySituation();
-            if (situation.kind === "unusable")
-                throw new TypeSafeIntegrationError("configuration", situation.reason);
-            if (situation.kind === "environment" || situation.kind === "stored")
-                apiKey = situation.key;
-        }
+        // The same resolution that authState() and ensureApiKey() report, so the status line and the request agree.
+        const situation = keySituation(backendName);
+        if (situation.kind === "unusable")
+            throw new TypeSafeIntegrationError("configuration", situation.reason);
+        if (situation.kind === "environment" || situation.kind === "stored")
+            apiKey = situation.key;
     }
     if (!apiKey) {
-        throw new TypeSafeIntegrationError("configuration", `No API key. Run /typesafe login in Pi, or set ${keyEnv} in the environment.`);
+        const how = usesTypesafeKey(backend) ? `Run /typesafe login in Pi, or set ${TYPESAFE_KEY_ENV}` : `Set ${backend.keyEnv}`;
+        throw new TypeSafeIntegrationError("configuration", `No API key. ${how} in the environment.`);
     }
     const timeout = positiveInteger(options.timeoutMs ?? 15_000, "timeoutMs");
     const maxInputBytes = positiveInteger(options.maxInputBytes ?? DEFAULT_MAX_INPUT_BYTES, "maxInputBytes");
@@ -122,7 +144,8 @@ export function createTypeSafe(options = {}) {
         ...(options.maxInputTokensPerDay === undefined ? {} : { maxInputTokensPerDay: positiveInteger(options.maxInputTokensPerDay, "maxInputTokensPerDay") }),
         ...(options.maxUsdPerDay === undefined ? {} : { maxUsdPerDay: positiveNumber(options.maxUsdPerDay, "maxUsdPerDay") }),
     }, capsFromEnvironment());
-    const transport = backendPath ? backendFetch(backendPath, options.fetch) : options.fetch;
+    // A backend that serves its own paths gets a transport that rewrites them; the default backend keeps the caller's.
+    const transport = backend.path !== undefined || backend.modelsPath !== undefined ? backendFetch(backend, options.fetch) : options.fetch;
     const model = options.model ?? (backendName === "openrouter" ? "typesafe/jev-1.13" : "jev-latest");
     if (typeof model !== "string" || !model.trim() || model.length > 100)
         throw new TypeSafeIntegrationError("configuration", "model must be a nonempty string of at most 100 characters.");
@@ -160,7 +183,8 @@ export function createTypeSafe(options = {}) {
                 const models = await client.models.list(callOptions);
                 if (!Array.isArray(models))
                     throw new TypeSafeIntegrationError("response", "TypeSafe returned an unexpected model list.");
-                if (!verificationRecorded) {
+                // A backend that serves its list publicly accepts any key, so a success there proves nothing about one.
+                if (backend.modelsVerifyKey !== false && !verificationRecorded) {
                     verificationRecorded = true;
                     recordAuthVerified();
                 }

package/node_modules/pi-typesafe/dist/credentials.d.ts

@@ -1,8 +1,12 @@
+import type { TypeSafeBackend } from "./backends.js";
 export type KeySource = "environment" | "stored";
 /** The complete, never-throwing answer to "which key is in effect". */
-export type KeySituation = {
+export type KeySituation = 
+/** `keyEnv` names the variable that was read; absent means `TYPESAFE_API_KEY`. */
+{
     readonly kind: "environment";
     readonly key: string;
+    readonly keyEnv?: string;
 } | {
     readonly kind: "stored";
     readonly key: string;
@@ -26,10 +30,12 @@ export declare function normalizeApiKey(value: unknown): string;
  */
 export declare function readStoredApiKey(): string | undefined;
 /**
- * What the environment, the login store, and file permissions add up to right now. Never throws; the "unusable" kind
- * carries the user-facing reason (a stored key that other local users can read).
+ * What the environment, the login store, and file permissions add up to right now for one judgment backend. Never
+ * throws; the "unusable" kind carries the user-facing reason (a stored key that other local users can read).
+ * The TypeSafe backend reads `TYPESAFE_API_KEY`, then the login store. Every other backend reads only its own
+ * environment variable, because the store holds a TypeSafe key and a login verifies against api.typesafe.ai.
  */
-export declare function keySituation(): KeySituation;
+export declare function keySituation(backend?: TypeSafeBackend): KeySituation;
 /** Short phrase naming the source; full sentences stay with the caller. */
 export declare function keySourceLabel(situation: KeySituation): string;
 /**
@@ -38,7 +44,7 @@ export declare function keySourceLabel(situation: KeySituation): string;
  * store must not be read. New code should call keySituation() instead: same precedence, never throws, and the
  * "must not be read" case arrives as `unusable` with the reason.
  */
-export declare function resolveApiKey(): {
+export declare function resolveApiKey(backend?: TypeSafeBackend): {
     key: string;
     source: KeySource;
 } | undefined;

package/node_modules/pi-typesafe/dist/credentials.js

@@ -1,6 +1,7 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { DEFAULT_BACKEND, TYPESAFE_KEY_ENV, backendConfig, usesTypesafeKey } from "./backends.js";
 import { TypeSafeIntegrationError } from "./errors.js";
 /** Mirrors Pi's agent directory rule; every pi-typesafe file lives in this one directory. */
 export function piTypesafeDir() {
@@ -44,13 +45,19 @@ export function readStoredApiKey() {
     }
 }
 /**
- * What the environment, the login store, and file permissions add up to right now. Never throws; the "unusable" kind
- * carries the user-facing reason (a stored key that other local users can read).
+ * What the environment, the login store, and file permissions add up to right now for one judgment backend. Never
+ * throws; the "unusable" kind carries the user-facing reason (a stored key that other local users can read).
+ * The TypeSafe backend reads `TYPESAFE_API_KEY`, then the login store. Every other backend reads only its own
+ * environment variable, because the store holds a TypeSafe key and a login verifies against api.typesafe.ai.
  */
-export function keySituation() {
-    const fromEnvironment = process.env.TYPESAFE_API_KEY?.trim();
+export function keySituation(backend = DEFAULT_BACKEND) {
+    const config = backendConfig(backend);
+    const keyEnv = config.keyEnv ?? TYPESAFE_KEY_ENV;
+    const fromEnvironment = process.env[keyEnv]?.trim();
     if (fromEnvironment)
-        return { kind: "environment", key: fromEnvironment };
+        return { kind: "environment", key: fromEnvironment, keyEnv };
+    if (!usesTypesafeKey(config))
+        return { kind: "missing" };
     const path = credentialsPath();
     try {
         const key = readStoredApiKey();
@@ -66,7 +73,7 @@ export function keySituation() {
 /** Short phrase naming the source; full sentences stay with the caller. */
 export function keySourceLabel(situation) {
     switch (situation.kind) {
-        case "environment": return "TYPESAFE_API_KEY";
+        case "environment": return situation.keyEnv ?? TYPESAFE_KEY_ENV;
         case "stored": return "/typesafe login";
         case "missing": return "no key";
         case "unusable": return "unusable key";
@@ -78,8 +85,8 @@ export function keySourceLabel(situation) {
  * store must not be read. New code should call keySituation() instead: same precedence, never throws, and the
  * "must not be read" case arrives as `unusable` with the reason.
  */
-export function resolveApiKey() {
-    const situation = keySituation();
+export function resolveApiKey(backend = DEFAULT_BACKEND) {
+    const situation = keySituation(backend);
     if (situation.kind === "unusable")
         throw new TypeSafeIntegrationError("configuration", situation.reason);
     return situation.kind === "environment" || situation.kind === "stored" ? { key: situation.key, source: situation.kind } : undefined;

package/node_modules/pi-typesafe/dist/extension.js

@@ -11,7 +11,7 @@ const sample = {
     questions: {
         category: { type: "choice", instructions: "Which team should handle this message?", criteria: { billing: "Charges and payments", technical: "Software failures", other: "None of these" } },
         urgent: { type: "noul", instructions: "Does the sender request help today?" },
-        frustration: { type: "score", instructions: "How frustrated does the sender sound?", criteria: ["A neutral request without expressed frustration", "Expressed frustration while remaining civil", "Explicit anger or threats"] },
+        frustration: { type: "score", instructions: "How frustrated does the sender sound?", criteria: ["Neutral request", "Frustrated but civil", "Angry or threatening"] },
     },
 };
 function format(result, expanded = false) {
@@ -69,6 +69,9 @@ export default function typesafeExtension(pi) {
         description: `Evaluate supplied state with independent Choice, Score, and Noul questions in one TypeSafe request. Each question judges the whole state, so when several items are involved, put each item in a named state field (e.g. \`reports.r1\`) and ask one question per item per dimension (e.g. \`r1_owner\`, \`r2_owner\`), naming the field in the instructions; never aggregate several items into one question. ${disclosure} Requires operator opt-in via /typesafe enable or PI_TYPESAFE_ENABLED=1. Limit: 32 questions, ${DEFAULT_MAX_INPUT_BYTES / 1024} KiB JSON, ${DEFAULT_MAX_REQUESTS} attempts per session; no retries.`,
         promptSnippet: "Ask batched structured questions with TypeSafe (external service; operator opt-in required)",
         promptGuidelines: [
+            // The payload shape is what models get wrong on the first call; the same sample the playground edits is the cheapest way to show it.
+            // Every session pays for this line on every tool listing, so the sample stays short.
+            `Request shape, all three question kinds in one call: ${JSON.stringify(sample)}`,
             "Use typesafe_evaluate only for requested semantic judgments, not calculations or exact lookups; send only the relevant permitted data.",
             "Batch independent typesafe_evaluate questions over the same state; use code or explicit permission rules for actions, never confidence as authorization.",
             "When typesafe_evaluate judges several items, give each item a named state field and ask one question per item per dimension, naming the field in the instructions; one question over many items returns an unusable blend.",

package/node_modules/pi-typesafe/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { createTypeSafe, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS } from "./client.js";
+export { createTypeSafe, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
 export type { TypeSafe, TypeSafeOptions, EvaluationOptions, Evaluation, UsageSnapshot, SpendReport, TypeSafeBackend, BackendConfig, } from "./client.js";
 export { ask, DEFAULT_ASK_TIMEOUT_MS } from "./ask.js";
 export type { AskAnswer, AskOptions, Judge } from "./ask.js";

package/node_modules/pi-typesafe/dist/index.js

@@ -1,4 +1,4 @@
-export { createTypeSafe, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS } from "./client.js";
+export { createTypeSafe, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
 export { ask, DEFAULT_ASK_TIMEOUT_MS } from "./ask.js";
 export { fanOut, DEFAULT_CONCURRENCY, evaluateMany, evaluateAll, chunkEvaluationRequest } from "./batch.js";
 export { authState, authStatePath, clearAuthState, describeAuth, recordAuthFailure, recordAuthVerified } from "./auth.js";