@byokit/openclaw 0.8.0 → 0.10.0

package/dist/pick.d.ts

@@ -0,0 +1,11 @@
+import type { Account, AccountId, AccountPick, Considered, Defaults, ModelInfo, PickWhy, Room, RunSelection } from './types.ts';
+export type RoomOf = (a: Account, demand: readonly string[]) => Room;
+/** Every account's `Considered` row, in list order, with the kit-only `bound` applied. */
+export declare function consider(accounts: readonly Account[], defaults: Defaults, sel: RunSelection, room: RoomOf, nowMs: number, models?: (a: Account) => readonly ModelInfo[], bound?: readonly AccountId[]): Considered[];
+/** Auto's winner only; `candidates` are the eligible accounts. Pure and portable; no timers, reads or mid-run switching. */
+export declare function chooseAccount(candidates: readonly Account[], room: (a: Account) => Room, nowMs: number): {
+    account: Account;
+    why: PickWhy;
+} | undefined;
+/** Resolve once before starting. Without `models`, membership is host-validated and a missing model is ''. */
+export declare function resolveSelection(accounts: readonly Account[], defaults: Defaults, sel: RunSelection, room: RoomOf, nowMs: number, models?: (a: Account) => readonly ModelInfo[], bound?: readonly AccountId[]): AccountPick;

package/dist/pick.js

