@byokit/accounts 0.11.0 → 0.13.0

package/dist/claude-plan.d.ts

@@ -0,0 +1,51 @@
+import type { CredentialStore } from '@earendil-works/pi-ai';
+import type { AuthHost } from './accounts.ts';
+export declare const CLAUDE_PLAN_ID = "byokit-claude-plan";
+export declare const CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+/** A refused/uncertain rotation requires a new sign-in; its old refresh token must not be tried again. */
+export declare class ClaudePlanExpiredError extends Error {
+    readonly code = "CLAUDE_PLAN_EXPIRED";
+    readonly status = 401;
+    constructor();
+}
+export declare class ClaudePlanPlatformError extends Error {
+    readonly code = "CLAUDE_PLAN_UNSUPPORTED_PLATFORM";
+    constructor();
+}
+export type ClaudePlanOptions = {
+    fetch?: typeof fetch;
+    /** Stand-ins for offline tests. Production uses the Hermes-reference endpoints directly. */
+    authorizeUrl?: string;
+    tokenUrl?: string;
+    /** On React Native, pass a Web Crypto implementation supplied by the app. */
+    crypto?: Pick<Crypto, 'getRandomValues' | 'subtle'>;
+    now?: () => number;
+};
+/** Pending state/verifier never enter persistent storage. */
+export declare function claudeAuthorization(options?: ClaudePlanOptions): Promise<{
+    url: string;
+    verifier: string;
+    state: string;
+    redirect: string;
+}>;
+export declare function claudeCode(paste: string, state: string): string;
+/** Adds only BYOKit's own Claude route; every other provider still belongs to the supplied engine. */
+export declare function withClaudePlan(engine: AuthHost, credentials: CredentialStore, lockKey: CredentialStore, options?: ClaudePlanOptions): AuthHost;
+/** Hermes's baseline native-client fingerprint. No installed CLI is consulted for its version. */
+export declare function claudePlanMessages(access: string, options?: {
+    fetch?: typeof fetch;
+}): {
+    respond: {
+        (o: import("./anthropic.ts").AnthropicAsk & {
+            result: true;
+        }): Promise<import("./anthropic.ts").AnthropicResult>;
+        (o: import("./anthropic.ts").AnthropicAsk & {
+            tools: import("./anthropic.ts").AnthropicTool[];
+        }): Promise<import("./anthropic.ts").AnthropicResult>;
+        (o: import("./anthropic.ts").AnthropicAsk & {
+            tools?: undefined;
+            result?: false;
+        }): Promise<string>;
+        (o: import("./anthropic.ts").AnthropicAsk): Promise<string | import("./anthropic.ts").AnthropicResult>;
+    };
+};

package/dist/claude-plan.js

