@jameslovespancakes/pi-plus 1.0.14 → 1.0.16

package/README.md

@@ -17,6 +17,8 @@
 
 ## Install
 
+Requires **pi 0.87.0 or newer**.
+
 ```sh
 pi install npm:@jameslovespancakes/pi-plus           # npm
 pi install git:github.com/jameslovespancakes/pi-plus # git
@@ -48,13 +50,13 @@ Nothing else is required, every feature configures itself from within pi.
 
 ### Pool every subscription
 
-Add multiple Claude, ChatGPT/Codex, Kimi Code, or xAI/Grok accounts. pi-plus
-keeps credentials separate, refreshes them safely, and supports sequential or
-quota-aware routing.
+Add multiple Claude, ChatGPT/Codex, Gemini, Kimi Code, or xAI/Grok accounts.
+pi-plus keeps credentials separate, refreshes them safely, and supports
+sequential or quota-aware routing.
 
 ```
 /accounts add anthropic work
-/accounts add kimi-coding personal
+/accounts add gemini personal
 /routing quota-aware
 ```
 
@@ -75,6 +77,31 @@ Account and routing commands are provider-agnostic. Sequential routing uses
 account order; quota-aware routing uses reported capacity and fairly probes
 accounts whose provider does not publish quota headers.
 
+### Gemini on a Google account
+
+pi keeps only the metered `google/*` API. pi-plus adds `gemini/*`, served by
+Google's Antigravity backend and pooled like every other subscription. The
+provider is ported from [`pi-antigravity`](https://github.com/Rahularya01/pi-antigravity).
+`/login` → **Gemini** signs in through the browser (callback on port 51121; on
+a headless machine, paste the callback URL when asked).
+
+```
+/login gemini
+/accounts add gemini personal
+```
+
+Models include Gemini 3.x Flash and 3.1 Pro, plus the Claude and GPT-OSS
+models the backend also serves; each thinking level routes to the backend's own
+runtime model. The list refreshes from your account, so newly enabled models
+appear without an update, and `/models-refresh` forces it.
+
+A quota-walled account is held out of routing until it resets, so the next
+request goes to another pooled account. `PI_GEMINI_PROJECT_ID` pins a Cloud
+project; most accounts need none.
+
+`gemini/*` is auto-approved because the subscription has already paid for it;
+the metered `google/*` still asks.
+
 ### Pick models on evidence
 
 `list_models` puts the full **Artificial Analysis** benchmark set in front of the
@@ -257,10 +284,15 @@ pi-plus is a thin layer over other people's work.
 | [`pi`](https://pi.dev/) | the host agent and the entire extension API | MIT |
 | [`xxhash-wasm`](https://github.com/jungomi/xxhash-wasm) | vendored into `src/core/anthropic/vendor/` for the billing checksum | MIT |
 | [`pi-workflow-engine`](https://github.com/timbrinded/pi-workflow-engine) | embedded workflow runtime and built-in workflows | MIT |
+| [`pi-antigravity`](https://github.com/Rahularya01/pi-antigravity) | reference for the `gemini` provider: Antigravity OAuth, wire format, model routing and catalogue discovery | MIT |
 
 The workflow engine keeps its upstream license in
 [`src/domains/workflows/LICENSE.md`](src/domains/workflows/LICENSE.md).
 
+The `gemini` provider in `src/core/gemini/` is ported from `pi-antigravity`
+0.8.0 and adapted to pi-plus's pooled accounts and pi's own Google adapter; its
+upstream license is kept in [`src/core/gemini/LICENSE.md`](src/core/gemini/LICENSE.md).
+
 The Anthropic provider, OAuth, quota and routing were originally adopted from
 [`@cortexkit/pi-anthropic-auth`](https://github.com/cortexkit/anthropic-auth)
 (MIT) and have since been reimplemented in this repository.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jameslovespancakes/pi-plus",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "type": "module",
   "description": "pi and more",
   "license": "MIT",
@@ -49,10 +49,10 @@
     "ws": "^8.18.3"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": "^0.86.1",
-    "@earendil-works/pi-ai": "^0.86.1",
-    "@earendil-works/pi-coding-agent": "^0.86.1",
-    "@earendil-works/pi-tui": "^0.86.1",
+    "@earendil-works/pi-agent-core": "^0.87.0",
+    "@earendil-works/pi-ai": "^0.87.0",
+    "@earendil-works/pi-coding-agent": "^0.87.0",
+    "@earendil-works/pi-tui": "^0.87.0",
     "typebox": "*"
   },
   "scripts": {

package/src/core/accounts/oauth-pool.ts

@@ -40,7 +40,6 @@ interface OAuthPoolFile {
   providers: Record<string, ProviderOAuthPool>;
 }
 
-const EMPTY_FILE: OAuthPoolFile = { version: 1, providers: {} };
 const DEFAULT_PATH = "pi-plus-oauth-accounts.json";
 const fileCache = new Map<string, OAuthPoolFile>();
 
@@ -52,7 +51,10 @@ function loadFile(path = oauthPoolPath()): OAuthPoolFile {
   const cached = fileCache.get(path);
   if (cached) return cached;
 
-  const raw = readJson<Partial<OAuthPoolFile>>(path, EMPTY_FILE);
+  // The fallback is built per call: a shared constant would be aliased into
+  // `file.providers` whenever the file is missing, and every later write would
+  // accumulate in it — outliving both the cache and the file itself.
+  const raw = readJson<Partial<OAuthPoolFile>>(path, { version: 1, providers: {} });
   const file: OAuthPoolFile = {
     version: 1,
     providers: raw.providers && typeof raw.providers === "object" ? raw.providers : {},

package/src/core/accounts/registry.ts

@@ -16,9 +16,14 @@ export interface ManagedAccount {
 /** Fixed account order or provider quota-aware selection. */
 export type RoutingMode = "sequential" | "quota-aware";
 
