@herbertgao/pi-extensions 2026.9.20 → 2026.10.1

package/node_modules/pi-multi-account/model-pins.ts

@@ -0,0 +1,36 @@
+/** Explicit routing preferences; never foreground selections or authorization for a cheaper tier. */
+import { mutateConfigFile } from "./config-file-transaction.ts";
+
+export function validModelPinScope(scope: string): boolean {
+	return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(scope);
+}
+
+export function normalizeModelPins(value: unknown): Record<string, string> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return Object.fromEntries(Object.entries(value).filter(([scope, model]) =>
+		validModelPinScope(scope) && typeof model === "string" && model.trim().length > 0 &&
+		!/[\s\x00-\x1f]/.test(model.trim()),
+	).map(([scope, model]) => [scope, (model as string).trim()]));
+}
+
+/** Change only one group's pin through the shared extension configuration transaction. */
+export function persistModelPin(
+	path: string,
+	scope: string,
+	model: string | undefined,
+	canCommit: () => boolean = () => true,
+): Record<string, string> {
+	if (!validModelPinScope(scope) || (model !== undefined && normalizeModelPins({ [scope]: model })[scope] !== model)) {
+		throw new Error("invalid model pin");
+	}
+	const next = mutateConfigFile(path, disk => {
+		if (disk.pinnedModels !== undefined && (!disk.pinnedModels || typeof disk.pinnedModels !== "object" || Array.isArray(disk.pinnedModels))) {
+			throw new Error("pinnedModels must be an object");
+		}
+		const pins = { ...disk.pinnedModels };
+		if (model === undefined) delete pins[scope];
+		else pins[scope] = model;
+		return { pinnedModels: pins };
+	}, canCommit);
+	return normalizeModelPins(next.pinnedModels);
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "pi-multi-account",
-  "version": "1.23.2",
+  "version": "1.24.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",
@@ -45,7 +45,9 @@
     "provider-payload-stream.ts",
     "auth-file-transaction.ts",
     "state-file-transaction.ts",
+    "config-file-transaction.ts",
     "model-catalog.ts",
+    "model-pins.ts",
     "usage.ts",
     "cursor-bridge.ts",
     "cursor-model-name.ts",
@@ -78,13 +80,13 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-ai": "*"
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "@earendil-works/pi-ai": "0.85.1",
-    "@types/node": "^22.20.1",
+    "@earendil-works/pi-ai": "0.87.1",
+    "@earendil-works/pi-coding-agent": "0.87.1",
+    "@types/node": "^22.20.4",
     "typescript": "^6.0.3"
   },
   "pi": {
@@ -93,7 +95,7 @@
     ]
   },
   "dependencies": {
-    "@bufbuild/protobuf": "^2.14.0",
+    "@bufbuild/protobuf": "^2.15.0",
     "proper-lockfile": "4.1.2"
   },
   "overrides": {

package/node_modules/pi-multi-account/slot-proxy-auth.ts

@@ -28,6 +28,7 @@ import {
 } from "./cursor-bridge.ts";
 import {
 	needsChildFacingApiKey,
+	isPlaceholderFor,
 	placeholderKeyFor,
 	proxyFamilyFor,
 	type ProxyFamily,
@@ -67,7 +68,7 @@ export function isChildFacingPlaceholder(
 	entry: AuthBlob | undefined,
 	family: ProxyFamily,
 ): boolean {
-	return entry?.type === "api_key" && entry.key === placeholderKeyFor(family);
+	return entry?.type === "api_key" && isPlaceholderFor(family, entry.key);
 }
 
 export function isChildFacingPlaceholderForSlot(
@@ -75,7 +76,9 @@ export function isChildFacingPlaceholderForSlot(
 	slotId: string,
 ): boolean {
 	const key = childFacingPlaceholderKey(slotId);
-	return !!key && entry?.type === "api_key" && entry.key === key;
+	const family = proxyFamilyFor(slotId);
+	return !!key && entry?.type === "api_key" &&
+		(family ? isPlaceholderFor(family, entry.key) : entry.key === key);
 }
 
 /** What the parent should use for refresh/upstream: sidecar OAuth wins over a child-facing placeholder. */
@@ -101,6 +104,13 @@ export function applyShadowPlan(
 		return { auth: { ...auth }, sidecar: { ...sidecar }, changed: false };
 	}
 	const entry = auth[slotId];
+	const hidden = sidecar[slotId];
+	if (isChildFacingPlaceholderForSlot(entry, slotId) && entry?.key !== facing.key &&
+		hidden?.type === "oauth" && typeof hidden.access === "string" && hidden.access.length > 0) {
+		// Upgrade only a publication backed by the parent's actual OAuth blob. Never rewrite a
+		// user's real API key or replace the hidden credential with a placeholder during migration.
+		return { auth: { ...auth, [slotId]: facing }, sidecar: { ...sidecar }, changed: true };
+	}
 	if (entry?.type === "oauth" && typeof entry.access === "string" && entry.access.length > 0) {
 		return {
 			auth: { ...auth, [slotId]: facing },

package/node_modules/pi-multi-account/slot-proxy.ts

@@ -36,6 +36,14 @@
  */
 export const PROXY_PLACEHOLDER_KEY = "pi-multi-account-proxy";
 
+/**
+ * Non-secret Anthropic placeholder with the shape Pi's native transport recognizes as OAuth.
+ * Request identity, tool-name conversion and response mapping all depend on this marker; adding
+ * a Bearer header at the proxy is too late. The proxy replaces it with the real token on egress.
+ * The legacy generic placeholder remains recognizable for restoration during an upgrade.
+ */
+export const ANTHROPIC_PROXY_PLACEHOLDER_KEY = "sk-ant-oat01-pi-multi-account-proxy";
+
 /**
  * The `apiKey` published for a **Codex** slot.
  *
@@ -60,9 +68,10 @@ export const PROXY_PLACEHOLDER_JWT = [
 	"",
 ].join(".");
 
-/** Either published placeholder — neither is a credential, both mark "a child we published for". */
+/** Current or legacy published placeholder — none is a real credential. */
 export function isPublishedPlaceholder(value: string | undefined): boolean {
-	return value === PROXY_PLACEHOLDER_KEY || value === PROXY_PLACEHOLDER_JWT;
+	return value === PROXY_PLACEHOLDER_KEY || value === PROXY_PLACEHOLDER_JWT ||
+		value === ANTHROPIC_PROXY_PLACEHOLDER_KEY;
 }
 
 export type ProxyFamily = "anthropic" | "codex";
@@ -273,7 +282,14 @@ export function shapeUpstreamRequest(args: {
 		}
 	}
 
-	return { ok: true, url: `${base}${rest}`, headers };
+	// Image tools append these endpoints directly to the slot base; chat already sends /codex.
+	// Leave all other paths and families intact, including usage requests.
+	const upstreamRest =
+		route.family === "codex" && /^\/images\/(?:generations|edits)(?:\?.*)?$/.test(rest)
+			? `/codex${rest}`
+			: rest;
+
+	return { ok: true, url: `${base}${upstreamRest}`, headers };
 }
 
 /** Keep any beta flags the caller asked for, and add ours once. */
@@ -289,7 +305,13 @@ function mergeBeta(existing: string | undefined, required: string): string {
 
 /** The `apiKey` to publish for a slot of this family. */
 export function placeholderKeyFor(family: ProxyFamily): string {
-	return family === "codex" ? PROXY_PLACEHOLDER_JWT : PROXY_PLACEHOLDER_KEY;
+	return family === "codex" ? PROXY_PLACEHOLDER_JWT : ANTHROPIC_PROXY_PLACEHOLDER_KEY;
+}
+
+/** Recognize the previous Anthropic publication without mistaking real tokens for placeholders. */
+export function isPlaceholderFor(family: ProxyFamily, value: unknown): boolean {
+	return value === placeholderKeyFor(family) ||
+		(family === "anthropic" && value === PROXY_PLACEHOLDER_KEY);
 }
 
 /** The `models.json` route to publish for a slot served by this proxy. */
@@ -305,7 +327,7 @@ export function isOwnLoopbackPublication(
 	if (!existing || typeof existing !== "object") return false;
 	const rec = existing as Record<string, unknown>;
 	return (
-		rec.apiKey === placeholderKeyFor(family) &&
+		isPlaceholderFor(family, rec.apiKey) &&
 		typeof rec.baseUrl === "string" &&
 		rec.baseUrl.startsWith("http://127.0.0.1:")
 	);

package/node_modules/pi-typesafe/README.md

@@ -142,7 +142,7 @@ if (!answer.ok) return { skipped: answer.errorCode === "budget" };  // never thr
 
 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`. Command Code serves the same protocol: `createTypeSafe({ backend: "commandcode" })` sends them to `api.commandcode.ai` with the key from `COMMANDCODE_API_KEY` and the model `typesafe/jev`. Or pass a `BackendEndpoint` object as `backend` to name any host that serves the protocol: it brings its own key variable, never reads `TYPESAFE_API_KEY`, and `backendHost()` reports its destination host for your consent text. These backends have no login store, so `/typesafe login` does not apply to them. 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).
+Judgments can also go through OpenRouter: `createTypeSafe({ backend: "openrouter" })` sends them to `openrouter.ai` with the key from `OPENROUTER_API_KEY`. Command Code serves the same protocol: `createTypeSafe({ backend: "commandcode" })` sends them to `api.commandcode.ai` with the key from `COMMANDCODE_API_KEY` and the model `typesafe/jev`. So does Liquid AI: `createTypeSafe({ backend: "liquid" })` sends them to `api.liquid.ai` with the key from `LIQUID_API_KEY` and the model `d1:free`, which is free; pass `model: "d1"` for the paid model, priced at $0.040 per million input tokens. Liquid counts the state once per question, where TypeSafe counts it once per request, so a request with N questions costs about N times the state on Liquid. Speed, measured on 2026-10-03 with one request at a time: `d1:free` took a median of about 14 seconds and sometimes failed with HTTP 504 after about 46 seconds, while `d1` took about 0.5 seconds. With `d1:free`, raise `timeoutMs` above its 15-second default, or pass `model: "d1"`. Or pass a `BackendEndpoint` object as `backend` to name any host that serves the protocol: it brings its own key variable, never reads `TYPESAFE_API_KEY`, and `backendHost()` reports its destination host for your consent text. These backends have no login store, so `/typesafe login` does not apply to them. 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/backends.d.ts

@@ -1,6 +1,6 @@
-export type TypeSafeBackend = "typesafe" | "openrouter" | "commandcode";
+export type TypeSafeBackend = "typesafe" | "openrouter" | "commandcode" | "liquid";
 export interface BackendConfig {
-    /** Human name for status lines: "TypeSafe", "OpenRouter", "Command Code". */
+    /** Human name for status lines: "TypeSafe", "OpenRouter", "Command Code", "Liquid AI". */
     label: string;
     host: string;
     /** The environment variable that carries this backend's key. Absent means the TypeSafe key resolution applies. */
@@ -16,6 +16,11 @@ export interface BackendConfig {
     /** Whether the model list checks the key. A public list accepts any key, so it proves nothing. Absent means it does. */
     modelsVerifyKey?: boolean;
 }
+/** A registry entry: a backend config that can also name a price per model. Caller-supplied endpoints carry none. */
+export interface RegistryBackendConfig extends BackendConfig {
+    /** USD per million input tokens, by the model id as it is sent. A model with no entry is priced at DEFAULT_USD_PER_MTOK. */
+    prices?: Readonly<Record<string, number>>;
+}
 /** A caller-supplied endpoint that serves the Jev decisions protocol. Passed per call; never added to the registry. */
 export interface BackendEndpoint extends BackendConfig {
     /** Required. The environment variable with this endpoint's key. Must not be TYPESAFE_API_KEY. */
@@ -26,7 +31,7 @@ export interface BackendEndpoint extends BackendConfig {
 /** A registry name or a caller-supplied endpoint. */
 export type BackendSpec = TypeSafeBackend | BackendEndpoint;
 /** A backend resolved and validated: what the client will actually use. */
-export interface ResolvedBackend extends BackendConfig {
+export interface ResolvedBackend extends RegistryBackendConfig {
     /** Registry name, absent for a caller-supplied endpoint. */
     readonly name?: TypeSafeBackend;
     /** Origin only: scheme, host, and port. */
@@ -42,9 +47,9 @@ 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. Callers pass a `BackendEndpoint` for a host this registry does not name. */
-export declare const DECISIONS_BACKENDS: Record<TypeSafeBackend, BackendConfig>;
+export declare const DECISIONS_BACKENDS: Record<TypeSafeBackend, RegistryBackendConfig>;
 /** 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;
+export declare function backendConfig(name: TypeSafeBackend): RegistryBackendConfig;
 /**
  * The model id to send for a caller's `model` on this backend. OpenRouter routes a bare Jev id under the `typesafe`
  * author: `jev-latest` becomes its alias form `~typesafe/jev-latest`, and a bare `jev-<major>.<minor>` — with or
@@ -55,6 +60,11 @@ export declare function backendConfig(name: TypeSafeBackend): BackendConfig;
 export declare function backendModelId(backend: TypeSafeBackend, model: string): string;
 /** The model a client sends when the caller names none: the backend's own default, in the form that backend accepts. */
 export declare function defaultModelId(backend: TypeSafeBackend): string;
+/**
+ * The registry's price for a model, in USD per million input tokens, or undefined when the backend names none.
+ * `model` is the id as sent. A caller-supplied endpoint has no prices.
+ */
+export declare function backendPrice(backend: ResolvedBackend, model: string): number | undefined;
 /**
  * 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.

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

@@ -26,6 +26,15 @@ export const DECISIONS_BACKENDS = {
         modelsIdField: "id",
         modelsVerifyKey: false,
     },
+    liquid: {
+        label: "Liquid AI",
+        host: "https://api.liquid.ai",
+        keyEnv: "LIQUID_API_KEY",
+        path: "/decisions/v1/systemone",
+        modelsPath: "/decisions/v1/models",
+        modelsVerifyKey: true,
+        prices: { d1: 0.04, "d1:free": 0 },
+    },
 };
 /** The registry entry for a backend name; a `configuration` error for a name the registry does not know. */
 export function backendConfig(name) {
@@ -39,6 +48,7 @@ const DEFAULT_MODEL = {
     typesafe: "jev-latest",
     openrouter: "typesafe/jev-1.13",
     commandcode: "typesafe/jev",
+    liquid: "d1:free",
 };
 /**
  * The model id to send for a caller's `model` on this backend. OpenRouter routes a bare Jev id under the `typesafe`
@@ -61,6 +71,14 @@ export function backendModelId(backend, model) {
 export function defaultModelId(backend) {
     return backendModelId(backend, DEFAULT_MODEL[backend]);
 }
+/**
+ * The registry's price for a model, in USD per million input tokens, or undefined when the backend names none.
+ * `model` is the id as sent. A caller-supplied endpoint has no prices.
+ */
+export function backendPrice(backend, model) {
+    const prices = backend.prices;
+    return prices !== undefined && Object.hasOwn(prices, model) ? prices[model] : undefined;
+}
 /**
  * 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.

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

@@ -2,8 +2,8 @@ import type { Fetch, Questions, SystemOneRequest, SystemOneResult } from "@types
 import type { BackendSpec } from "./backends.js";
 import type { BatchEvaluation, BatchOptions } from "./batch.js";
 import type { BlockedCap, SpendCaps, UsageLedger, UsageReport } from "./usage.js";
-export { backendHost, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
-export type { BackendConfig, BackendEndpoint, BackendSpec, ResolvedBackend, TypeSafeBackend } from "./backends.js";
+export { backendHost, backendPrice, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+export type { BackendConfig, BackendEndpoint, BackendSpec, RegistryBackendConfig, ResolvedBackend, TypeSafeBackend } from "./backends.js";
 export interface TypeSafeOptions {
     /** Defaults to TYPESAFE_API_KEY, then the key saved by `/typesafe login`; never returned. */
     apiKey?: string;
@@ -23,7 +23,7 @@ export interface TypeSafeOptions {
     maxInputTokensPerDay?: number;
     /** Estimated spend per local day, in US dollars. Unlimited by default. */
     maxUsdPerDay?: number;
-    /** Price used for the cost estimate and the USD cap. Default: DEFAULT_USD_PER_MTOK. */
+    /** Price in USD per million input tokens, used for every request's cost and the USD cap; 0 means free. Default: the backend's price for the model sent, else DEFAULT_USD_PER_MTOK. */
     usdPerMTok?: number;
     /** The usage ledger; defaults to the store next to the key. Injected by tests. */
     ledger?: UsageLedger;
@@ -50,6 +50,7 @@ export interface SpendReport {
     readonly session: UsageSnapshot;
     readonly today: UsageReport;
     readonly caps: SpendCaps;
+    /** The price of this client's default model. A request that names another model may be priced differently. */
     readonly usdPerMTok: number;
     readonly blocked?: BlockedCap;
 }

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

@@ -1,12 +1,12 @@
 import { TypeSafeClient } from "@typesafe-ai/sdk";
 import { recordAuthFailure, recordAuthVerified } from "./auth.js";
-import { TYPESAFE_KEY_ENV, backendModelId, resolveBackend, usesTypesafeKey } from "./backends.js";
+import { TYPESAFE_KEY_ENV, backendModelId, backendPrice, resolveBackend, 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";
-export { backendHost, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+export { backendHost, backendPrice, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
 /** The paths the SDK appends to whatever base URL it is given. */
 const SDK_PATH = "/v1/systemone";
 const SDK_MODELS_PATH = "/v1/models";
@@ -63,6 +63,12 @@ function positiveInteger(value, label) {
     }
     return value;
 }
+function nonNegativeNumber(value, label) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeSafeIntegrationError("configuration", `${label} must be a non-negative number.`);
+    }
+    return value;
+}
 function positiveNumber(value, label) {
     if (!Number.isFinite(value) || value <= 0) {
         throw new TypeSafeIntegrationError("configuration", `${label} must be a positive number.`);
@@ -138,7 +144,7 @@ export function createTypeSafe(options = {}) {
     const timeout = positiveInteger(options.timeoutMs ?? 15_000, "timeoutMs");
     const maxInputBytes = positiveInteger(options.maxInputBytes ?? DEFAULT_MAX_INPUT_BYTES, "maxInputBytes");
     const maxRequests = positiveInteger(options.maxRequests ?? DEFAULT_MAX_REQUESTS, "maxRequests");
-    const usdPerMTok = positiveNumber(options.usdPerMTok ?? DEFAULT_USD_PER_MTOK, "usdPerMTok");
+    const callerRate = options.usdPerMTok === undefined ? undefined : nonNegativeNumber(options.usdPerMTok, "usdPerMTok");
     const caps = mergeCaps({
         maxRequests,
         ...(options.maxRequestsPerDay === undefined ? {} : { maxRequestsPerDay: positiveInteger(options.maxRequestsPerDay, "maxRequestsPerDay") }),
@@ -165,12 +171,17 @@ export function createTypeSafe(options = {}) {
         logLevel: "off",
         ...(transport ? { fetch: transport } : {}),
     });
-    const ledger = options.ledger ?? openUsageLedger({ usdPerMTok });
+    // The caller's price wins; else the backend's price for the model sent; else the default. Each request is priced alone.
+    const rateFor = (sent) => callerRate ?? backendPrice(backend, sent) ?? DEFAULT_USD_PER_MTOK;
+    const usdPerMTok = rateFor(model);
+    // The ledger's own rate only estimates input tokens that carry no recorded cost, so it follows the caller's price alone.
+    const ledger = options.ledger ?? openUsageLedger(callerRate === undefined ? {} : { usdPerMTok: callerRate });
+    let sessionUsd = 0;
     const usage = { requestsStarted: 0, requestsSucceeded: 0, requestsFailed: 0, inputTokens: 0, outputTokens: 0 };
     // Auth state writes are deduplicated: one verification record per process, one record per distinct failure.
     let verificationRecorded = false;
     let lastFailureRecorded;
-    const snapshot = () => ({ ...usage, estimatedUsd: estimateUsd(usage.inputTokens, usdPerMTok) });
+    const snapshot = () => ({ ...usage, estimatedUsd: Math.round(sessionUsd * 1e6) / 1e6 });
     const blocked = () => (usage.requestsStarted >= maxRequests ? undefined : ledger.blocked(caps));
     const typesafe = {
         getUsage: snapshot,
@@ -203,7 +214,8 @@ export function createTypeSafe(options = {}) {
         async evaluate(input, callOptions = {}) {
             const validated = prepareEvaluationRequest(input, { maxInputBytes });
             // A per-request model meets the same mapping as the client default; the schema already limited the caller's own id.
-            const body = JSON.stringify({ ...validated, model: validated.model === undefined ? model : mapModel(validated.model) });
+            const sentModel = validated.model === undefined ? model : mapModel(validated.model);
+            const body = JSON.stringify({ ...validated, model: sentModel });
             assertWithinByteLimit(body, maxInputBytes);
             if (callOptions.signal?.aborted)
                 throw new TypeSafeIntegrationError("aborted", "TypeSafe request cancelled before submission.");
@@ -227,7 +239,10 @@ export function createTypeSafe(options = {}) {
                 usage.requestsSucceeded += 1;
                 usage.inputTokens += result.usage.input_tokens;
                 usage.outputTokens += result.usage.output_tokens;
-                ledger.recordSuccess(result.usage.input_tokens, result.usage.output_tokens);
+                // Unrounded: a small request must still count toward the cap.
+                const cost = (result.usage.input_tokens * rateFor(sentModel)) / 1e6;
+                sessionUsd += cost;
+                ledger.recordSuccess(result.usage.input_tokens, result.usage.output_tokens, cost);
                 if (!verificationRecorded) {
                     verificationRecorded = true;
                     recordAuthVerified();

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

@@ -1,5 +1,5 @@
-export { createTypeSafe, backendHost, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
-export type { TypeSafe, TypeSafeOptions, EvaluationOptions, Evaluation, UsageSnapshot, SpendReport, TypeSafeBackend, BackendConfig, BackendEndpoint, BackendSpec, ResolvedBackend, } from "./client.js";
+export { createTypeSafe, backendHost, backendPrice, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
+export type { TypeSafe, TypeSafeOptions, EvaluationOptions, Evaluation, UsageSnapshot, SpendReport, TypeSafeBackend, BackendConfig, BackendEndpoint, BackendSpec, RegistryBackendConfig, ResolvedBackend, } from "./client.js";
 export { ask, DEFAULT_ASK_TIMEOUT_MS } from "./ask.js";
 export type { AskAnswer, AskOptions, Judge } from "./ask.js";
 export { fanOut, DEFAULT_CONCURRENCY, evaluateMany, evaluateAll, chunkEvaluationRequest } from "./batch.js";

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

@@ -1,4 +1,4 @@
-export { createTypeSafe, backendHost, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
+export { createTypeSafe, backendHost, backendPrice, resolveBackend, 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";

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

@@ -40,6 +40,10 @@ export declare function usagePath(): string;
 /** Input-token cost, rounded to a micro-dollar so the number stays readable. */
 export declare function estimateUsd(inputTokens: number, usdPerMTok: number): number;
 export declare function emptyTotals(): UsageTotals;
+/** Longest an update waits for the ledger lock. A request that cannot get it keeps its delta and adds it with the next update. */
+export declare const LOCK_WAIT_MS = 200;
+/** A lock this old belongs to a process that died while holding it; the next update takes it over. */
+export declare const LOCK_STALE_MS = 5000;
 /** The caps a headless run may set without code: `PI_TYPESAFE_MAX_USD_PER_DAY` and its siblings. */
 export declare function capsFromEnvironment(env?: NodeJS.ProcessEnv): SpendCaps;
 /** Environment first for day caps, then the explicit option; a cap is never raised by the environment. */
@@ -49,12 +53,15 @@ export interface UsageLedgerOptions {
     path?: string;
     /** Clock for the local day and for rollover; injectable for tests. */
     now?: () => Date;
+    /** Rate for input tokens that have no recorded cost: requests recorded without one, and days from an older ledger file. Default: DEFAULT_USD_PER_MTOK. */
     usdPerMTok?: number;
 }
 /**
- * One day of persisted request, token, and cost totals, plus the caps that stop the next request. The in-memory copy is
- * authoritative for this process; the file is the cross-process, across-restart record. Reads are defensive, writes are
- * atomic and best-effort, and a day rolls over on the local date, so a long eval cannot accumulate forever unnoticed.
+ * One day of persisted request, token, and cost totals, plus the caps that stop the next request. The file is the
+ * record for every process: each update adds its delta to the file's current content under a lock, and `today()`,
+ * `blocked()`, and `describe()` read the file, so a cap counts every process that writes it. A delta that cannot be
+ * written in time (the lock is held, or the file is unwritable) stays in this process and is added with its next
+ * update. Reads are defensive, writes are atomic and best-effort, and a day rolls over on the local date.
  */
 export interface UsageLedger {
     readonly path: string;
@@ -63,11 +70,14 @@ export interface UsageLedger {
     today(): UsageReport;
     /** Count the attempt before it is submitted; a request that never returns still counts. */
     recordStart(): void;
-    recordSuccess(inputTokens: number, outputTokens: number): void;
+    /** `usd` is this request's cost at its own price; without it the request is estimated at the ledger's rate. */
+    recordSuccess(inputTokens: number, outputTokens: number, usd?: number): void;
     recordFailure(): void;
     /** The reached day cap that blocks the next request, or undefined. The caller owns the caps. */
     blocked(caps: SpendCaps): BlockedCap | undefined;
     /** One line for status output: today's requests, tokens, and cost, with the caps that apply. */
     describe(caps?: SpendCaps): string;
+    /** Add to the file any delta this process still holds. Updates do this themselves; call it before the process exits. */
+    flush?(): void;
 }
 export declare function openUsageLedger(options?: UsageLedgerOptions): UsageLedger;