@@ -0,0 +1,167 @@
+import { anthropicMessages } from "./anthropic.js";
+import { needsReauth, refreshCredential } from "./stores.js";
+export const CLAUDE_PLAN_ID = 'byokit-claude-plan';
+export const CLAUDE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+const REDIRECT = 'https://console.anthropic.com/oauth/code/callback';
+const SCOPES = 'org:create_api_key user:profile user:inference';
+/** A refused/uncertain rotation requires a new sign-in; its old refresh token must not be tried again. */
+export class ClaudePlanExpiredError extends Error {
+    code = 'CLAUDE_PLAN_EXPIRED';
+    status = 401;
+    constructor() { super('Sign in with Claude again.'); this.name = 'ClaudePlanExpiredError'; }
+}
+export class ClaudePlanPlatformError extends Error {
+    code = 'CLAUDE_PLAN_UNSUPPORTED_PLATFORM';
+    constructor() { super('Claude sign-in needs secure random bytes and SHA-256 on this device.'); this.name = 'ClaudePlanPlatformError'; }
+}
+const base64url = (bytes) => btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join('')).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+/** Pending state/verifier never enter persistent storage. */
+export async function claudeAuthorization(options = {}) {
+    const crypto = options.crypto ?? globalThis.crypto;
+    if (!crypto?.getRandomValues || !crypto.subtle?.digest)
+        throw new ClaudePlanPlatformError();
+    const verifier = base64url(crypto.getRandomValues(new Uint8Array(32)));
+    const state = base64url(crypto.getRandomValues(new Uint8Array(32)));
+    const challenge = base64url(new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier))));
+    const url = new URL(options.authorizeUrl ?? 'https://claude.ai/oauth/authorize');
+    url.search = new URLSearchParams({ code: 'true', response_type: 'code', client_id: CLAUDE_CLIENT_ID,
+        redirect_uri: REDIRECT, scope: SCOPES, state, code_challenge: challenge, code_challenge_method: 'S256' }).toString();
+    return { url: url.toString(), verifier, state, redirect: REDIRECT };
+}
+export function claudeCode(paste, state) {
+    let code, returned;
+    if (/^https?:\/\//.test(paste)) {
+        const url = new URL(paste);
+        code = url.searchParams.get('code');
+        returned = url.searchParams.get('state');
+    }
+    else {
+        const parts = paste.trim().split('#');
+        code = parts.length === 2 ? parts[0] : null;
+        returned = parts.length === 2 ? parts[1] : null;
+    }
+    if (!code || !returned || returned !== state)
+        throw new Error('The Claude sign-in code does not match this sign-in. Try signing in again.');
+    return code;
+}
+const credential = (j, now, previous) => {
+    if (typeof j?.access_token !== 'string' || !j.access_token || typeof j.expires_in !== 'number'
+        || !Number.isFinite(j.expires_in) || j.expires_in <= 0 || !Number.isFinite(now + j.expires_in * 1000)
+        || (j.refresh_token !== undefined && (typeof j.refresh_token !== 'string' || !j.refresh_token)))
+        throw new Error('Claude could not complete the sign-in. Try signing in again.');
+    return { type: 'oauth', access: j.access_token, refresh: j.refresh_token ?? previous?.refresh ?? '', expires: now + j.expires_in * 1000 };
+};
+const states = new WeakMap();
+/** Adds only BYOKit's own Claude route; every other provider still belongs to the supplied engine. */
+export function withClaudePlan(engine, credentials, lockKey, options = {}) {
+    let shared = states.get(lockKey);
+    if (!shared)
+        states.set(lockKey, shared = { spent: new Set() });
+    const state = shared;
+    const now = options.now ?? Date.now;
+    const post = async (body, signal) => {
+        let res;
+        try {
+            res = await (options.fetch ?? fetch)(options.tokenUrl ?? 'https://platform.claude.com/v1/oauth/token', {
+                method: 'POST', signal: signal ?? AbortSignal.timeout(15_000),
+                headers: { 'content-type': 'application/json', 'user-agent': 'axios/1.7.9' }, body: JSON.stringify(body),
+            });
+        }
+        catch {
+            throw new Error('Claude could not complete the sign-in on this connection.');
+        }
+        if (!res.ok) {
+            if ([400, 401, 403].includes(res.status))
+                throw new ClaudePlanExpiredError();
+            throw new Error('Claude could not complete the sign-in. Try again later.');
+        }
+        try {
+            return await res.json();
+        }
+        catch {
+            throw new Error('Claude could not complete the sign-in. Try signing in again.');
+        }
+    };
+    const login = async ({ signal, notify, prompt }) => {
+        const pending = await claudeAuthorization(options);
+        if (signal?.aborted)
+            throw new Error('Login cancelled');
+        // Register the paste receiver before publishing the URL, so an immediate paste cannot be lost.
+        const pasted = prompt({ type: 'manual_code', message: 'Paste the code from the Claude page.', signal });
+        notify({ type: 'auth_url', url: pending.url });
+        const code = claudeCode(await pasted, pending.state);
+        if (signal?.aborted)
+            throw new Error('Login cancelled');
+        const c = credential(await post({ grant_type: 'authorization_code', client_id: CLAUDE_CLIENT_ID,
+            code, state: pending.state, redirect_uri: pending.redirect, code_verifier: pending.verifier }, signal), now());
+        if (signal?.aborted)
+            throw new Error('Login cancelled');
+        try {
+            await credentials.modify(CLAUDE_PLAN_ID, async () => c, { signal });
+        }
+        catch {
+            throw new Error('Claude sign-in could not be saved on this device. Try signing in again.');
+        }
+        if (signal?.aborted) {
+            await credentials.delete(CLAUDE_PLAN_ID);
+            throw new Error('Login cancelled');
+        }
+        return c;
+    };
+    const access = async (minOAuthValidityMs = 0) => {
+        const min = Math.max(300_000, minOAuthValidityMs);
+        const due = (c) => now() + min >= c.expires;
+        const c = await credentials.read(CLAUDE_PLAN_ID);
+        if (c?.type !== 'oauth')
+            return undefined;
+        if (state.flight)
+            return state.flight;
+        if (needsReauth(c) || state.spent.has(c.refresh))
+            throw new ClaudePlanExpiredError();
+        if (!due(c))
+            return c;
+        const work = refreshCredential(credentials, CLAUDE_PLAN_ID, due, async (current) => {
+            if (!current.refresh || state.spent.has(current.refresh))
+                throw new ClaudePlanExpiredError();
+            state.spent.add(current.refresh);
+            return credential(await post({ grant_type: 'refresh_token', client_id: CLAUDE_CLIENT_ID, refresh_token: current.refresh }), now(), current);
+        }).catch(async () => {
+            await credentials.delete(CLAUDE_PLAN_ID).catch(() => { });
+            throw new ClaudePlanExpiredError();
+        });
+        state.flight = work;
+        try {
+            const next = await work;
+            if (next)
+                state.spent.delete(next.refresh);
+            return next;
+        }
+        finally {
+            if (state.flight === work)
+                state.flight = undefined;
+        }
+    };
+    return Object.assign(engine, {
+        login: ((original) => (id, type, interaction) => id === CLAUDE_PLAN_ID ? login(interaction) : original.call(engine, id, type, interaction))(engine.login),
+        logout: ((original) => (id) => id === CLAUDE_PLAN_ID ? credentials.delete(id) : original.call(engine, id))(engine.logout),
+        checkAuth: ((original) => async (id) => id === CLAUDE_PLAN_ID
+            ? await (async () => { const c = await credentials.read(id); return c?.type === 'oauth' && !needsReauth(c) ? { source: 'OAuth', type: 'oauth' } : undefined; })()
+            : original.call(engine, id))(engine.checkAuth),
+        getAuth: ((original) => async (id, overrides) => {
+            if (id !== CLAUDE_PLAN_ID)
+                return original.call(engine, id, overrides);
+            const c = await access(overrides?.minOAuthValidityMs);
+            return c ? { auth: { apiKey: c.access }, source: 'OAuth' } : undefined;
+        })(engine.getAuth),
+    });
+}
+/** Hermes's baseline native-client fingerprint. No installed CLI is consulted for its version. */
+export function claudePlanMessages(access, options = {}) {
+    return anthropicMessages({ ...options, headers: {
+            authorization: `Bearer ${access}`, 'anthropic-beta': 'claude-code-20250219,oauth-2025-04-20',
+            'user-agent': 'claude-code/2.1.74 (external, cli)', 'x-app': 'cli', 'anthropic-dangerous-direct-browser-access': 'true',
+        }, prepare: (request) => ({ ...request, system: [
+                { type: 'text', text: "You are Claude Code, Anthropic's official CLI for Claude." },
+                ...(typeof request.system === 'string' ? [{ type: 'text', text: request.system }] : request.system ?? []),
+            ] }), safeErrors: true });
+}