+/** Dismisses a dialog programmatically, e.g. a paste prompt once the browser callback wins. */
+export interface AccountDialogOptions {
+  signal?: AbortSignal;
+}
+
 export interface AccountUi {
-  input(title: string, placeholder?: string): Promise<string | undefined>;
-  select(title: string, options: string[]): Promise<string | undefined>;
+  input(title: string, placeholder?: string, options?: AccountDialogOptions): Promise<string | undefined>;
+  select(title: string, options: string[], dialog?: AccountDialogOptions): Promise<string | undefined>;
   confirm(title: string, message: string): Promise<boolean>;
   notify(message: string, type?: "info" | "warning" | "error"): void;
 }

package/src/core/anthropic/catalog.ts

@@ -0,0 +1,139 @@
+import { agentPath, readJson, writeJson } from "../store.ts";
+
+/**
+ * Live Anthropic model list.
+ *
+ * pi's bundled catalogue is generated at build time, so a model Anthropic
+ * ships afterwards is invisible to pi until pi is upgraded — `claude-opus-5-5`
+ * was usable for days while the picker denied it existed. Claude Code does not
+ * have that problem because it asks the API.
+ *
+ * `GET /v1/models` returns identity only (`id`, `display_name`), never limits
+ * or pricing, so a discovered model still needs those filled in. They are
+ * inherited from the newest model of the same family in pi's catalogue rather
+ * than invented here — see `models.ts`.
+ *
+ * The result is cached on disk so the picker is correct on the very first
+ * render, before any network call has finished.
+ */
+
+const CACHE_FILE = "anthropic-models.json";
+/** Re-ask once a day; a new model is news, not an emergency. */
+export const CATALOG_TTL_MS = 24 * 60 * 60 * 1000;
+
+export interface LiveModel {
+  id: string;
+  displayName?: string;
+}
+
+interface CacheFile {
+  version: 1;
+  fetchedAt: number;
+  models: LiveModel[];
+}
+
+const EMPTY: CacheFile = { version: 1, fetchedAt: 0, models: [] };
+
+export function catalogPath(): string {
+  return process.env.PI_PLUS_ANTHROPIC_MODELS_FILE ?? agentPath(CACHE_FILE);
+}
+
+function load(): CacheFile {
+  const raw = readJson<Partial<CacheFile>>(catalogPath(), { ...EMPTY });
+  return {
+    version: 1,
+    fetchedAt: typeof raw.fetchedAt === "number" ? raw.fetchedAt : 0,
+    models: Array.isArray(raw.models)
+      ? raw.models.filter((model): model is LiveModel => typeof model?.id === "string" && model.id.length > 0)
+      : [],
+  };
+}
+
+/** Last known live list. Empty before the first successful fetch. */
+export function cachedAnthropicModels(): LiveModel[] {
+  return load().models;
+}
+
+export function catalogIsStale(now = Date.now()): boolean {
+  return now - load().fetchedAt > CATALOG_TTL_MS;
+}
+
+/** Test seam and reset path. */
+export function writeAnthropicCatalog(models: LiveModel[], fetchedAt = Date.now()): void {
+  writeJson(catalogPath(), { version: 1, fetchedAt, models } satisfies CacheFile, true);
+}
+
+interface ModelsResponse {
+  data?: { id?: string; display_name?: string }[];
+}
+
+/**
+ * Asks Anthropic what this credential can actually use.
+ *
+ * `auth` comes from pi's resolved provider auth, so an OAuth subscription and
+ * a plain API key both work and the token is already refreshed.
+ */
+export interface ResolvedAnthropicAuth {
+  apiKey?: string;
+  headers?: Record<string, string | null>;
+  baseUrl?: string;
+  /** pi reports "OAuth" for a subscription credential. */
+  source?: string;
+}
+
+/**
+ * Only a real API key goes in `x-api-key`; everything else is a bearer token.
+ *
+ * A prefix test alone is a trap: an Anthropic *OAuth* token is `sk-ant-oat…`
+ * and an API key is `sk-ant-api…`, so checking for `sk-` routes subscription
+ * tokens into the wrong header and the endpoint answers 401.
+ */
+function usesApiKeyHeader(auth: ResolvedAnthropicAuth): boolean {
+  if (auth.source === "OAuth") return false;
+  return (auth.apiKey ?? "").startsWith("sk-ant-api");
+}
+
+export async function fetchAnthropicModels(
+  auth: ResolvedAnthropicAuth,
+  signal?: AbortSignal,
+): Promise<LiveModel[]> {
+  const headers: Record<string, string> = { "anthropic-version": "2023-06-01" };
+  for (const [key, value] of Object.entries(auth.headers ?? {})) {
+    if (value !== null) headers[key] = value;
+  }
+
+  if (auth.apiKey) {
+    if (usesApiKeyHeader(auth)) headers["x-api-key"] = auth.apiKey;
+    else headers.Authorization = `Bearer ${auth.apiKey}`;
+  }
+  // Exactly this one beta. The model list rejects the request when the
+  // Claude Code betas meant for /v1/messages are carried over.
+  headers["anthropic-beta"] = "oauth-2025-04-20";
+
+  const base = (auth.baseUrl || "https://api.anthropic.com").replace(/\/+$/, "");
+  const response = await fetch(`${base}/v1/models?limit=200`, { headers, signal });
+  if (!response.ok) {
+    throw new Error(`Anthropic model list failed: ${response.status} ${response.statusText}`);
+  }
+
+  const body = (await response.json()) as ModelsResponse;
+  return (body.data ?? [])
+    .filter((model) => typeof model?.id === "string" && model.id.length > 0)
+    .map((model) => ({ id: model.id!, ...(model.display_name && { displayName: model.display_name }) }));
+}
+
+/**
+ * Refreshes the cache. Returns the ids that were not already known, so a
+ * caller can decide whether re-registering the provider is worth it.
+ */
+export async function refreshAnthropicCatalog(
+  auth: ResolvedAnthropicAuth,
+  signal?: AbortSignal,
+): Promise<string[]> {
+  const before = new Set(cachedAnthropicModels().map((model) => model.id));
+  const models = await fetchAnthropicModels(auth, signal);
+  if (models.length === 0) return [];
+
+  writeAnthropicCatalog(models);
+  return models.map((model) => model.id).filter((id) => !before.has(id));
+}

