@byokit/accounts 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.13.0 (2026-10-01)
+
+
+
+- Add portable, choose-once multi-account selection with most-room ordering, unknown room above exhausted, and secret-free candidate explanations. Auto and default fallback use subscription accounts only; an API key (billed per use) must be explicitly selected.
+- Export roomOf and roomWords, shared Auto conformance fixtures, and descriptive multi-account terms data.
+
+## 0.12.0 (2026-09-30)
+
+
+
+- FIX: fileStore verifies optional sealing-adapter upgrades and atomically replaces authenticated ciphertext on read, allowing opt-in dual-wrap migration without losing the original store on interruption.
+- Claude Pro/Max subscription PKCE sign-in, direct Messages and single-flight refresh with on-device credentials.
+
+- Anthropic Messages with an app-passed API key (billed per use), explicit model and opt-in; typed native requests, streamed text/tools/thinking/message events, usage/raw results and the shared IncompleteError contract for max_tokens/refusal (including with tools) on every platform.
 - Expose fresh subscription access to host-side capabilities using the app’s own sign-in.
 
 ## 0.11.0 (2026-09-30)

package/NOTICE

@@ -0,0 +1,30 @@
+BYOKit accounts implements the Claude manual OAuth protocol independently, informed by:
+
+Hermes Agent, Nous Research, copyright (c) 2025 Nous Research.
+https://github.com/NousResearch/hermes-agent/tree/57a22675ef9f7761111feba9d24e5c366db3134b
+agent/anthropic_credentials.py and agent/anthropic_adapter.py.
+
+oh-my-pi, copyright (c) 2025 Mario Zechner; 2025-2026 Can Bölük; 2026 Stencil Labs.
+https://github.com/can1357/oh-my-pi/tree/2b023d1b80133c523d66412602d99b5427408395
+packages/catalog/src/compat/rules/auth/anthropic.kdl, packages/ai/src/registry/engine/refresh.ts.
+
+These references are MIT licensed. No reference project's installed credential store or CLI is used.
+The following MIT notice is retained for protocol adaptations, including constants and request construction:
+
+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.

package/README.md

@@ -8,8 +8,8 @@
 </p>
 
 <p align="center"><strong>Sign in with the AI plan you already pay for, inside your own app.</strong><br/>
-ChatGPT on every platform; OpenRouter on computers when an app offers it (API billing, never by default); Grok and
-GitHub Copilot hidden by default. Sign-ins go into your app's own store: on a computer (Node, Electron), in a browser
+ChatGPT and Claude Pro/Max on every platform (Claude needs Web Crypto); OpenRouter on computers when an app offers it (API billing, never by default); Grok and
+GitHub Copilot hidden by default. Anthropic uses an app-passed API key (billed per use), explicitly opted in. Sign-ins go into your app's own store: on a computer (Node, Electron), in a browser
 (a PWA, Electron's renderer) and on a phone (React Native and Expo, iOS and Android). One import; your bundler picks
 the platform's side (`package.json`'s `react-native` and `browser` conditions).</p>
 
@@ -135,6 +135,8 @@ and [`examples/pwa`](../../examples/pwa) (browser sign-in).
 | | Computer (Node, Electron main) | Browser (PWA, Electron renderer) | Phone (React Native: iOS, Android) |
 |---|---|---|---|
 | ChatGPT (subscription) | Its own page, straight back to this computer (port 1455); a code when asked or stuck | Device code | Device code |