package/dist/multi.d.ts

@@ -0,0 +1,77 @@
+export type SignInState = 'ready' | 'signing' | 'resting' | 'signed_out' | 'needs_again' | 'not_included';
+export type AccountLike = {
+    id: string;
+    provider: string;
+    name: string;
+    state: SignInState;
+    billing: 'subscription' | 'api';
+    until?: number;
+};
+export type RoomSpan = 'session' | 'week' | 'month' | 'tightest';
+/** Every time here is epoch milliseconds; `at` is the source measurement time, never its receipt time. */
+export type Room = {
+    left: number;
+    span: RoomSpan;
+    resetsAt?: number;
+    at?: number;
+} | {
+    left: 'unknown';
+    at?: number;
+};
+export type RunSelection = {
+    account: string | 'default' | 'auto';
+    model?: string;
+    needs?: string[];
+};
+export type Defaults = {
+    account?: string;
+    model?: string;
+    auto?: boolean;
+};
+export type PickWhy = 'chosen' | 'default' | 'first_ready' | 'only' | 'most_room' | 'earlier_reset' | 'list_order' | 'no_reading' | 'refills_first';
+export type Considered = {
+    id: string;
+    out?: 'state' | 'resting' | 'billing' | 'model' | 'provider';
+    until?: number;
+    missing?: string;
+    tier?: 'room' | 'unknown' | 'exhausted';
+    left: number | 'unknown';
+    span?: RoomSpan;
+    resetsAt?: number;
+    age: number | 'unknown';
+    confidence: 'known' | 'stale' | 'unknown';
+    reason: PickWhy | 'state' | 'resting' | 'billing' | 'model' | 'provider';
+};
+export type AccountPick<A extends AccountLike = AccountLike> = {
+    ok: true;
+    account: A;
+    model: string;
+    how: 'chosen' | 'default' | 'auto';
+    why: PickWhy;
+    reason: string;
+    considered: Considered[];
+} | {
+    ok: false;
+    code: 'none' | 'not_included' | 'unknown_account';
+    reason: string;
+    considered: Considered[];
+};
+type Models<A> = (a: A) => readonly {
+    id: string;
+    available: boolean;
+}[];
+/** Structural windows: legacy reset seconds by default; usage 0.2.0+ must pass milliseconds explicitly. */
+export declare function roomOf(windows: readonly {
+    usedPercent: number;
+    kind: string;
+    resetsAt?: number;
+}[], at?: number, resetUnit?: 'seconds' | 'milliseconds'): Room;
+export declare function roomWords(room: Room): string;
+/** Auto's winner only. Pure and portable; no timers, reads, refreshes or mid-run switching. */
+export declare function chooseAccount<A extends AccountLike>(accounts: readonly A[], room: (a: A) => Room, nowMs: number): {
+    account: A;
+    why: PickWhy;
+} | undefined;
+/** Resolve once before starting. Without `models`, membership is host-validated and a missing model is ''. */
+export declare function resolveSelection<A extends AccountLike>(accounts: readonly A[], defaults: Defaults, sel: RunSelection, room: (a: A, demand: readonly string[]) => Room, nowMs: number, models?: Models<A>): AccountPick<A>;
+export {};

