@byokit/accounts 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 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)
+
+
+
+- Add optional `parallelToolCalls` to `respond` and `Accounts.respond`, passed through to ChatGPT as `parallel_tool_calls`; omitted keeps the provider default.
+
 ## 0.10.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.
 ```
@@ -260,6 +262,11 @@ already have shown partial words. This covers `response.incomplete` events and `
 whether fetch streams SSE, buffers it, or returns JSON. The account stays signed in and is not put to rest.
 Successful return values are unchanged.
 
+Set `parallelToolCalls: false` to request one tool call at a time; `true` allows parallel calls. Both pass through as
+`parallel_tool_calls`; omitting it sends nothing and keeps the provider default. `respond` supports only the ChatGPT
+subscription route; OpenRouter, Grok and Copilot are credential routes without `respond` support, and there is no
+Anthropic response route.
+
 The whole question passes through: `input` takes the turns so far (messages, with `input_image` where the person
 attached a picture), `tools` and `tool_choice` take the app's own function tools and built-ins (including
 `image_generation`), `reasoning.effort` how hard the model thinks, and `text` how long the answer is with the shape it
@@ -344,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
@@ -361,3 +372,120 @@ in N min/hours", and zero otherwise. For resting kinds, use
 `failure.until || nowMs + REST_MS[failure.kind]`; signed-out, not-included and network
 failures have no fallback rest. `classify` remains an alias. Pass a clock for deterministic
 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.

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;
@@ -125,21 +139,48 @@ export declare class Accounts<R extends AuthHost = AuthHost, M extends Member =
     forget(member: M, key: string): void;
     /** 0 when the account is available; otherwise when it stops resting. */
     restingUntil(member: M, key: string): number;
-    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
-     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
-     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
-     *  or null for an error that is not about the account; `network` changes nothing. */
+    /** Fresh ChatGPT access for a host-side capability. Never send this to another device. */
+    access(member: M, signal?: AbortSignal): Promise<{
+        access: string;
+        accountId: string;
+    }>;
     /** Ask ChatGPT with this member's own sign-in, the answer streaming into `onText`; refreshed first when due. A
      *  failure about the account (a limit, a lapsed sign-in) is acted on as `failed()` does, then thrown as a
      *  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>;
     respond(member: M, ask: Ask & {
         tools: ResponseTool[];
     }): Promise<ResponseResult>;
+    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
+     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
+     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
+     *  or null for an error that is not about the account; `network` changes nothing. */
     failed(member: M, key: string, error: string | ResponseError): Promise<import("./limits.ts").Failure | null>;
     /** The first choice whose account is neither resting nor known to be unusable: the fallback ladder. */
     ladder<T>(member: M, choices: readonly T[], key?: (c: T) => string): T | undefined;

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),
         }));
     }
@@ -228,7 +232,9 @@ export class Accounts {
         const r = this.rests.get(`${member}:${key}`);
         return r && r.until > Date.now() ? r.until : 0;
     }
-    async respond(member, ask) {
+    /** Fresh ChatGPT access for a host-side capability. Never send this to another device. */
+    async access(member, signal) {
+        signal?.throwIfAborted();
         const key = 'chatgpt';
         const p = this.offer(key);
         const rt = await this.runtime(member);
@@ -247,8 +253,53 @@ export class Accounts {
         const c = await rt.readCredential(p.pi).catch(() => undefined);
         if (!access || c?.type !== 'oauth')
             throw new ResponseError(say('status.signedOut', { name: p.name }), 'signed_out');
+        signal?.throwIfAborted();
+        return { access, accountId: String(c.accountId ?? '') };
+    }
+    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);
         try {
-            const base = { ...ask, access, accountId: String(c.accountId ?? ''), model: ask.model ?? p.models.strong, base: this.opts.apiBase, fetch: this.opts.fetch, originator: ask.originator ?? this.opts.originator };
+            const base = { ...ask, access, accountId, model: ask.model ?? p.models.strong, base: this.opts.apiBase, fetch: this.opts.fetch, originator: ask.originator ?? this.opts.originator };
             return ask.tools ? await respond({ ...base, tools: ask.tools }) : await respond({ ...base, tools: undefined });
         }
         catch (e) {
@@ -260,6 +311,10 @@ export class Accounts {
             throw e;
         }
     }
+    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
+     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
+     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
+     *  or null for an error that is not about the account; `network` changes nothing. */
     async failed(member, key, error) {
         const c = error instanceof ResponseError ? error.kind && { kind: error.kind, until: error.until } : classify(error);
         if (!c || c.kind === 'network')
@@ -300,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)
@@ -366,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;