package/src/core/anthropic/client-identity.ts

@@ -8,7 +8,7 @@ import { xxhash64 } from "./xxhash64.ts";
  */
 
 /** Pinned to the Claude Code release being imitated. */
-export const CLAUDE_CODE_VERSION = "2.1.258";
+export const CLAUDE_CODE_VERSION = "2.1.280";
 
 /** Claude Code checksum constants. They can change between CLI releases. */
 const CCH_SEED = 0x4d659218e32a3268n;
@@ -163,12 +163,31 @@ export function selectBetas(body: unknown, extra: string[] = []): string {
 }
 
 /** Headers presenting this client as Claude Code. */
-export function clientIdentityHeaders(body?: unknown, existingBetas?: string): Record<string, string> {
-  const incoming = (existingBetas ?? "").split(",").map((b) => b.trim()).filter(Boolean);
+/**
+ * Betas this identity adds, on top of whatever pi computed for the model.
+ *
+ * These must be *merged*, never substituted. pi enables model-specific betas
+ * that authorise fields it also emits — `mid-conversation-output-config-…`
+ * covers the `output_config` system messages it inserts for adaptive-effort
+ * models. Replacing the list leaves those messages in the body with nothing
+ * permitting them, and Anthropic rejects the request:
+ *
+ *     messages.1.output_config: Extra inputs are not permitted
+ *
+ * which is a 400 on every Opus 5 request and reads like a pi bug.
+ */
+export function identityBetas(body?: unknown, existing: readonly string[] = []): string[] {
+  return [...new Set([...existing.map((beta) => beta.trim()).filter(Boolean), ...selectBetas(body).split(",")])];
+}
+
+/**
+ * Deliberately omits `anthropic-beta`. pi copies that header verbatim into the
+ * request body's `betas`, so setting it here would discard pi's own list; the
+ * merge happens per request through {@link identityBetas} instead.
+ */
+export function clientIdentityHeaders(): Record<string, string> {
   return {
     "user-agent": USER_AGENT,
-    // Pi copies this header into the request body's betas field.
-    "anthropic-beta": selectBetas(body, incoming),
     "anthropic-version": "2023-06-01",
     "anthropic-dangerous-direct-browser-access": "true",
     "x-app": "cli",

package/src/core/anthropic/models.ts

@@ -1,9 +1,23 @@
+import type { Model } from "@earendil-works/pi-ai";
+import { ANTHROPIC_MODELS as PI_ANTHROPIC_MODELS } from "@earendil-works/pi-ai/providers/anthropic.models";
+import { cachedAnthropicModels, type LiveModel } from "./catalog.ts";
+
 /**
  * Anthropic model catalogue.
  *
- * These are the models pi's built-in catalogue does not carry (or carries with
- * stale pricing). Extracted so the provider definition lives here rather than
- * in a dependency.
+ * Three sources, in increasing authority:
+ *
+ *   1. pi's bundled catalogue — complete metadata, but generated at build time
+ *      and therefore always a little behind Anthropic.
+ *   2. the live `/v1/models` list cached by `catalog.ts` — authoritative about
+ *      which models exist, silent about their limits.
+ *   3. local corrections and additions, for the handful of things pi has
+ *      wrong or has never carried.
+ *
+ * The merge has to be a superset of pi's list.
+ * `registerProvider("anthropic", { models })` *substitutes* the catalogue
+ * rather than extending it, so anything omitted here vanishes from the picker
+ * with no error at all.
  */
 
 export const FABLE_CONTEXT_WINDOW = 1_000_000;
@@ -31,39 +45,107 @@ const fable = (id: string, name: string, pricing = FABLE_PRICING): ModelSpec =>
   contextWindow: FABLE_CONTEXT_WINDOW, maxTokens: FABLE_MAX_OUTPUT,
 });
 
-export const ANTHROPIC_MODELS: ModelSpec[] = [
+/** Models neither pi nor the live list carries. */
+const ADDITIONS: ModelSpec[] = [
   fable("claude-fable-5", "Claude Fable 5"),
   fable("claude-mythos-5", "Claude Mythos 5"),
   fable("claude-fable-5-1", "Claude Fable 5.1", FABLE_5_1_PRICING),
   fable("claude-mythos-5-1", "Claude Mythos 5.1", FABLE_5_1_PRICING),
-  {
-    id: "claude-opus-5", name: "Claude Opus 5", reasoning: true, input: textImage,
+];
+
+/**
+ * Applied on top of pi's entry for the same id. Only the listed fields change;
+ * everything else pi knows (thinking levels, input limits, cache tiers) stays.
+ */
+const CORRECTIONS: Record<string, Partial<ModelSpec>> = {
+  "claude-opus-5": {
     cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
     contextWindow: 1_000_000, maxTokens: 128_000,
   },
-  {
-    id: "claude-opus-4-8", name: "Claude Opus 4.8", reasoning: true, input: textImage,
+  "claude-opus-4-8": {
     cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
     contextWindow: 1_000_000, maxTokens: 128_000,
   },
-  {
-    id: "claude-opus-4-5", name: "Claude Opus 4.5", reasoning: true, input: textImage,
-    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-    contextWindow: 200_000, maxTokens: 64_000,
-  },
-  {
-    id: "claude-sonnet-5", name: "Claude Sonnet 5", reasoning: true, input: textImage,
+  "claude-sonnet-5": {
     cost: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 },
     contextWindow: 1_000_000, maxTokens: 128_000,
   },
-  {
-    id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5", reasoning: true, input: textImage,
-    cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-    contextWindow: 200_000, maxTokens: 64_000,
-  },
-  {
-    id: "claude-haiku-4-5", name: "Claude Haiku 4.5", reasoning: false, input: textImage,
-    cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
-    contextWindow: 200_000, maxTokens: 64_000,
-  },
-];
+};
+
+type AnthropicModel = Model<"anthropic-messages">;
+
+/** `claude-opus-5-5` -> `opus`; undated ids only, so aliases do not win below. */
+function familyOf(id: string): string | undefined {
+  return /^claude-([a-z]+)-\d/.exec(id)?.[1];
+}
+
+/** `claude-opus-5-5` -> [5, 5]. A dated alias sorts below its undated form. */
+function versionOf(id: string): number[] {
+  const tail = /^claude-[a-z]+-(.+)$/.exec(id)?.[1] ?? "";
+  // A date suffix (20251101) is a release stamp, not a version component.
+  return tail.split("-").filter((part) => /^\d+$/.test(part) && part.length < 5).map(Number);
+}
+
+function isNewer(candidate: string, incumbent: string): boolean {
+  const left = versionOf(candidate);
+  const right = versionOf(incumbent);
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const a = left[i] ?? -1;
+    const b = right[i] ?? -1;
+    if (a !== b) return a > b;
+  }
+  return false;
+}
+
+/** Title-case a display name when Anthropic did not send one. */
+function nameFor(model: LiveModel): string {
+  if (model.displayName) return model.displayName;
+  const family = familyOf(model.id) ?? "";
+  const version = versionOf(model.id).join(".");
+  const pretty = family ? family[0].toUpperCase() + family.slice(1) : model.id;
+  return version ? `Claude ${pretty} ${version}` : `Claude ${pretty}`;
+}
+
+const base = Object.values(PI_ANTHROPIC_MODELS as unknown as Record<string, AnthropicModel>);
+
+/**
+ * Newest model per family, used as the template for a model the live list
+ * reports but pi has never seen. Inheriting beats guessing: a new Opus gets
+ * the current Opus's context window, output cap, thinking levels and pricing,
+ * and those track pi upgrades automatically.
+ */
+function templates(models: AnthropicModel[]): Map<string, AnthropicModel> {
+  const newest = new Map<string, AnthropicModel>();
+  for (const model of models) {
+    const family = familyOf(model.id);
+    if (!family) continue;
+    const incumbent = newest.get(family);
+    if (!incumbent || isNewer(model.id, incumbent.id)) newest.set(family, model);
+  }
+  return newest;
+}
+
+/** pi's catalogue, corrected, plus anything the live list knows about that pi does not. */
+export function buildAnthropicModels(live: LiveModel[] = cachedAnthropicModels()): ModelSpec[] {
+  const corrected = base.map((model) => ({ ...model, ...CORRECTIONS[model.id] })) as AnthropicModel[];
+  const known = new Set(corrected.map((model) => model.id));
+  const byFamily = templates(corrected);
+
+  const discovered: AnthropicModel[] = [];
+  for (const model of live) {
+    if (known.has(model.id)) continue;
+    const template = byFamily.get(familyOf(model.id) ?? "");
+    if (!template) continue; // An unrecognised family has nothing safe to inherit.
+    known.add(model.id);
+    discovered.push({ ...template, id: model.id, name: nameFor(model) });
+  }
+
+  return [
+    ...corrected,
+    ...discovered,
+    ...ADDITIONS.filter((model) => !known.has(model.id)),
+  ] as unknown as ModelSpec[];
+}
+
+/** Snapshot taken at load; `refreshAnthropicModels()` re-registers on change. */
+export const ANTHROPIC_MODELS: ModelSpec[] = buildAnthropicModels();

package/src/core/config.ts

@@ -28,7 +28,7 @@ export interface PiPlusConfig {
 const DEFAULTS: PiPlusConfig = {
   env: {},
   policy: {
-    autoApprove: ["anthropic/*", "openai-codex/*", "kimi-coding/*", "xai/*"],
+    autoApprove: ["anthropic/*", "openai-codex/*", "gemini/*", "kimi-coding/*", "xai/*"],
     requireApproval: ["openrouter/*", "google/*", "openai/*"],
     deny: [],
   },

package/src/core/gemini/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rahul Arya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.