package/dist/multi.js

@@ -0,0 +1,134 @@
+// Pure start-of-run selection. Callers own identities and credentials and keep the returned account for the run.
+import { clock, say } from "./words.js";
+const DAY_MS = 24 * 60 * 60 * 1000;
+const finite = (n) => typeof n === 'number' && Number.isFinite(n);
+const reset = (r) => r.resetsAt ?? Infinity;
+/** Structural windows: legacy reset seconds by default; usage 0.2.0+ must pass milliseconds explicitly. */
+export function roomOf(windows, at, resetUnit = 'seconds') {
+    const known = windows.filter((w) => finite(w.usedPercent));
+    if (!known.length)
+        return { left: 'unknown', ...(finite(at) ? { at } : {}) };
+    const w = known.reduce((a, b) => b.usedPercent > a.usedPercent ? b : a);
+    const span = w.kind === 'session' ? 'session' : w.kind === 'weekly' ? 'week' : w.kind === 'monthly' ? 'month' : 'tightest';
+    return { left: Math.max(0, Math.min(100, 100 - w.usedPercent)), span,
+        ...(finite(w.resetsAt) ? { resetsAt: w.resetsAt * (resetUnit === 'seconds' ? 1000 : 1) } : {}), ...(finite(at) ? { at } : {}) };
+}
+export function roomWords(room) {
+    return room.left === 'unknown' ? say('room.unknown') : say(`room.${room.span}`, { left: `${Math.round(room.left)}%` });
+}
+// One shared eligibility predicate for direct picks, Auto and all explanation rows. Room is read once per row.
+function consider(accounts, room, nowMs, demand = [], models, provider, named) {
+    return accounts.map((account) => {
+        const r = room(account);
+        const age = finite(r.at) ? Math.max(0, nowMs - r.at) : 'unknown';
+        const stale = typeof age === 'number' && age > DAY_MS;
+        const left = r.left === 'unknown' || !finite(r.left) || stale ? 'unknown' : Math.max(0, Math.min(100, r.left));
+        const row = { id: account.id, left, age,
+            confidence: stale ? 'stale' : left === 'unknown' || age === 'unknown' ? 'unknown' : 'known', reason: 'no_reading' };
+        if (r.left !== 'unknown') {
+            row.span = r.span;
+            if (finite(r.resetsAt))
+                row.resetsAt = r.resetsAt;
+        }
+        // Explicit ids bypass state and billing: the host verifies readiness before starting, never falls back.
+        if (account.id !== named) {
+            if (account.state === 'resting' && finite(account.until) && account.until > nowMs) {
+                row.out = 'resting';
+                row.until = account.until;
+            }
+            else if (account.state !== 'ready' && !(account.state === 'resting' && finite(account.until) && account.until <= nowMs))
+                row.out = 'state';
+            else if (account.billing !== 'subscription')
+                row.out = 'billing';
+        }
+        if (!row.out && demand.length && models) {
+            const available = models(account);
+            const missing = demand.find((id) => !available.some((m) => m.id === id && m.available));
+            if (missing !== undefined) {
+                row.out = 'model';
+                row.missing = missing;
+            }
+        }
+        if (!row.out && !demand.length && provider !== undefined && account.provider !== provider && account.id !== named)
+            row.out = 'provider';
+        if (row.out)
+            row.reason = row.out;
+        else
+            row.tier = left === 'unknown' ? 'unknown' : left > 0 || reset(row) <= nowMs ? 'room' : 'exhausted';
+        return { account, row };
+    });
+}
+const tierOrder = { room: 0, unknown: 1, exhausted: 2 };
+function compare(a, b) {
+    const tier = tierOrder[a.row.tier] - tierOrder[b.row.tier];
+    if (tier)
+        return tier;
+    if (a.row.tier === 'unknown')
+        return 0;
+    if (a.row.tier === 'room' && a.row.left !== b.row.left)
+        return Number(b.row.left) - Number(a.row.left);
+    // Avoid Infinity - Infinity (NaN); stable sort preserves list order for ties.
+    return reset(a.row) === reset(b.row) ? 0 : reset(a.row) < reset(b.row) ? -1 : 1;
+}
+function rankingReason(winner, next) {
+    if (winner.row.tier === 'unknown')
+        return 'no_reading';
+    if (winner.row.tier === 'exhausted')
+        return 'refills_first';
+    if (!next || next.row.tier !== 'room' || winner.row.left !== next.row.left)
+        return 'most_room';
+    return reset(winner.row) < reset(next.row) ? 'earlier_reset' : 'list_order';
+}
+function rank(rows) {
+    const ranked = rows.filter((c) => !c.row.out).sort(compare);
+    const winner = ranked[0];
+    if (!winner)
+        return undefined;
+    const why = ranked.length === 1 ? 'only' : rankingReason(winner, ranked[1]);
+    for (const c of ranked)
+        c.row.reason = c === winner ? why : rankingReason(winner, c);
+    return { account: winner.account, why, row: winner.row };
+}
+/** Auto's winner only. Pure and portable; no timers, reads, refreshes or mid-run switching. */
+export function chooseAccount(accounts, room, nowMs) {
+    const pick = rank(consider(accounts, room, nowMs));
+    return pick && { account: pick.account, why: pick.why };
+}
+/** Resolve once before starting. Without `models`, membership is host-validated and a missing model is ''. */
+export function resolveSelection(accounts, defaults, sel, room, nowMs, models) {
+    const demand = [...new Set([...(sel.model ? [sel.model] : []), ...(sel.needs ?? [])])];
+    const defaultAccount = accounts.find((a) => a.id === defaults.account);
+    const named = sel.account === 'default' ? defaultAccount?.state === 'ready' ? defaultAccount.id : undefined : sel.account === 'auto' ? undefined : sel.account;
+    const provider = defaultAccount?.provider ?? accounts[0]?.provider;
+    const rows = consider(accounts, (a) => room(a, demand), nowMs, demand, models, provider, named);
+    const considered = rows.map((c) => c.row);
+    const auto = rank(rows); // also fills explanations for every eligible row, even on explicit selection
+    if (named !== undefined) {
+        const chosen = rows.find((c) => c.account.id === named);
+        if (!chosen)
+            return { ok: false, code: 'unknown_account', reason: say('pick.unknownAccount'), considered };
+        if (chosen.row.out)
+            return { ok: false, code: 'not_included', reason: say('pick.out.model', { model: chosen.row.missing ?? '' }), considered };
+        return finish(chosen.account, chosen.row, sel.account === 'default' ? 'default' : 'chosen', sel.account === 'default' ? 'default' : 'chosen');
+    }
+    if (sel.account === 'default' && defaults.auto === false) {
+        const first = rows.find((c) => !c.row.out);
+        if (first)
+            return finish(first.account, first.row, 'default', 'first_ready');
+    }
+    else if (auto)
+        return finish(auto.account, auto.row, 'auto', auto.why);
+    return { ok: false, code: 'none', reason: say('auto.none', { provider: provider ?? '' }), considered };
+    function finish(account, row, how, why) {
+        const available = models?.(account).filter((m) => m.available);
+        const model = sel.model ?? (defaults.model && (!available || available.some((m) => m.id === defaults.model)) ? defaults.model : available?.[0]?.id) ?? '';
+        if (models && !model)
+            return { ok: false, code: 'not_included', reason: say('pick.noModel'), considered };
+        row.reason = why;
+        const slots = { name: account.name, provider: account.provider };
+        const reason = how !== 'auto' ? say(`pick.why.${why}`, slots) : row.tier === 'unknown' ? say('auto.unknown', slots) : row.tier === 'exhausted' ?
+            say(finite(row.resetsAt) ? 'auto.refills' : 'auto.refillsNoTime', { ...slots, time: finite(row.resetsAt) ? clock(row.resetsAt) : '' }) :
+            say('auto.room', { ...slots, room: roomWords({ left: Number(row.left), span: row.span ?? 'tightest' }) });
+        return { ok: true, account, model, how, why, reason, considered };
+    }
+}

