@byokit/openclaw 0.13.0 → 0.14.0

package/dist/kit.js

@@ -664,6 +664,9 @@ export class OpenClawKit {
         this.admission = createAuthStatus(this.engine.root, (method, params, options) => this.request()(method, params, options));
         this.keys = createKeys({ root: this.engine.root,
             prepareOwner: (agentId) => this.prepareKeyOwner(agentId),
+            indexLane: (member, route) => this.indexKeyLane(member, route),
+            dropLane: (member, provider) => this.dropKeyLane(member, provider),
+            backfillLane: (member, model) => this.backfillKeyLane(member, model),
             restarting: () => this.engineRestarting(),
             request: (method, params, options) => this.request()(method, params, options),
             ensure: (member) => this.ensureMember(member),
@@ -771,10 +774,11 @@ export class OpenClawKit {
             this.setState({ phase: 'ready' });
             this.syncCatalogs();
             // A failed key add whose abandon clear never reached the engine leaves an unsealed key with no ready marker;
-            // runs stay closed, so drop it now that the gateway is ready. Ready keys keep their marker and survive.
-            if (!this.swept)
-                void this.keys.sweep().then((done) => { if (done)
-                    this.swept = true; }).catch(() => undefined);
+            // runs stay closed, so drop it now that the gateway is ready. Ready keys keep their marker and survive. Every
+            // connect backfills the key lanes' index entries; only the clear stops once a sweep completes.
+            const clear = !this.swept;
+            void this.keys.sweep(clear).then((done) => { if (clear && done)
+                this.swept = true; }).catch(() => undefined);
             if (this.o.browser)
                 await this.checkBrowserTools();
             // Replays the engine's native approval lists over the now-live transport (N9).
@@ -951,7 +955,10 @@ export class OpenClawKit {
             // Public readiness/sign-in reads stay live; their fresh result can prepare the next run's admission.
             authStatus: (agentId, refresh, native) => this.admission.read(agentId, refresh, native, false),
             ensure: (member) => this.ensureMember(member), callbackPort: this.o.callbackPort ?? 1455,
+            nativeClaudeLogin: () => this.engine.nativeClaudeLogin(),
+            resetNativeClaudeLogin: () => this.engine.resetNativeClaudeLogin(),
             onDisconnect: (fn) => { this.signInDisconnects.add(fn); return () => { this.signInDisconnects.delete(fn); }; },
+            stopSignal: this.engine.stopSignal,
             authConfig: () => this.authSnapshot(),
             restarted: (authBefore, signal) => this.restarted(authBefore, signal) };
     }
@@ -966,15 +973,31 @@ export class OpenClawKit {
         return this.providerStatus(member).then((names) => names ?? []);
     }
     /** A member sign-in to `provider`, or a ready key (5.8) whose saved model is that provider's. */
-    signedIn(member, provider) {
-        return this.providers(member).then(async (names) => names.includes(provider)
-            || providerOf((await this.keys.ready(member, { once: true }))?.model ?? '') === provider).catch(() => false);
+    async signedIn(member, provider) {
+        // The key probe stands alone: a member-agent admission failure after an engine restart must not hide a sealed key.
+        const keyReady = async () => {
+            try {
+                return providerOf((await this.keys.ready(member, { once: true }))?.model ?? '') === provider;
+            }
+            catch {
+                return false;
+            }
+        };
+        try {
+            if ((await this.providers(member)).includes(provider))
+                return true;
+        }
+        catch { /* key probe below */ }
+        return keyReady();
     }
     signIn(member, o, on) {
         return startSignIn(this.signInCtx(), member, o, on);
     }
-    signOut(member, provider) {
-        return engineSignOut(this.signInCtx(), member, provider);
+    async signOut(member, provider) {
+        await engineSignOut(this.signInCtx(), member, provider);
+        // The saved key lives on its own `byokit-key-<member>` agent, which the member-agent logout never reaches: without
+        // this, a key of that provider stays sealed and ready and the member reads signed in again after a restart.
+        await this.keys.remove(member, { provider });
     }
     // The member an agent id or session key belongs to, through the account index (5.15, O14m). Reads the index file, so it
     // needs no live gateway.
@@ -1049,6 +1072,32 @@ export class OpenClawKit {
     addKey(agentId, o) {
         return this.keys.add(agentId, o);
     }
+    // The lane's index entry follows its sealed key. A failed write is logged and never fails the add; the start sweep repairs it.
+    async indexKeyLane(member, route) {
+        if (!this.accountsCtl) {
+            this.o.log?.('addKey: the account index is not ready, so the key lane is indexed at the next connect');
+            return;
+        }
+        await this.accountsCtl.key(member, route).catch((error) => this.o.log?.(`addKey: the key lane is not indexed yet: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    /** Remove this member's saved key (the `byokit-key-<member>` lane: its credential store and ready marker), so
+     * `signedIn` is false for it and a restart cannot revive it. `provider` removes only that provider's saved key;
+     * with no saved key the call resolves without doing anything. */
+    removeKey(member, o) {
+        return this.keys.remove(member, o);
+    }
+    // The lane's index entry follows its sealed key down. A failed drop is logged and never fails the removal.
+    async dropKeyLane(member, provider) {
+        if (!this.accountsCtl) {
+            this.o.log?.('removeKey: the account index is not ready, so the key lane entry stays until the next removal');
+            return;
+        }
+        await this.accountsCtl.unkey(member, provider).catch((error) => this.o.log?.(`removeKey: the key lane entry is not dropped yet: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    async backfillKeyLane(member, model) {
+        const found = model === undefined ? [] : routeTable().filter((r) => r.keyEntry && r.readiness === 'ready' && r.provider === providerOf(model));
+        await this.accountsCtl?.backfill(member, found).catch((error) => this.o.log?.(`key lane ${member}: not indexed yet: ${error instanceof Error ? error.message : String(error)}`));
+    }
     async prepareKeyOwner(agentId) {
         this.syncCatalogs();
         await this.catalogs;
@@ -1144,6 +1193,7 @@ export class OpenClawKit {
             });
         return this.runs().run(spec, on, undefined, output);
     }
+    // An API-key run's session is on the key lane (Runs step 2).
     runKey(sessionKey, o) {
         if (o?.auth !== 'apiKey')
             return sessionKey;
@@ -1152,7 +1202,7 @@ export class OpenClawKit {
             throw new Error('Choose your own conversation.');
         return `agent:${keyAgentId(member)}:${tail}`;
     }
-    steer(sessionKey, text, o) {
+    async steer(sessionKey, text, o) {
         return this.runs().steer(this.runKey(sessionKey, o), text);
     }
     async abort(sessionKey, o) {

package/dist/link.js

@@ -322,12 +322,16 @@ export function openclawLink(kit, o) {
                 drives.get(key)?.cancel();
                 const view = { state: 'waiting', via: args.via };
                 latest.set(key, view);
-                const drive = kit.signIn(member, { authChoice: route.choice, via: args.via }, (next) => {
-                    latest.set(key, next);
-                });
+                // A superseded attempt (still activating past its commit point) never writes over the newer one's view.
+                let drive;
+                const current = () => drive !== undefined && drives.get(key) === drive;
+                drive = kit.signIn(member, { authChoice: route.choice, via: args.via }, (next) => { if (current())
+                    latest.set(key, next); });
                 drives.set(key, drive);
-                void drive.done.then((done) => { latest.set(key, done); if (drives.get(key) === drive)
-                    drives.delete(key); }, () => { if (drives.get(key) === drive)
+                void drive.done.then((done) => { if (current()) {
+                    latest.set(key, done);
+                    drives.delete(key);
+                } }, () => { if (current())
                     drives.delete(key); });
                 return latest.get(key);
             }
@@ -336,7 +340,9 @@ export function openclawLink(kit, o) {
                     throw new Error('oc.signin.view needs { provider }');
                 // `ready` is the member's account (signed in to this provider), not the engine: `phaseOf` reads it as done.
                 const key = `${member}:${args.provider}`;
-                const ready = kit.state.phase === 'ready' && await kit.signedIn(member, args.provider);
+                // Native Claude is ready only once this attempt's live activation settles.
+                const native = args.provider === 'claude-cli';
+                const ready = kit.state.phase === 'ready' && await kit.signedIn(member, args.provider) && (!native || (!drives.has(key) && latest.get(key)?.state !== 'failed'));
                 // A finished sign-in whose account is gone since (signed out anywhere, or dropped by the engine) is no
                 // sign-in to show: without this the view says done while `ready` says no, which phaseOf reads as opening.
                 if (!ready && !drives.has(key) && latest.get(key)?.state === 'done')

package/dist/pick.js

@@ -154,6 +154,10 @@ export function resolveSelection(accounts, defaults, sel, room, nowMs, models, b
     const rests = eligible.filter((c) => c.row.out === 'resting');
     if (rests.length)
         return restingPick(rests.reduce((a, b) => ((b.row.until ?? Infinity) < (a.row.until ?? Infinity) ? b : a)));
+    // An empty `bound` (a member-agent conversation holding no indexed account) names no provider: every account is
+    // signed in somewhere else, so the provider-specific sentence would mislead.
+    if (bound !== undefined && !bound.length)
+        return { ok: false, code: 'none', reason: words('auto.noneBound'), considered };
     return { ok: false, code: 'none', reason: words('auto.none', { provider: provider ?? '' }), considered };
     function finish(account, row, how, why) {
         const listed = models?.(account);

package/dist/runs.js

@@ -6,6 +6,7 @@ import { outputSchema } from "./output.js";
 import { words } from "./words.js";
 import { classify } from "./classify.js";
 import { providerOf } from "./pick.js";
+import { catalogModelOf, clampThinking, levelsOf } from "./thinking.js";
 // The gateway gives up on a silent run after an hour; we wait ten minutes longer for the reply frame itself.
 const WAIT_MS = 3_600_000;
 const WAIT_CLIENT_MS = 3_610_000;
@@ -109,7 +110,7 @@ export function createRuns(ctx) {
         const tail = spec.sessionKey.slice(spec.sessionKey.indexOf(':', 'agent:'.length) + 1);
         // Runs step 1 (5.15): every run first finds the account its session is bound to, the API-key lane included.
         const binding = ctx.accounts ? await ctx.accounts.bind(spec.member, spec.sessionKey) : undefined;
-        // Step 2 on the API-key lane: only an API-billed conversation continues on its key; any other binding is refused.
+        // Step 2 on the API-key lane: its own lane binding continues; any other binding is refused.
         if (keyAgent && ctx.accounts && binding) {
             const message = await ctx.accounts.keyRefusal(spec.member, binding);
             if (message !== undefined)
@@ -119,8 +120,8 @@ export function createRuns(ctx) {
         // session went to another account, so it ends before any event and the caller's retry lands there.
         const moved = async () => !!binding && (await ctx.accounts.bind(spec.member, spec.sessionKey))?.agentId !== binding.agentId;
         const movedEnd = { ok: false, kind: 'other', message: words('run.moved') };
-        // Step 3: with `account` and `needs` both absent, on a key no account agent holds (or an API-key run, whose
-        // binding is API-billed), exactly the run on the agent it always was (a bound key under its shared lock).
+        // Step 3: with `account` and `needs` both absent, on a key no account agent holds (or an API-key run, which binds only
+        // to its lane), exactly the run on the agent it always was (a bound key under its shared lock).
         if ((keyAgent || binding?.id === undefined) && spec.account === undefined && !spec.needs?.length) {
             if (keyAgent)
                 return start(spec, on, { agentId: keyAgent, sessionKey: `agent:${keyAgent}:${tail}`, idempotencyKey, system, picked, output });
@@ -197,6 +198,19 @@ export function createRuns(ctx) {
             return { ...end, until };
         }
     };
+    const thinkingOf = async (picked, asked) => {
+        if (asked === undefined)
+            return undefined;
+        if (!picked)
+            return { asked, used: asked };
+        try {
+            const snap = await ctx.request('config.get', {});
+            return clampThinking(asked, levelsOf(catalogModelOf(snap.config?.models?.providers, picked.provider, picked.model)));
+        }
+        catch {
+            return { asked, used: asked };
+        }
+    };
     const start = async (spec, on, t) => {
         const { agentId, sessionKey, idempotencyKey, system, picked, output, chosen } = t;
         const release = spec.register !== false ? ctx.bridge.register({ sessionKey, member: spec.member }, spec.tools, idempotencyKey) : undefined;
@@ -253,7 +267,9 @@ export function createRuns(ctx) {
                     return { ok: false, kind: 'signed-out', message: `${picked.provider} is not signed in for ${spec.member}` };
             }
             // One `agent` request: its interim `accepted` frame names the run, its final frame (after the run) carries the
-            // run's usage. The wait below still decides how the run ended.
+            // run's usage. The wait below still decides how the run ended. Thinking is clamped to the catalog before the
+            // request so an unsupported level (e.g. Muse's off/high/max) never fails the engine.
+            const thinking = await thinkingOf(picked, spec.thinking);
             let accepted;
             const ack = new Promise((resolve) => { accepted = resolve; });
             // The run id is taken as the accepted frame lands, so no event read after it is missed.
@@ -274,7 +290,7 @@ export function createRuns(ctx) {
                 ...(picked ?? {}),
                 ...(system ? { extraSystemPrompt: system } : {}),
                 ...(spec.images ? { attachments: spec.images.map((image) => ({ mimeType: image.mimeType, content: image.data })) } : {}),
-                ...(spec.thinking ? { thinking: spec.thinking } : {}),
+                ...(thinking !== undefined ? { thinking: thinking.used } : {}),
             }, { expectFinal: true, timeoutMs: WAIT_CLIENT_MS, onAccepted });
             final.catch(() => { }); // a late failure is the wait's to report
             const started = await Promise.race([ack, final]);
@@ -307,7 +323,8 @@ export function createRuns(ctx) {
                 const reported = typeof agentMeta.provider === 'string' && typeof agentMeta.model === 'string'
                     ? `${agentMeta.provider}/${agentMeta.model}`.toLowerCase() : '';
                 return { ok: true, text, ...(parsed ? { data: parsed.data } : {}), ...(usage ? { usage } : {}), ...(planWindow ? { planWindow } : {}),
-                    ...(chosen ? { account: chosen.account.id, model: chosen.model || reported } : {}) };
+                    ...(chosen ? { account: chosen.account.id, model: chosen.model || reported } : {}),
+                    ...(thinking ? { thinking } : {}) };
             }
             if (result.stopReason === 'aborted' || (abortedByEngine && result.status !== 'ok'))
                 return { ok: false, aborted: true };

package/dist/signin.d.ts

@@ -1,3 +1,4 @@
+import type { remoteCliHost } from '@byokit/accounts/cli';
 import { authStatus } from './auth-status.ts';
 import type { GatewayTransport, Member, SignInOptions, SignInView } from './types.ts';
 export type SignInCtx = {
@@ -7,9 +8,12 @@ export type SignInCtx = {
         agentId: string;
     }>;
     callbackPort: number;
+    nativeClaudeLogin?(): ReturnType<typeof remoteCliHost>;
+    resetNativeClaudeLogin?(): Promise<void>;
     onDisconnect?(fn: () => void): () => void;
     authConfig(): string;
     restarted(authBefore: string | undefined, signal?: AbortSignal): Promise<boolean>;
+    stopSignal?: AbortSignal;
     fresh?: boolean;
 };
 /**

package/dist/signin.js

@@ -57,12 +57,14 @@ export function signIn(ctx, member, o, on) {
     };
     let server;
     let sessionId = '';
+    let native;
+    let nativeId;
     let starting;
     let releasing;
     let settleStart;
     const startingSettled = new Promise((resolve) => { settleStart = resolve; });
     let over = false;
-    let activating = false;
+    let committed = false; // the commit point of the native and key drives: set just before setup.activate
     let recovering = false;
     let offDisconnect;
     let agentId;
@@ -127,6 +129,7 @@ export function signIn(ctx, member, o, on) {
         stopApproval();
         offDisconnect?.();
         o.signal?.removeEventListener('abort', cancel);
+        ctx.stopSignal?.removeEventListener('abort', cancel);
         owner.abort();
         returned = undefined;
         pasteIn = undefined;
@@ -142,8 +145,16 @@ export function signIn(ctx, member, o, on) {
             // session only as `openclaw.setup.auth.start` settles, so a cancel sent sooner is answered `wizard not found`
             // and leaves the person locked out of signing in. Waiting for that settlement is what frees the admission.
             await startingSettled;
-            if (sessionId)
-                await Promise.resolve().then(() => ctx.request('wizard.cancel', { sessionId }, { timeoutMs: CANCEL_MS })).catch(() => { });
+            if (nativeId)
+                await native?.cancel(nativeId).catch(() => { });
+            if (!sessionId)
+                return;
+            const answer = await Promise.resolve().then(() => ctx.request('wizard.cancel', { sessionId }, { timeoutMs: CANCEL_MS })).catch(() => undefined);
+            // The pin answers `cancelled` at once but frees the admission only once the cancelled runner and its setup-target
+            // lock settle, and answers wizard.status on that session only after that: done waits for it (CANCEL_MS at most).
+            // Not covered: a `running` answer (its commit under way) and a session the engine purged at the cancel.
+            if (answer?.status === 'cancelled')
+                await Promise.resolve().then(() => ctx.request('wizard.status', { sessionId }, { timeoutMs: CANCEL_MS })).catch(() => { });
         })();
         return releasing;
     };
@@ -162,12 +173,17 @@ export function signIn(ctx, member, o, on) {
         if (signal.aborted)
             return;
         owner.abort();
-        void (async () => { await release(); if (!activating)
+        void (async () => { await release(); if (!committed)
             await finish(cancelled()); })();
     };
     o.signal?.addEventListener('abort', cancel, { once: true });
     if (o.signal?.aborted)
         cancel();
+    // An engine shutdown before the commit point is this drive's decline too: without it a key paste would sit out
+    // its 15-minute paste wait after the engine is gone.
+    ctx.stopSignal?.addEventListener('abort', cancel, { once: true });
+    if (ctx.stopSignal?.aborted)
+        cancel();
     /** Hold 127.0.0.1:<callbackPort> for the sign-in's life; a taken port is why the sign-in cannot start. */
     const holdCallback = () => {
         let took = false;
@@ -219,9 +235,53 @@ export function signIn(ctx, member, o, on) {
             settleStart();
             let apiKey;
             if (o.authChoice === 'anthropic-cli') {
-                const detected = await ctx.request('openclaw.setup.detect', { agentId }, { timeoutMs: STATUS_MS });
-                if (!detected.candidates?.some((candidate) => candidate.kind === 'claude-cli' && candidate.credentials === true))
-                    return { state: 'failed', via, why: 'failed', error: 'Sign in with Claude Code on this machine in the kit’s isolated HOME, then try again. The login stays in Claude Code.' };
+                const detected = async () => {
+                    const value = await ctx.request('openclaw.setup.detect', { agentId }, { timeoutMs: STATUS_MS, signal });
+                    return value.candidates?.some(candidate => candidate.kind === 'claude-cli' && candidate.credentials === true);
+                };
+                native = ctx.nativeClaudeLogin?.();
+                if (!await detected()) {
+                    if (!native)
+                        return { state: 'failed', via, why: 'failed', error: 'Claude Code sign-in is not available on this engine.' };
+                    let started = await native.start('claude', { signal });
+                    let ready = false;
+                    if (!started.ok && started.error === 'already') {
+                        ready = Boolean(await detected());
+                        if (!ready && ctx.resetNativeClaudeLogin) {
+                            if (signal.aborted || native.signal.aborted)
+                                return cancelled();
+                            await ctx.resetNativeClaudeLogin();
+                            started = await native.start('claude', { signal });
+                        }
+                    }
+                    if (!ready) {
+                        if (!started.ok)
+                            return { state: 'failed', via, why: started.error === 'busy' ? 'busy' : started.error === 'cancelled' ? 'declined' : 'failed', error: started.words };
+                        nativeId = started.signIn.id;
+                        if (signal.aborted) {
+                            await native.cancel(nativeId);
+                            return cancelled();
+                        }
+                        let pasteFailed = false;
+                        pasteIn = text => { void native.paste(nativeId, text).catch((error) => { if (error.remoteCliProblem === 'unknown')
+                            return; pasteFailed = true; void native.cancel(nativeId).catch(() => { }); }); };
+                        say({ url: started.signIn.verificationUri, prompt: 'Paste the code from the sign-in page' });
+                        if (returned !== undefined) {
+                            pasteIn(returned);
+                            returned = undefined;
+                        }
+                        const result = await native.wait(nativeId);
+                        pasteIn = undefined;
+                        if (signal.aborted)
+                            return cancelled();
+                        if (pasteFailed)
+                            return { state: 'failed', via, why: 'failed', error: 'The sign-in code could not be sent. Try again.' };
+                        if (!result.ok)
+                            return { state: 'failed', via, why: result.error === 'expired' ? 'expired' : result.error === 'cancelled' ? 'declined' : 'failed', error: result.words };
+                        if (!await detected())
+                            return { state: 'failed', via, why: 'failed', error: 'Claude Code is still signed out on this engine. Try again.' };
+                    }
+                }
             }
             else {
                 say({ prompt: keyRoute?.billing === 'api' ? 'API key (billed per use)' : 'Plan key' });
@@ -239,21 +299,19 @@ export function signIn(ctx, member, o, on) {
                     return { state: 'failed', via, why: signal.aborted ? 'declined' : 'expired' };
                 secret = apiKey.trim() || undefined;
             }
-            if (signal.aborted)
-                return { state: 'failed', via, why: 'declined' };
-            // Done waits for the gateway restart an `auth` change causes (activation.ts); a run started before it runs on the
-            // old config. A restart that runs late or is cancelled ends failed, and the account is cleaned up by the caller.
-            activating = true;
-            const result = await activate(ctx, {
-                agentId, kind: apiKey === undefined ? 'claude-cli' : 'api-key',
-                ...(apiKey === undefined ? {} : { authChoice: o.authChoice, apiKey }),
-            }, { timeoutMs: PULL_MS, signal }).finally(() => { activating = false; });
+            // The commit point: a phone cancel or host shutdown that landed before it activates nothing. Done waits for the gateway restart an `auth` change causes (activation.ts).
+            // For Claude only host shutdown cuts that wait; a late restart has persisted the route and says saved. A key's cancel still declines its wait; a late key keeps the shared words.
+            if (signal.aborted || native?.signal.aborted)
+                return cancelled();
+            committed = true;
+            const result = await activate(ctx, { agentId, kind: apiKey === undefined ? 'claude-cli' : 'api-key', ...(apiKey === undefined ? {} : { authChoice: o.authChoice, apiKey }), }, { timeoutMs: PULL_MS, signal: apiKey === undefined ? native?.signal : signal });
+            if (apiKey !== undefined && signal.aborted)
+                return cancelled();
             if (result.late)
-                return signal.aborted ? cancelled() : { state: 'failed', via, why: 'failed', error: LATE_RESTART };
+                return { state: 'failed', via, why: 'failed', error: apiKey === undefined ? words('signin.savedNotRestarted') : LATE_RESTART };
             if (!result.ok)
-                return { state: 'failed', via, why: 'failed',
-                    error: apiKey === undefined ? clean(result.error ?? 'Claude Code activation failed') : keyFailed(result.status) };
-            return signal.aborted ? cancelled() : { state: 'done', via };
+                return { state: 'failed', via, why: 'failed', error: apiKey === undefined ? clean(result.error ?? 'Claude Code activation failed') : keyFailed(result.status) };
+            return { state: 'done', via };
         }
         // The client chooses the wizard id; cancellation waits for the engine to register it.
         sessionId = `byokit-${randomUUID()}`;
@@ -441,11 +499,11 @@ export function signIn(ctx, member, o, on) {
         try {
             const driven = await Promise.race([drive(), disconnected]);
             view = driven ?? await recover();
-            if (signal.aborted)
+            if (!committed && (signal.aborted || native?.signal.aborted))
                 view = codeExpired ? expired() : cancelled();
         }
         catch (error) {
-            if (signal.aborted)
+            if (!committed && (signal.aborted || native?.signal.aborted))
                 view = codeExpired ? expired() : cancelled();
             else if (sawDeviceCode && /expired_token|code.*expired|device.*(?:expired|timed out)/i.test(cut(error)))
                 view = expired();

package/dist/testing/fake-gateway.js

@@ -385,6 +385,25 @@ export function fakeGateway(script, o) {
             models.delete(id);
             return { ok: true, agentId: id, removedBindings: 0 };
         },
+        // model: null clears the agent's primary (config.patch cannot delete a key); a string sets it.
+        'agents.update': (p) => {
+            const id = String(p.agentId ?? '');
+            if (!id)
+                throw new Error('agents.update requires agentId');
+            if ('model' in p) {
+                const entries = configBox.config.agents?.entries;
+                if (p.model === null) {
+                    models.delete(id);
+                    if (entries?.[id] && 'model' in entries[id])
+                        delete entries[id].model;
+                }
+                else if (typeof p.model === 'string')
+                    setPrimaryOfId(id, p.model);
+                else
+                    throw new Error('agents.update model must be a string or null');
+            }
+            return { ok: true, agentId: id };
+        },
         'agents.files.get': (p) => fileAnswer(String(p.agentId), String(p.name)),
         'agents.files.set': (p) => {
             filesOf(String(p.agentId)).files.set(String(p.name), String(p.content));
@@ -447,9 +466,11 @@ export function fakeGateway(script, o) {
         'byokit.keys': (p) => {
             const id = `byokit-key-${p.member}`;
             if (p.action === 'prepare' || p.action === 'clear') {
+                // As the shipped plugin: a clear of a lane that was never created has nothing to drop and reports absent.
+                const lane = keys.has(id) || agents.has(id);
                 keys.delete(id);
                 ensureAgent(id).providers = [];
-                return { ok: true };
+                return lane ? { ok: true } : { ok: false, absent: true };
             }
             const key = keys.get(id);
             if (!key)

package/dist/thinking.d.ts

@@ -0,0 +1,16 @@
+import type { ThinkingAsked, ThinkingReport, ThinkingUsed } from './types.ts';
+export type CatalogModel = {
+    id?: string;
+    thinkingLevelMap?: Record<string, string | null | undefined>;
+    compat?: {
+        supportedReasoningEfforts?: readonly string[] | null;
+    };
+};
+/** Supported thinking level ids from one catalog model row, or undefined when the catalog names none. */
+export declare function levelsOf(model: CatalogModel | undefined): ThinkingUsed[] | undefined;
+/** Nearest supported level for `asked`. Empty/absent catalog levels leave `asked` unchanged. */
+export declare function clampThinking(asked: ThinkingAsked, supported: readonly ThinkingUsed[] | undefined): ThinkingReport;
+/** The catalog row for `provider`/`modelId` in a `config.get` models.providers map. */
+export declare function catalogModelOf(providers: Record<string, {
+    models?: CatalogModel[];
+}> | undefined, provider: string, modelId: string): CatalogModel | undefined;

package/dist/thinking.js

@@ -0,0 +1,62 @@
+const ORDER = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+/** Supported thinking level ids from one catalog model row, or undefined when the catalog names none. */
+export function levelsOf(model) {
+    if (!model)
+        return undefined;
+    const efforts = model.compat?.supportedReasoningEfforts;
+    if (Array.isArray(efforts) && efforts.length > 0) {
+        const out = [];
+        const seen = new Set();
+        for (const raw of ['off', ...efforts]) {
+            const id = raw === 'none' ? 'off' : raw;
+            if (!ORDER.includes(id) || seen.has(id))
+                continue;
+            seen.add(id);
+            out.push(id);
+        }
+        return out.length ? out : undefined;
+    }
+    const map = model.thinkingLevelMap;
+    if (!map)
+        return undefined;
+    const out = ORDER.filter((level) => {
+        const mapped = map[level];
+        if (mapped === null)
+            return false;
+        if (level === 'xhigh' || level === 'max')
+            return mapped !== undefined;
+        return true;
+    });
+    return out.length ? out : undefined;
+}
+/** Nearest supported level for `asked`. Empty/absent catalog levels leave `asked` unchanged. */
+export function clampThinking(asked, supported) {
+    if (!supported?.length)
+        return { asked, used: asked };
+    if (supported.includes(asked))
+        return { asked, used: asked };
+    const candidates = asked === 'off' ? supported : supported.filter((level) => level !== 'off');
+    const pool = candidates.length ? candidates : supported;
+    const at = ORDER.indexOf(asked);
+    if (at >= 0) {
+        for (let i = at; i < ORDER.length; i++) {
+            const level = ORDER[i];
+            if (pool.includes(level))
+                return { asked, used: level };
+        }
+        for (let i = at - 1; i >= 0; i--) {
+            const level = ORDER[i];
+            if (pool.includes(level))
+                return { asked, used: level };
+        }
+    }
+    return { asked, used: pool[0] };
+}
+/** The catalog row for `provider`/`modelId` in a `config.get` models.providers map. */
+export function catalogModelOf(providers, provider, modelId) {
+    const rows = providers?.[provider]?.models;
+    if (!rows)
+        return undefined;
+    const needle = modelId.includes('/') ? modelId.slice(modelId.indexOf('/') + 1) : modelId;
+    return rows.find((row) => row.id === needle || row.id === modelId || row.id === `${provider}/${needle}`);
+}

package/dist/types.d.ts

@@ -102,6 +102,13 @@ export type PlanWindow = {
         resetAt?: number;
     }[];
 };
+/** Thinking levels a run may ask for (`RunSpec.thinking`) and the level the kit actually sent. */
+export type ThinkingAsked = 'off' | 'low' | 'medium' | 'high';
+export type ThinkingUsed = ThinkingAsked | 'minimal' | 'xhigh' | 'max';
+export type ThinkingReport = {
+    asked: ThinkingAsked;
+    used: ThinkingUsed;
+};
 export type RunEnd<T = unknown> = {
     ok: true;
     text: string;
@@ -110,6 +117,7 @@ export type RunEnd<T = unknown> = {
     planWindow?: PlanWindow;
     account?: AccountId;
     model?: string;
+    thinking?: ThinkingReport;
 } | {
     ok: false;
     aborted: true;

package/dist/words.json

@@ -21,6 +21,7 @@
     "signin.returned": "Thanks. Finishing the sign-in — you can go back to the app now.",
     "signin.busy": "Another sign-in is already in progress. Finish or cancel it, then try again.",
     "signin.cancelled": "Sign-in cancelled. You can start again whenever you are ready.",
+    "signin.savedNotRestarted": "Your Claude sign-in was saved, but the engine did not restart in time. Try again.",
     "signin.expired": "The sign-in took too long. Start it again.",
     "signin.title": "Sign in to {site}",
     "signin.takeover": "Take over to sign in",
@@ -81,6 +82,7 @@
     "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.",
+    "auto.noneBound": "No account in this conversation is signed in.",
     "room.unknown": "Room left unknown",
     "room.session": "{left} left this session",
     "room.week": "{left} left this week",
@@ -110,10 +112,12 @@
     "account.another": "another account",
     "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.",
+    "account.indexDamaged": "The account list for {member} couldn't be opened, so those accounts are paused. Add the account again to fix this.",
     "move.unsupported": "This conversation has not started yet, so there is nothing to move.",
     "move.busy": "Wait for this conversation to finish before moving it.",
     "move.notReady": "Sign in to {name} first.",
     "move.closeFailed": "This conversation now continues on {name}, but its earlier copy could not be removed.",
     "move.taken": "{name} already holds a conversation under this name, so nothing was moved.",
-    "run.moved": "This conversation just moved to another account. Send it again to continue there."
+    "run.moved": "This conversation just moved to another account. Send it again to continue there.",
+    "run.thinkingClamped": "Thinking set to {used} because this model does not support {asked}."
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "The OpenClaw runtime kit: the pinned engine's full operator surface with plain-words helpers for members, sign-in, runs and approvals.",
   "license": "Apache-2.0",
   "type": "module",
@@ -60,6 +60,7 @@
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"
   },
   "dependencies": {
+    "@byokit/accounts": "0.23.0",
     "@byokit/pair": "0.10.0",
     "@byokit/relay": "0.6.1",
     "@byokit/discover": "0.8.1",

package/plugin/keys.js

@@ -19,8 +19,9 @@ export function registerKeys(api) {
       if (diagnostics) diagnostics.stage = 'config';
       const config = JSON.parse(await readFile(process.env.OPENCLAW_CONFIG_PATH, 'utf8'));
       const keyId = `byokit-key-${member}`;
-      if (!config.agents?.entries?.[member] || !config.agents?.entries?.[keyId]) {
-        reply({ ok: false });
+      // A clear for a lane that was never created (or whose entries are gone) has nothing left to drop and reports absent.
+      if (!config.agents?.entries?.[keyId] || (params.action !== 'clear' && !config.agents?.entries?.[member])) {
+        reply(params.action === 'clear' ? { ok: false, absent: true } : { ok: false });
         return;
       }
       const keyDir = resolveAgentDir(config, keyId);