@@ -0,0 +1,145 @@
+import { words } 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;
+const roomWords = (left, span) => words(`room.${span}`, { left: `${Math.round(left)}%` });
+// "3:40pm", or "Fri 3:40pm" when it isn't today (matches @byokit/accounts' clock).
+const clock = (t) => (new Date(t).toDateString() === new Date().toDateString() ? '' : new Date(t).toLocaleDateString('en-US', { weekday: 'short' }) + ' ') +
+    new Date(t).toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' }).toLowerCase();
+// One shared eligibility predicate for direct picks, Auto and every explanation row. Room is read once per row.
+// `bound` (kit only) is the accounts a conversation may use; an account outside it is never a candidate, even when
+// the selection names it, and its row carries `out: 'bound'`. An account the selection names is judged only on
+// `bound` and the demand, so an API-key or resting account it names carries no `billing`/`resting` `out`.
+function considerRows(accounts, room, nowMs, demand = [], models, provider, named, bound) {
+    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;
+        }
+        if (bound !== undefined && !bound.includes(account.id))
+            row.out = 'bound';
+        if (!row.out && 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 };
+    });
+}
+/** Every account's `Considered` row, in list order, with the kit-only `bound` applied. */
+export function consider(accounts, defaults, sel, room, nowMs, models, bound) {
+    const demand = [...new Set([...(sel.model ? [sel.model] : []), ...(sel.needs ?? [])])];
+    const defaultAccount = accounts.find((a) => a.id === defaults.account);
+    const named = nameOf(accounts, defaults, sel, bound);
+    const provider = sel.provider ?? defaultAccount?.provider ?? accounts[0]?.provider;
+    return considerRows(accounts, (a) => room(a, demand), nowMs, demand, models, provider, named, bound).map((c) => c.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; `candidates` are the eligible accounts. Pure and portable; no timers, reads or mid-run switching. */
+export function chooseAccount(candidates, room, nowMs) {
+    const pick = rank(considerRows(candidates, room, nowMs));
+    return pick && { account: pick.account, why: pick.why };
+}
+// The `'default'` id is the saved default account when it is ready, a subscription (or a non-custom API choice) and
+// in `bound`; a default outside `bound` is treated as not ready (its row has `out: 'bound'`) and the pick falls through.
+function nameOf(accounts, defaults, sel, bound) {
+    const defaultAccount = accounts.find((a) => a.id === defaults.account);
+    const usable = defaultAccount?.state === 'ready' &&
+        (defaultAccount.billing === 'subscription' || (defaultAccount.billing === 'api' && defaultAccount.provider !== 'custom')) &&
+        (bound === undefined || bound.includes(defaultAccount.id));
+    return sel.account === 'default' ? (usable ? defaultAccount.id : undefined) : sel.account === 'auto' ? undefined : sel.account;
+}
+/** Resolve once before starting. Without `models`, membership is host-validated and a missing model is ''. */
+export function resolveSelection(accounts, defaults, sel, room, nowMs, models, bound) {
+    const demand = [...new Set([...(sel.model ? [sel.model] : []), ...(sel.needs ?? [])])];
+    const defaultAccount = accounts.find((a) => a.id === defaults.account);
+    const named = nameOf(accounts, defaults, sel, bound);
+    const provider = sel.provider ?? defaultAccount?.provider ?? accounts[0]?.provider;
+    const rows = considerRows(accounts, (a) => room(a, demand), nowMs, demand, models, provider, named, bound);
+    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: words('auto.none', { provider: provider ?? '' }), considered };
+        if (chosen.row.out)
+            return { ok: false, code: 'not_included', reason: words(`pick.out.${chosen.row.out}`, { 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: words('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: words('pick.out.model', { model: sel.model ?? '' }), considered };
+        row.reason = why;
+        const slots = { name: account.name, provider: account.provider };
+        const reason = how !== 'auto' ? words(`pick.why.${why}`, slots) : row.tier === 'unknown' ? words('auto.unknown', slots) : row.tier === 'exhausted' ?
+            words(finite(row.resetsAt) ? 'auto.refills' : 'auto.refillsNoTime', { ...slots, time: finite(row.resetsAt) ? clock(row.resetsAt) : '' }) :
+            words('auto.room', { ...slots, room: roomWords(Number(row.left), row.span ?? 'tightest') });
+        return { ok: true, account, model, how, why, reason, considered };
+    }
+}

package/dist/signin.d.ts

@@ -21,4 +21,5 @@ export declare function signIn(ctx: SignInCtx, member: Member, o: SignInOptions,
 };
 /** Usable provider profiles plus native Claude Code readiness reported by the engine. */
 export declare function providers(ctx: SignInCtx, member: Member, refresh?: boolean): Promise<string[]>;
+/** Signs the member's agent out of its own profiles of `provider` only (5.7, 5.15). */
 export declare function signOut(ctx: SignInCtx, member: Member, provider: string): Promise<void>;

package/dist/signin.js

@@ -433,7 +433,19 @@ export async function providers(ctx, member, refresh) {
     return signedInProviders(await (ctx.authStatus ? ctx.authStatus(agentId, refresh ?? false, true)
         : authStatus(ctx.request, agentId, refresh, true))) ?? [];
 }
+/** Signs the member's agent out of its own profiles of `provider` only (5.7, 5.15). */
 export async function signOut(ctx, member, provider) {
     const { agentId } = await ctx.ensure(member);
-    await ctx.request('models.authLogout', { provider, agentId }, { timeoutMs: STATUS_MS });
+    // Without profileIds the pin removes the provider's profiles from every owner store, another member's included.
+    // The inherited base is empty (5.15), so every profile this agent's status lists is its own.
+    const read = (refresh) => ctx.authStatus ? ctx.authStatus(agentId, refresh, false) : authStatus(ctx.request, agentId, refresh);
+    let status = await read(false);
+    if (status.unavailable)
+        status = await read(true); // no prepared snapshot yet: build it once
+    if (status.unavailable)
+        throw new Error(String(status.unavailable.message ?? 'account status unavailable'));
+    const profileIds = (status.providers ?? []).flatMap((row) => typeof row === 'string' || row.provider !== provider ? []
+        : (row.profiles ?? []).map((p) => p.profileId).filter((id) => typeof id === 'string' && id !== ''));
+    if (profileIds.length)
+        await ctx.request('models.authLogout', { provider, agentId, profileIds }, { timeoutMs: STATUS_MS });
 }

package/dist/testing/fake-gateway.js

@@ -222,11 +222,17 @@ export function fakeGateway(script, o) {
                 ensureAgent(id, workspace);
             return { id };
         },
+        // One profile per signed-in provider, `<provider>:default`, as the pin lists an agent's own profiles.
         'models.authStatus': (p) => ({
-            providers: (agents.get(String(p?.agentId ?? 'main'))?.providers ?? []).map((provider) => ({ provider })),
+            providers: (agents.get(String(p?.agentId ?? 'main'))?.providers ?? []).map((provider) => ({ provider,
+                profiles: [{ profileId: `${provider}:default`, type: 'oauth', status: 'ok' }] })),
         }),
         'models.authLogout': (p) => {
             const agent = agents.get(String(p?.agentId ?? 'main'));
+            // The pin refuses a profileIds list naming a profile the agent does not hold.
+            if (p.profileIds !== undefined && (!Array.isArray(p.profileIds) || !p.profileIds.length
+                || p.profileIds.some((id) => id !== `${p.provider}:default` || !agent?.providers.includes(String(p.provider)))))
+                throw new Error('profileIds contain unavailable auth profiles');
             if (agent)
                 agent.providers = agent.providers.filter((provider) => provider !== p.provider);
             if (keys.get(String(p.agentId))?.provider === p.provider)

package/dist/types.d.ts

@@ -2,6 +2,15 @@ import type { OutputSchema } from './output.ts';
 import type { GatewayEventName, GatewayEventPayload } from './generated/events.ts';
 export type { OutputSchema, SchemaOutput } from './output.ts';
 export type Member = string;
+/** The engine's learning mode: config key `skills.workshop.autonomous.mode` (5.6). */
+export type LearningMode = 'off' | 'propose' | 'auto';
+/** Exactly what `learning()` saw: absence is a value, not "probably default" (5.6). */
+export type LearningCapture = {
+    present: false;
+} | {
+    present: true;
+    mode: LearningMode;
+};
 export interface ToolSpec {
     name: string;
     description: string;
@@ -132,8 +141,13 @@ export type Decision = {
 };
 export type KitState = {
     phase: 'stopped' | 'installing' | 'starting' | 'repairing' | 'ready' | 'restarting' | 'failed' | 'needs-update' | 'locked';
-    why?: 'install' | 'handshake' | 'exited' | 'port' | 'version' | 'engine-already-running' | 'engine-patch' | 'sign-in-reset' | 'auth-store-unreadable';
+    why?: 'install' | 'handshake' | 'exited' | 'port' | 'version' | 'engine-already-running' | 'engine-patch' | 'sign-in-reset' | 'auth-store-unreadable' | 'auth-store-seal-size';
     retryAt?: number;
+    sealSize?: {
+        size: number;
+        cap: number;
+        file?: string;
+    };
     patchSet?: string | null;
 };
 export type Hello = {
@@ -233,3 +247,85 @@ export type KitEventName = GatewayEventName | 'byokit.browser';
 export type KitEventPayload<E extends KitEventName> = E extends 'byokit.browser' ? BrowserPing : GatewayEventPayload<Extract<E, GatewayEventName>>;
 export type { GatewayMethod, GatewayParams, GatewayResult } from './generated/methods.ts';
 export type { GatewayEventName, GatewayEventPayload } from './generated/events.ts';
+export type AccountId = string;
+export type AccountRef = AccountId;
+export type SignInState = 'ready' | 'signing' | 'resting' | 'signed_out' | 'needs_again' | 'not_included';
+export type Account = {
+    id: AccountId;
+    provider: string;
+    route: string;
+    name: string;
+    label: string;
+    email?: string;
+    plan?: string;
+    billing: 'subscription' | 'api';
+    state: SignInState;
+    until?: number;
+    addedAt: number;
+};
+export type RoomSpan = 'session' | 'week' | 'month' | 'tightest';
+export type Room = {
+    left: number;
+    span: RoomSpan;
+    resetsAt?: number;
+    at?: number;
+} | {
+    left: 'unknown';
+    at?: number;
+};
+export type ModelInfo = {
+    id: string;
+    name: string;
+    tier?: 'strong' | 'fast';
+    available: boolean;
+    why?: 'plan' | 'resting' | 'signed_out';
+    until?: number;
+};
+export type RunSelection = {
+    account: AccountRef | 'default' | 'auto';
+    model?: string;
+    needs?: string[];
+    provider?: string;
+};
+export type Defaults = {
+    account?: AccountId;
+    model?: string;
+    auto?: boolean;
+};
+export type Considered = {
+    id: AccountId;
+    out?: 'state' | 'resting' | 'billing' | 'model' | 'provider' | 'bound';
+    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' | 'bound';
+};
+export type PickWhy = 'chosen' | 'default' | 'first_ready' | 'only' | 'most_room' | 'earlier_reset' | 'list_order' | 'no_reading' | 'refills_first';
+export type AccountPick = {
+    ok: true;
+    account: Account;
+    model: string;
+    how: 'chosen' | 'default' | 'auto';
+    why: PickWhy;
+    reason: string;
+    considered: Considered[];
+} | {
+    ok: false;
+    code: 'none' | 'not_included' | 'unknown_account' | 'bound' | 'paid';
+    reason: string;
+    considered: Considered[];
+};
+export type MoveResult = {
+    ok: true;
+    session: string;
+} | {
+    ok: false;
+    code: 'too_early' | 'busy' | 'unsupported' | 'env_mismatch' | 'close_failed' | 'start_failed';
+    message: string;
+    live?: string;
+};

package/dist/words.js

@@ -17,12 +17,15 @@ const PHASE_WORDS = {
     locked: 'engine.locked',
     'needs-update': 'engine.needsUpdate',
 };
+const MiB = 1024 * 1024;
 export function stateWords(s) {
     // 'stopped' is never on screen (4.3 covers what a person can see), so 5.14 has no row for it.
     if (s.phase === 'failed' && s.why === 'engine-already-running')
         return words('engine.alreadyRunning');
     if (s.why === 'auth-store-unreadable')
         return words('engine.authStoreUnreadable');
+    if (s.why === 'auth-store-seal-size' && s.sealSize)
+        return words('engine.authStoreSealSize', { store: s.sealSize.file ? words('engine.store.engineData', { file: s.sealSize.file }) : words('engine.store.savedSignIn'), size: String(Math.floor(s.sealSize.size / MiB)), limit: String(s.sealSize.cap / MiB) });
     if (s.why === 'sign-in-reset')
         return words('engine.signInAgain');
     return s.phase === 'stopped' ? '' : words(PHASE_WORDS[s.phase]);

package/dist/words.json

@@ -4,6 +4,9 @@
     "engine.repairing": "Fixing a small problem with the setup. This takes a moment.",
     "engine.locked": "Your saved sign-in is locked. Unlock your password storage, then try again.",
     "engine.authStoreUnreadable": "Your saved sign-in couldn't be opened. It is unchanged. Restore its original key or a working backup, then retry.",
+    "engine.authStoreSealSize": "{store} is too large to keep safely (more than {size} MB; the limit is {limit} MB). Your sign-ins were kept.",
+    "engine.store.engineData": "Engine data {file}",
+    "engine.store.savedSignIn": "Your saved sign-in data",
     "engine.signInAgain": "Your saved sign-in couldn't be opened, so it was kept aside. Sign in again.",
     "engine.ready": "Ready.",
     "engine.restarting": "Something stopped. Starting it again by itself.",
@@ -71,5 +74,39 @@
     "key.ok": "Your key is ready. Use it only when you choose this option.",
     "key.invalid": "This key could not be saved. Check it and try again.",
     "key.notIncluded": "This option is not available here.",
-    "key.missing": "Add an API key to use this option."
+    "key.missing": "Add an API key to use this option.",
+    "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.terms": "Auto may use either of a provider's accounts.",
+    "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.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} min",
+    "ago.hours": "{n} h",
+    "account.bound": "This conversation uses {name}. Move it to switch accounts.",
+    "account.paid": "This conversation uses {name}, which is billed per use. Choose {name} to keep going.",
+    "account.signOutFirst": "To add a different {provider} account, sign out of {provider} in your browser first.",
+    "account.legacyMember": "This person needs a new profile before adding more accounts."
 }