package/dist/node-stores.d.ts

@@ -4,6 +4,8 @@ import { type EndingStore } from './stores.ts';
 export type SafeStorageLike = {
     encryptString(text: string): Uint8Array;
     decryptString(data: Buffer): string;
+    /** Optional authenticated format upgrade; fileStore verifies and atomically replaces it. */
+    upgrade?(data: Buffer): Uint8Array | undefined;
     isEncryptionAvailable?(): boolean;
     getSelectedStorageBackend?(): string;
 };

package/dist/node-stores.js

@@ -38,7 +38,16 @@ export function fileStore(path, safeStorage) {
             const st = fstatSync(fd);
             if (!st.isFile() || (st.mode & 0o077))
                 throw new Error('Credential storage requires a private regular file');
-            return JSON.parse(safeStorage.decryptString(readFileSync(fd)));
+            const bytes = readFileSync(fd);
+            const text = safeStorage.decryptString(bytes);
+            const data = JSON.parse(text);
+            const upgraded = safeStorage.upgrade?.(bytes);
+            if (upgraded) {
+                if (safeStorage.decryptString(Buffer.from(upgraded)) !== text)
+                    throw new Error('Credential upgrade verification failed');
+                replace(upgraded);
+            }
+            return data;
         }
         finally {
             closeSync(fd);
@@ -47,6 +56,9 @@ export function fileStore(path, safeStorage) {
     const save = async (data) => {
         ready();
         const sealed = safeStorage.encryptString(JSON.stringify(data, null, 2));
+        replace(sealed);
+    };
+    const replace = (sealed) => {
         mkdirSync(folder, { recursive: true, mode: 0o700 });
         privateFolder();
         const tmp = `${path}.${process.pid}.${randomBytes(12).toString('hex')}.tmp`;

package/dist/portable.d.ts

@@ -1,8 +1,11 @@
-export { Accounts, planOf, portable, type AccountsOptions, type AuthHost, type Loopback, type Member, type Platform, type SignIn, type Status } from './accounts.ts';
-export { PROVIDERS, offered, provider, type Billing, type Provider, type Terms } from './catalogue.ts';
+export { Accounts, planOf, portable, type AccountsOptions, type ClaudePlanAsk, type AnthropicAccountAsk, type AuthHost, type Loopback, type Member, type Platform, type SignIn, type Status } from './accounts.ts';
+export { PROVIDERS, offered, provider, type Billing, type MultiAccountTerms, type Provider, type Terms } from './catalogue.ts';
 export { PORTABLE, claims, credentialOf, devicePoll, deviceStart, portableEngine, type EngineOptions, type Poll } from './engine.ts';
 export { REST_MS, classify, classifyFailure, type Failure, type Kind } from './limits.ts';
 export { IncompleteError, ResponseError, isFunctionCall, limitResponse, respond, sseReader, type Ask, type ResponseFunctionCall, type ResponseInputItem, type ResponseOutputItem, type ResponseOutputMessage, type ResponseReasoning, type ResponseResult, type ResponseStreamEvent, type ResponseText, type ResponseTextFormat, type ResponseTool, type ResponseToolChoice } from './responses.ts';
-export { browserStore, memoryStore, recordStore, secureStore, RefreshRequiredError, type RefreshStore, type SecureStoreLike } from './stores.ts';
+export { browserStore, keystoreStore, memoryStore, recordStore, secureStore, RefreshRequiredError, type RefreshStore, type SecureStoreLike } from './stores.ts';
 export { WORDS, billingWords, callbackPage, clock, failure, say, signInError, type WordKey, type Why } from './words.ts';
 export { chatgptPlan, UnsupportedAccountError, type ChatGPTPlanAccount, type ChatGPTPlanSession } from './chatgpt-plan.ts';
+export { anthropic, anthropicSseReader, AnthropicIncompleteError, type AnthropicAsk, type AnthropicCacheControl, type AnthropicContent, type AnthropicImage, type AnthropicMessage, type AnthropicOptions, type AnthropicRequest, type AnthropicResponse, type AnthropicResult, type AnthropicStreamEvent, type AnthropicText, type AnthropicThinking, type AnthropicTool, type AnthropicToolChoice, type AnthropicToolUse, type AnthropicUsage } from './anthropic.ts';
+export { ClaudePlanExpiredError, ClaudePlanPlatformError, claudeAuthorization, claudeCode, type ClaudePlanOptions } from './claude-plan.ts';
+export { chooseAccount, resolveSelection, roomOf, roomWords, type AccountLike, type AccountPick, type Considered, type Defaults, type PickWhy, type Room, type RoomSpan, type RunSelection, type SignInState } from './multi.ts';

package/dist/portable.js

@@ -5,6 +5,9 @@ export { PROVIDERS, offered, provider } from "./catalogue.js";
 export { PORTABLE, claims, credentialOf, devicePoll, deviceStart, portableEngine } from "./engine.js";
 export { REST_MS, classify, classifyFailure } from "./limits.js";
 export { IncompleteError, ResponseError, isFunctionCall, limitResponse, respond, sseReader } from "./responses.js";
-export { browserStore, memoryStore, recordStore, secureStore, RefreshRequiredError } from "./stores.js";
+export { browserStore, keystoreStore, memoryStore, recordStore, secureStore, RefreshRequiredError } from "./stores.js";
 export { WORDS, billingWords, callbackPage, clock, failure, say, signInError } from "./words.js";
 export { chatgptPlan, UnsupportedAccountError } from "./chatgpt-plan.js";
+export { anthropic, anthropicSseReader, AnthropicIncompleteError } from "./anthropic.js";
+export { ClaudePlanExpiredError, ClaudePlanPlatformError, claudeAuthorization, claudeCode } from "./claude-plan.js";
+export { chooseAccount, resolveSelection, roomOf, roomWords } from "./multi.js";

package/dist/stores.d.ts

@@ -39,3 +39,8 @@ export declare function secureStore(secure: SecureStoreLike, name: string, optio
 /** One person's sign-ins in the browser's IndexedDB (a PWA, or Electron's renderer), under `name`. A browser has no
  *  keychain: anything running on this page could read them, so keep the page free of scripts you don't control. */
 export declare function browserStore(name: string, db?: string): EndingStore;
+/** A device-owned @byokit/secrets backend, supplied by the host; no runtime Node import. One store per member/name. */
+export declare function keystoreStore(keystore: {
+    get(name: string): Promise<string | null>;
+    set(name: string, secret: string): Promise<void>;
+}, name: string): CredentialStore;

package/dist/stores.js

@@ -164,3 +164,7 @@ export function browserStore(name, db = 'byokit') {
         end: (id, fn) => locked(() => store.end(id, fn)),
     };
 }
+/** A device-owned @byokit/secrets backend, supplied by the host; no runtime Node import. One store per member/name. */
+export function keystoreStore(keystore, name) {
+    return recordStore(async () => JSON.parse(await keystore.get(name) ?? '{}'), async (data) => keystore.set(name, JSON.stringify(data)));
+}

package/dist/words.json

@@ -1,5 +1,5 @@
 {
-    "signIn.opening": "Opening {name}…",
+    "signIn.opening": "Opening {name}\u2026",
     "signIn.waitingUrl": "Sign in on the {name} page that just opened.",
     "signIn.waitingCode": "On the {name} page, type this code: {code}",
     "signIn.pasteHint": "Having trouble? Copy the address from the browser and paste it here.",
@@ -12,7 +12,7 @@
     "signIn.busy": "Something else on this computer is signing in to {name}. Try again in a minute.",
     "signIn.failed": "{name} didn't finish the sign-in. Tap Sign in with {name} to try again.",
     "status.ready": "{name} is connected.",
-    "status.signing": "Signing in to {name}…",
+    "status.signing": "Signing in to {name}\u2026",
     "status.resting": "{name} is resting until {until}.",
     "status.busy": "{name} is busy right now.",
     "status.signedOut": "{name} isn't signed in yet.",
@@ -25,5 +25,37 @@
     "callback.declined": "No problem. Nothing was changed. You can go back to {app}.",
     "callback.failed": "{error} Go back to {app}.",
     "callback.nearly": "Nearly there. Go back to {app} to finish.",
-    "callback.outOfDate": "This sign-in page is out of date. Go back to {app} and tap Sign in with {name} again."
+    "callback.outOfDate": "This sign-in page is out of date. Go back to {app} and tap Sign in with {name} again.",
+    "auto.terms": "Auto may use either of a provider's accounts.",
+    "auto.room": "Right now that's {name}: {room}",
+    "auto.unknown": "Right now that's {name} (no recent reading)",
+    "auto.refills": "All {provider} accounts are out of room until {time}. {name} refills first.",
+    "auto.refillsNoTime": "All {provider} accounts are out of room. {name} refills first.",
+    "auto.none": "No signed-in {provider} account.",
+    "room.unknown": "Room left unknown",
+    "room.session": "{left} left this session",
+    "room.week": "{left} left this week",
+    "room.month": "{left} left this month",
+    "room.tightest": "{left} left for now",
+    "pick.out.state": "Not signed in right now",
+    "pick.out.resting": "Taking a break until {time}",
+    "pick.out.billing": "Billed per use, so used only when you choose it",
+    "pick.out.model": "Doesn't include {model}",
+    "pick.out.provider": "A different service",
+    "pick.out.bound": "This conversation uses another account",
+    "pick.unknownAccount": "That account is no longer in your list.",
+    "pick.noModel": "That account doesn't include a model for this run.",
+    "pick.why.chosen": "You chose {name}.",
+    "pick.why.default": "{name} is your default.",
+    "pick.why.first_ready": "Your default isn't ready, so {name}, the first ready account.",
+    "pick.why.only": "{name} is the only account that can take this.",
+    "pick.why.most_room": "{name} has the most room left.",
+    "pick.why.earlier_reset": "{name} has as much room left and refills sooner.",
+    "pick.why.list_order": "{name} is tied for room and comes first in your list.",
+    "pick.why.no_reading": "No account has a recent reading, so {name}, first in your list.",
+    "pick.why.refills_first": "All accounts are out of room; {name} refills first.",
+    "pick.age": "Read {ago} ago",
+    "pick.ageUnknown": "Reading time unknown",
+    "ago.minutes": "{n} minutes",
+    "ago.hours": "{n} hours"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/accounts",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Sign in with the AI plan you already pay for, into your app's own store.",
   "license": "Apache-2.0",
   "type": "module",
@@ -41,7 +41,8 @@
   "files": [
     "dist",
     "CHANGELOG.md",
-    "SECURITY.md"
+    "SECURITY.md",
+    "NOTICE"
   ],
   "scripts": {
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"