+| Claude Pro/Max (subscription) | Provider page, paste its code back | Same PKCE flow; token endpoint CORS required | Same PKCE flow; app supplies Web Crypto |
+| Anthropic (API key, billed per use) | App passes its own key, explicitly | Same fetch-only Messages provider | Same fetch-only Messages provider |
 | OpenRouter (API billing) | Its own page, back to this computer (Pi's flow), when an app offers it (never by default) | Not yet | Not yet |
 | Grok, Copilot (hidden) | Pi's flows | No | No |
 | Where sign-ins are kept | `fileStore(path, safeStorage)`, sealing required | `browserStore(name)` (IndexedDB) | `secureStore(SecureStore, name)` (Keychain, Keystore) |
@@ -152,7 +154,7 @@ doesn't answer other web pages), so a PWA's model calls go through the app's own
 platform are shown: OpenRouter is API-billed and never offered by default. An explicit list is not platform-filtered,
 so choose from the table above. Show `billingWords(p)` next to every provider you list.
 
-Claude plan sign-in is never offered: Anthropic reserves it for its own apps.
+Anthropic Messages uses an app-passed API key (billed per use), with explicit opt-in; its authentication is separate from the Messages request.
 
 ```ts
 import { Accounts, billingWords, offered } from '@byokit/accounts';
@@ -162,7 +164,7 @@ for (const p of offered(['chatgpt', 'openrouter'])) console.log(`${p.name}: ${bi
 ```
 
 ```text
-[ 'chatgpt' ]
+[ 'chatgpt', 'claude' ]
 ChatGPT: Uses your ChatGPT plan.
 OpenRouter: Charged per use to your OpenRouter account, not a plan.
 ```
@@ -349,6 +351,10 @@ and the Linux `basic_text` backend. Other adapters must protect their keys outsi
 file and provide authenticated encryption. For a Node service, use a host-owned keystore through
 `recordStore(load, save)`, or provide an equivalent sealing adapter; the kit never discovers a key
 or invokes an OS keyring itself. Use `memoryStore()` for temporary sign-ins.
+If the adapter exposes optional `upgrade(bytes)`, a read validates the decrypted record, verifies
+that upgraded ciphertext decrypts to identical text and atomically replaces the original. This
+supports opt-in dual-wrap migration through `@byokit/secrets`; a failed replacement leaves the
+original envelope usable. Hold the host writer lock for read upgrades as well as ordinary writes.
 
 Use an app-owned directory: the immediate folder must be a real 0700 directory and credential
 files must be private regular files. Reuse one store instance for each path; a host lock is required
@@ -368,3 +374,180 @@ failures have no fallback rest. `classify` remains an alias. Pass a clock for de
 classification; the default uses `Date.now()`. It stores and logs no error text.
 
 For a capability running where the sign-in lives, `await accounts.access(member, signal)` returns fresh `{ access, accountId }` from the app’s own ChatGPT store. Keep these credentials in that process; proxy signaling or relay media for another device. This uses the same refresh and signed-out behavior as `respond`.
+
+## Anthropic Messages: API key (billed per use)
+
+This route is never a default or a subscription fallback. The app supplies the key and an explicit model.
+The kit never reads keys from environment variables, files or another tool's sign-in.
+
+```ts
+import { anthropic, AnthropicIncompleteError } from '@byokit/accounts';
+
+export async function askClaude(appKey: string, show: (text: string) => void) {
+  const claude = anthropic({ key: appKey });
+  try {
+    const answer = await claude.respond({
+      model: 'claude-opus-5-5', max_tokens: 1024,
+      system: 'Be brief.', messages: [{ role: 'user', content: 'Hello' }],
+      result: true, onText: (delta) => show(delta),
+    });
+    // answer.text, answer.output, answer.usage, answer.raw
+  } catch (error) {
+    if (error instanceof AnthropicIncompleteError) {
+      show(error.reason); // error.result carries partial text/output, usage and native raw response
+    } else throw error;
+  }
+}
+```
+
+Native `system`, `messages` (images, thinking, tool calls/results), `tools`, `tool_choice`, `thinking`,
+`max_tokens`, `stop_sequences`, `metadata`, sampling and `output_config` pass through unchanged.
+`onEvent` carries text deltas, tool JSON deltas, completed tools/content blocks, message events and an
+incomplete event for `max_tokens` or `refusal`. A stream without `message_stop` fails. With `tools` or
+`result: true`, the result carries metadata; without either, it returns text. Incomplete answers always
+throw the shared `IncompleteError` contract (the `AnthropicIncompleteError` subtype retains typed native
+metadata), including with tools or `result: true`. Call `isFunctionCall` on normalized `output` items; use native `raw.content` for the next Messages turn.
+
+The catalogue's `label` is exactly `API key (billed per use)`; show it when presenting the explicit key route.
+`billingWords` also supplies the existing plain sentence about per-use charges.
+
+An `Accounts` instance can also use this route, with `offer: ['anthropic']` and
+`accounts.respond(member, { provider: 'anthropic', key: appKey, model, max_tokens, messages, result: true })`.
+The key is used for that request, never stored by the kit; `login` does not launch a plan flow for this route.
+
+The existing `@byokit/decide` seam accepts it without a new dependency:
+
+```ts
+import { anthropic } from '@byokit/accounts';
+import { answerer } from '@byokit/decide';
+
+export function claudeBackend(appKey: string) {
+  const claude = anthropic({ key: appKey });
+  return answerer({ name: 'anthropic', leaves: true,
+    ask: (prompt, signal) => claude.respond({
+      model: 'claude-opus-5-5', max_tokens: 2048, signal,
+      messages: [{ role: 'user', content: prompt }],
+    }),
+  });
+}
+```
+
+An incomplete answer throws through this text seam, so decide abstains rather than parsing a partial answer.
+Browser apps should keep the API key in an app-owned server proxy (`base`); React Native can pass a streaming
+fetch such as Expo's. `betas` explicitly opts into native beta headers.
+
+## Claude Pro/Max subscription
+
+Anthropic's [developer guidance](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use) prohibits third-party Claude.ai login without approval; BYOKit has no approval, and this route may stop working or lead to account restrictions (the separately billed API-key route is the documented alternative).
+
+Claude is available by default. Open its page, then paste the returned `code#state` into the app:
+
+```ts
+import { Accounts, memoryStore } from '@byokit/accounts';
+
+const member = 1;
+const credentials = memoryStore(); // replace with device-owned persistent storage in your app
+const accounts = new Accounts({ store: () => credentials });
+const pastedCode = 'code#state'; // collect the actual returned value from the person
+const pending = await accounts.login(member, 'claude');
+// Open pending.url in the person's browser, then collect the code from that page.
+accounts.paste(member, 'claude', pastedCode);
+await accounts.finished(member, 'claude');
+const text = await accounts.respond(member, {
+  provider: 'claude', model: 'claude-opus-5-5', max_tokens: 1024,
+  messages: [{ role: 'user', content: 'Hello' }],
+});
+```
+
+The manual HTTPS callback works without a local listener or an installed CLI. It uses PKCE (secure random verifier,
+SHA-256 challenge), independent state, strict `code#state` validation, and direct JSON exchange/refresh at
+`platform.claude.com/v1/oauth/token`. Refresh is single-flight for one store, saves an attempt before sending and commits the rotated credentials before
+returning access. An omitted replacement requires sign-in again. `ClaudePlanExpiredError` means sign in again, including after a refused or uncertain rotation or a
+failed durable save; a persisted attempt prevents replay after restart. A custom store must provide the refresh transaction seam (use
+`recordStore(load, save)`); a host lock is required for multiple processes. Local logout removes only this app's credentials; it does not promise server
+revocation. A Messages authentication refusal requests re-authentication without replaying the request or switching
+billing to an API key.
+
+Tokens belong in one device-owned `CredentialStore` per member. `keystoreStore(hostKeystore, 'member.1')` adapts
+`@byokit/secrets` without importing Node into the portable entry. Electron can pass safeStorage to `fileStore`;
+its sealed file writes atomically with mode 0600; a sealing adapter is required. Use one process per file (or a host-supplied cross-process lock).
+Phones use `secureStore` with device-only accessibility. PWA `browserStore` uses IndexedDB and Web Locks; page
+scripts can read its credentials. Tokens are never collected by a BYOKit server or logged. The default is memory-only.
+
+React Native hosts pass `claudePlan: { crypto: webCrypto }` when global Web Crypto is unavailable;
+`ClaudePlanPlatformError` reports missing secure randomness/SHA-256. Browsers require the provider token endpoint's
+CORS support; a network/CORS failure stays on-device and does not trigger a proxy. Browser User-Agent restrictions
+can affect compatibility. Tests replay protocol-shaped captures offline; no live OAuth, CORS, or current inference
+compatibility is claimed. This implementation supplies the manual-flow headers and Claude Code identity prelude,
+without relying on Pi's provider or executing an installed Claude CLI.
+
+Protocol references: [Hermes credentials at 57a22675, PKCE/exchange](https://github.com/NousResearch/hermes-agent/blob/57a22675ef9f7761111feba9d24e5c366db3134b/agent/anthropic_credentials.py#L747),
+[Hermes headers/identity](https://github.com/NousResearch/hermes-agent/blob/57a22675ef9f7761111feba9d24e5c366db3134b/agent/anthropic_adapter.py#L219),
+[oh-my-pi auth rule at 2b023d1b](https://github.com/can1357/oh-my-pi/blob/2b023d1b80133c523d66412602d99b5427408395/packages/catalog/src/compat/rules/auth/anthropic.kdl#L1),
+and [oh-my-pi refresh](https://github.com/can1357/oh-my-pi/blob/2b023d1b80133c523d66412602d99b5427408395/packages/ai/src/registry/engine/refresh.ts#L62).
+The common route follows Hermes's platform token host, three scopes and `axios/1.7.9` token User-Agent,
+with inference `claude-code/2.1.74 (external, cli)`, `x-app: cli`, bearer authorization, Messages version
+`2023-06-01` and betas `claude-code-20250219,oauth-2025-04-20`. The implementation is independent;
+[NOTICE](NOTICE) records the MIT protocol references.
+
+## Choosing between accounts
+
+The portable entry exports `chooseAccount`, `resolveSelection`, `roomOf`, `roomWords` and the structural
+`AccountLike`, `AccountPick`, `Room`, `Considered`, `RunSelection` and `Defaults` types. The host supplies its own
+account records and readings; these functions never read credentials, sign in, refresh, start a run or switch a
+running conversation. Resolve once before starting and keep the selected account for the whole run.
+
+```ts
+import { resolveSelection, roomOf, type AccountLike, type Defaults } from '@byokit/accounts';
+
+// Host-provided account, model and measurement accessors:
+declare const accounts: readonly AccountLike[];
+declare const defaults: Defaults;
+declare function windowsFor(account: AccountLike, demand: readonly string[]):
+  { usedPercent: number; kind: string; resetsAt?: number }[];
+declare function measuredAt(account: AccountLike): number | undefined;
+declare function modelsFor(account: AccountLike): { id: string; available: boolean }[];
+declare function startRunWith(account: AccountLike, model: string): void;
+
+const pick = resolveSelection(accounts, defaults, { account: 'auto', needs: ['provider/model'] },
+  (account, demand) => roomOf(windowsFor(account, demand), measuredAt(account), 'milliseconds'), Date.now(),
+  (account) => modelsFor(account));
+if (pick.ok) startRunWith(pick.account, pick.model);
+```
+
+Auto uses ready subscription accounts (including a rest whose deadline has elapsed). It ranks usable readings
+by most room, earlier refill, then list order; unknown readings follow; exhausted accounts refill first. A reading
+older than 24 hours counts as unknown. A numeric reading without a measurement time retains its room tier,
+with unknown age/confidence. Explicit account ids bypass state and billing filtering: the host must verify the
+selected account is ready before starting, and a failed explicit selection never falls back to another account.
+API key accounts (billed per use) are used only when explicitly selected by id or a ready default.
+
+`sel.model` and deduplicated `sel.needs` form the demand passed to the room reader. Supply `models` to verify
+every demanded model is available. Without it, the host owns model eligibility; `model` is the explicit or default
+model, or an empty string when neither is provided. With a model list, no available model returns `not_included`.
+Without a demand, selection stays within the default account's provider, or the first provider in list order.
+
+Each pick includes every account's `considered` row in list order. It holds only ids, exclusion/ranking codes,
+room figures, measurement age and confidence (`known`, `stale`, `unknown`); no names, emails, credential fields
+or engine messages are copied. The winning row's `reason` is the pick's `why`; other candidate reasons describe
+the deterministic comparison to the Auto winner. Excluded rows carry their first exclusion code. Account ids
+and model ids supplied by the host must themselves be secret-free. The generic returned `account` is the original
+host record: keep credentials outside that record before exposing the whole pick to UI or logs.
+
+`AccountLike.until`, `nowMs`, `Room.at`, `Room.resetsAt` and `Considered.age` use **milliseconds**.
+`roomOf(windows, at, resetUnit?)` accepts structural windows. Legacy reset **epoch seconds** are the default,
+converted by 1000 exactly once. For normalized `@byokit/usage` 0.2.0+ windows, pass `'milliseconds'` as the
+third argument; reset times then stay unchanged. A normalized usage `Room` also passes directly to the chooser.
+The optional `at` is always the original measurement time in epoch milliseconds.
+The current structural input contains `usedPercent`, `kind`, and optional `resetsAt`; hard-limit/model-scope and
+poll-health ingestion is a follow-up to the pending usage extension. Hosts must supply demand-filtered windows
+and authoritative eligibility rather than interpreting an unavailable quota reading as a fresh successful read.
+
+`Provider.multiAccount` gives a terms assessment, reason and source for multiple accounts of that service.
+A grey assessment records missing explicit documentation; it does not gate selection. `auto.terms`, `auto.*`,
+`room.*` and `pick.*` words are exported in `WORDS`.
+
+Identity and re-authentication stay with the host's canonical device store or engine. A provider account id
+scoped by member/provider proves identity; names and emails do not. The TypeScript identity fixture records
+wrong-account, duplicate identity, changed-email, absent-identity, removal/refresh and extension-field boundaries
+for runtime integration; the chooser consumes host-validated state and never adopts credentials itself.

package/dist/accounts.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialStore, Models } from '@earendil-works/pi-ai';
+import { type ClaudePlanOptions } from './claude-plan.ts';
+import { type AnthropicAsk, type AnthropicResult, type AnthropicTool } from './anthropic.ts';
 import { type Provider } from './catalogue.ts';
 import { ResponseError, type Ask, type ResponseResult, type ResponseTool } from './responses.ts';
 import { type EndingStore, type RefreshStore } from './stores.ts';
@@ -45,8 +47,15 @@ export type Platform = {
 };
 /** Phones and browsers: ChatGPT by device code, no listener. */
 export declare const portable: Platform;
+export type ClaudePlanAsk = AnthropicAsk & {
+    provider: 'claude';
+};
+export type AnthropicAccountAsk = AnthropicAsk & {
+    provider: 'anthropic';
+    key: string;
+};
 export type AccountsOptions<M extends Member = Member> = {
-    /** The accounts this app offers, in order. Default: every provider not hidden (ChatGPT, OpenRouter). */
+    /** The accounts this app offers, in order. Default: supported subscription providers not hidden. */
     offer?: readonly string[];
     /** Each member's own store. Default: in memory. */
     store?: (member: M) => CredentialStore;
@@ -64,6 +73,10 @@ export type AccountsOptions<M extends Member = Member> = {
     authBase?: string;
     /** Where ChatGPT answers `respond`, for a stand-in in tests and demos. */
     apiBase?: string;
+    /** Anthropic Messages origin: an app-owned proxy or stand-in. */
+    anthropicBase?: string;
+    /** Claude PKCE transport and Web Crypto supplied by the app (React Native). */
+    claudePlan?: ClaudePlanOptions;
     /** The fetch `respond` asks with: one that streams on a phone (Expo's `expo/fetch`). Default: the platform's. */
     fetch?: typeof fetch;
     /** The originator header `respond` sends. Default: 'byokit'. */
@@ -80,6 +93,7 @@ export declare class Accounts<R extends AuthHost = AuthHost, M extends Member =
     private opts;
     private runtimes;
     private stores;
+    private baseStores;
     private generations;
     private signals;
     private chains;
@@ -135,6 +149,28 @@ export declare class Accounts<R extends AuthHost = AuthHost, M extends Member =
      *  ResponseError with the words to show. Without `tools` the answer is the plain text, as before: pass `input` as
      *  words or as turns (messages with `input_image`, then the `function_call` with its `function_call_output`). With
      *  `tools` it is the text with every output item, and `onEvent` sees each tool call as it lands. */
+    respond(member: M, ask: ClaudePlanAsk & {
+        result: true;
+    }): Promise<AnthropicResult>;
+    respond(member: M, ask: ClaudePlanAsk & {
+        tools: AnthropicTool[];
+    }): Promise<AnthropicResult>;
+    respond(member: M, ask: ClaudePlanAsk & {
+        tools?: undefined;
+        result?: false;
+    }): Promise<string>;
+    respond(member: M, ask: ClaudePlanAsk): Promise<string | AnthropicResult>;
+    respond(member: M, ask: AnthropicAccountAsk & {
+        result: true;
+    }): Promise<AnthropicResult>;
+    respond(member: M, ask: AnthropicAccountAsk & {
+        tools: AnthropicTool[];
+    }): Promise<AnthropicResult>;
+    respond(member: M, ask: AnthropicAccountAsk & {
+        tools?: undefined;
+        result?: false;
+    }): Promise<string>;
+    respond(member: M, ask: AnthropicAccountAsk): Promise<string | AnthropicResult>;
     respond(member: M, ask: Ask & {
         tools?: undefined;
     }): Promise<string>;

package/dist/accounts.js

@@ -1,3 +1,5 @@
+import { CLAUDE_PLAN_ID, ClaudePlanExpiredError, claudePlanMessages, withClaudePlan } from "./claude-plan.js";
+import { anthropic } from "./anthropic.js";
 import { offered, provider } from "./catalogue.js";
 import { claims, PORTABLE, portableEngine } from "./engine.js";
 import { classify, REST_MS } from "./limits.js";
@@ -5,7 +7,7 @@ import { respond, ResponseError } from "./responses.js";
 import { memoryStore, refreshCredential } from "./stores.js";
 import { callbackPage, clock, failure, say, signInError } from "./words.js";
 /** Phones and browsers: ChatGPT by device code, no listener. */
-export const portable = { engine: (c, base) => portableEngine(c, { base }), signsIn: (pi) => PORTABLE.includes(pi) };
+export const portable = { engine: (c, base) => portableEngine(c, { base }), signsIn: (pi) => pi === CLAUDE_PLAN_ID || PORTABLE.includes(pi) };
 /** The ChatGPT plan behind a sign-in, from its own token: a work plan (Business, Enterprise, Edu) follows the employer's rules. */
 export function planOf(access) {
     let c = {};
@@ -30,6 +32,7 @@ export class Accounts {
     opts;
     runtimes = new Map();
     stores = new Map();
+    baseStores = new Map();
     generations = new Map();
     signals = new WeakMap();
     chains = new Map();
@@ -59,6 +62,7 @@ export class Accounts {
         let s = this.stores.get(String(member));
         if (!s) {
             const base = (this.opts.store ?? memoryStore)(member);
+            this.baseStores.set(String(member), base);
             let chain = Promise.resolve();
             const serial = (fn) => { const result = chain.then(fn); chain = result.catch(() => { }); return result; };
             s = {
@@ -172,7 +176,7 @@ export class Accounts {
     }
     engine(member, raw) {
         const credentials = this.boundStore(member, raw);
-        return Promise.resolve(Object.assign(this.platform.engine(credentials, this.opts.authBase), {
+        return Promise.resolve(Object.assign(withClaudePlan(this.platform.engine(credentials, this.opts.authBase), credentials, this.baseStores.get(String(member)) ?? raw, { ...this.opts.claudePlan, fetch: this.opts.claudePlan?.fetch ?? this.opts.fetch }), {
             credentialStore: credentials, readCredential: (id) => credentials.read(id),
         }));
     }
@@ -252,7 +256,45 @@ export class Accounts {
         signal?.throwIfAborted();
         return { access, accountId: String(c.accountId ?? '') };
     }
-    async respond(member, ask) {
+    async respond(member, query) {
+        const ask = query;
+        if ('provider' in query && query.provider === 'claude') {
+            this.offer('claude');
+            const rt = await this.runtime(member);
+            const { provider: _provider, ...request } = query;
+            let access;
+            try {
+                access = (await rt.getAuth(CLAUDE_PLAN_ID))?.auth?.apiKey;
+            }
+            catch (e) {
+                if (e instanceof ClaudePlanExpiredError) {
+                    this.forget(member, 'claude');
+                    this.onExpired?.(member, 'claude');
+                }
+                throw e;
+            }
+            if (!access)
+                throw new ClaudePlanExpiredError();
+            try {
+                return await claudePlanMessages(access, { fetch: this.opts.fetch }).respond(request);
+            }
+            catch (e) {
+                if (e instanceof ResponseError && e.kind === 'signed_out') {
+                    await this.logout(member, 'claude').catch(() => { });
+                    this.forget(member, 'claude');
+                    this.onExpired?.(member, 'claude');
+                    throw new ClaudePlanExpiredError();
+                }
+                if (e instanceof ResponseError && e.kind)
+                    await this.failed(member, 'claude', e);
+                throw e;
+            }
+        }
+        if ('provider' in query && query.provider === 'anthropic') {
+            this.offer('anthropic');
+            const { provider: _provider, key, ...request } = query;
+            return anthropic({ key, fetch: this.opts.fetch, base: this.opts.anthropicBase }).respond(request);
+        }
         const key = 'chatgpt';
         const p = this.offer(key);
         const { access, accountId } = await this.access(member);
@@ -313,7 +355,9 @@ export class Accounts {
      *  stalls times out; nothing is kept unless the engine then sees a working sign-in; every failure ends in one plain
      *  sentence. Returns as soon as there is a page to open or a code to show (or it is over); the rest carries on by itself. */
     async login(member, key, body = {}) {
-        this.offer(key);
+        const p = this.offer(key);
+        if (p.auth === 'api-key')
+            throw new Error('Use the app-provided API key (billed per use) to ask this provider.');
         const id = `${member}:${key}`;
         const pending = this.signingOut.get(id);
         if (pending)
@@ -379,7 +423,7 @@ export class Accounts {
             },
         });
         const timer = setTimeout(() => { flow.timedOut = true; flow.abort.abort(); }, this.opts.signInMs ?? 15 * 60_000);
-        const stuck = setTimeout(() => this.toCode(flow), this.opts.redirectMs ?? 3 * 60_000);
+        const stuck = p.key === 'claude' ? undefined : setTimeout(() => this.toCode(flow), this.opts.redirectMs ?? 3 * 60_000);
         // Listen where the provider sends the browser back (the engine then finds the port taken and waits to be handed the address).
         const port = p.callbackPort && (this.opts.callbackPort ?? p.callbackPort);
         const catcher = port && body.via !== 'code' && this.platform.loopback ? await this.catchRedirect(this.platform.loopback, flow, p.name, port).catch(() => null) : undefined;