@byokit/openclaw 0.25.0 → 0.26.1

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## Unreleased
 
+## 0.26.1 (2026-10-21)
+
+- FIX: a key sign-in through `@byokit/openclaw` no longer fires one slow `openclaw.setup.detect` per reader: the
+  readiness read, the account list and a sign-in share one detection per agent (one probe in flight, its answer reused
+  briefly, and every sign-in, sign-out, key change and account change drops it), and the pin's own status and the
+  detection now run together. The app's poll after a sign-in costs one probe instead of fifteen.
+- FIX: a key lane lists the models the provider's live catalog offers, so a model the picker showed (MiniMax Flash)
+  stays listed and pickable instead of being refused as "not included" while the engine's own list still lags the
+  registration. The kit keeps no model list of its own: the rows are the ones it registered from the live catalog.
+- FIX: an OpenRouter key sign-in now registers the provider's live list beside the model the person chose, so the
+  member keeps every model the vendor lists to pick from (the MiniMax models, `minimax/minimax-m3.1-flash` and its
+  free variant, among them) and `openrouter/auto` stays beside them. The engine's catalog stops at a registered list,
+  so an add that registered the chosen model alone left the member with that one row and nothing else to pick from.
+  The rows are deduped by the id the engine keeps, so the Google preview pair is one row and the list is never
+  refused, and the chosen model is registered on its own as well, so a list the engine refuses never costs the member
+  their own choice.
+
+## 0.26.0 (2026-10-20)
+
+- Dependency update: pins @byokit/accounts 0.30.0.
+
+- FEAT: every key route now lists its own models: `kit.models(member, { authChoice })` answers the provider plugin's catalog joined by the vendor's own `/models` (not only OpenCode Go, OpenRouter and MiniMax), and `addKey({ ..., model })` takes any full `provider/model` id on any key route. An id the catalog lags is taken with the route's own capabilities instead of being refused; only a route with no catalog at all refuses a model.
+- The bridge's Codex CLI route now names its two model rows itself instead of reading them from `@byokit/accounts`' catalogue, which no longer keeps model tiers; the rows the engine lists are unchanged.
+
 ## 0.25.0 (2026-10-20)
 
 - Dependency update: pins @byokit/accounts 0.29.0.

package/README.md

@@ -159,10 +159,10 @@ other choice that takes no key (a subscription such as `openai`, a provider with
 throws its cause before anything is sent.
 `reason` is `auth` (provider refused the key) or `billing` (the provider's billing refused it; the kit words it and never passes
 provider text): both are `invalid`, and an unchanged key must not be retried. `empty` is a blank key, rejected locally before any
-provider call, also `invalid`. `model` is an unsupported route or unknown model (`not_included`), or a live model the engine did not
+provider call, also `invalid`. `model` is an unsupported route or a model on a route with no catalog (`not_included`), or a model the engine did not
 register (`retry`). `network` is a timeout or transport failure; `inference` is a provider reply in an unexpected format, an unknown
 probe failure, or a typed request-validation refusal; `engine` is a control or preparation failure; `busy` is a rate limit or a
-restarting engine. `not_included` covers an unsupported route, an unknown chosen model and a probe reporting the route unavailable;
+restarting engine. `not_included` covers an unsupported route, a chosen model on a route with no catalog and a probe reporting the route unavailable;
 every other failure is `retry`. Migrate from the old string result with `result.status === 'ok'`, not `result === 'ok'`.
 An OpenCode Go plan login can act for several workspaces, and the Go gateway refuses its every call until one is named
 (`403 Workspace selection is required`). Pass the workspace as `orgId` when you have it; it rides the probe and every run as
@@ -185,16 +185,24 @@ live catalog. Before a key exists it returns `[]` (a failed catalog probe with n
 empty; with one it is an error) and runs no engine discovery. Only available key-lane
 models can be saved; the ordinary member's sign-ins never supply the list. Pass a full catalog id, e.g.
 `model: 'opencode-go/muse-spark-1.3-contributor'`, to `addKey` to save it as the lane's default after activation.
-Model listing and selection belong to the live-catalog routes, OpenCode Go and OpenRouter. An OpenRouter key is
+Every key route lists and takes models: its catalog is the provider plugin's own, joined by the vendor's own `/models`
+list, and the kit keeps no provider or model list. An OpenRouter key is
 pay-as-you-go with no plan, so it takes any model its own live catalog lists, named `openrouter/<id>`, e.g.
 `model: 'openrouter/deepseek/deepseek-v4.1-flash-1017'`; an id already beginning with its own provider keeps one
 prefix (`openrouter/auto`). A Google preview id is named and saved as the canonical id the engine keeps
 (`openrouter/google/gemini-3.1-flash-lite-preview` becomes `openrouter/google/gemini-3.1-flash-lite`); the add
-registers that one model with the engine. Other key routes list no models, and a `model` on them returns
-`not_included`/`model` before activation.
-An unknown model returns `{ status: 'not_included', reason: 'model' }` and clears the replacement.
+registers that one model with the engine (every provider but OpenCode Go and MiniMax, whose whole lists are registered).
+An OpenRouter key add registers the provider's live list beside the chosen model, so the member keeps every model the
+vendor lists to pick from (the MiniMax models, `minimax/minimax-m3.1-flash` and its free variant, among them) and
+`openrouter/auto` stays beside them; the engine's catalog stops at a registered list, so registering the chosen model
+alone would leave the member with that one row. The rows are deduped by the id the engine keeps, so the Google preview
+pair is one row and the list is never refused.
+A vendor's list can lag a model it already runs, so an id the catalog lacks is taken, not refused: it rides the route's
+own models (the richest row's api, base URL and context), unpriced, and the app sees it missing from `models()` to warn.
+A route with no catalog rows (its plugin has none) lists nothing, and a `model` there returns
+`{ status: 'not_included', reason: 'model' }` and clears the replacement.
 Before success, `addKey` waits for catalog registration and prepares the new key agent's full-catalog owner once.
-For a live-catalog provider, a chosen model must also be in the engine's registered `models.providers[provider].models`
+A chosen model must also be in the engine's registered `models.providers[provider].models`
 list before anything is sealed; otherwise the add clears the attempt and returns `{ status: 'retry', reason: 'model' }`.
 Preparation failure clears the attempted key and returns `{ status: 'retry', reason: 'engine' }`; ordinary runs stay unchanged.
 With no choice, today's starter stays.

package/dist/accounts.d.ts

@@ -1,7 +1,11 @@
 import { createLocks } from './locks.ts';
+import type { Detector } from './detect.ts';
 import { type RouteView } from './routes.ts';
 import type { Account, AccountId, AccountPick, Defaults, GatewayTransport, Member, ModelInfo, MoveResult, Room, RunSelection, SignInOptions, SignInView } from './types.ts';
 export declare const kitId: (provider: string, id: string) => string;
+/** The id the engine keeps for a row of `provider` (5.6): a Google preview id (a row of a provider that carries
+ *  Google's models) and a bare id of a provider that names it. Every other id is the vendor's own, kept as it is. */
+export declare const engineModelId: (provider: string, id: string) => string;
 export declare const engineId: (provider: string, model: string, rows: readonly unknown[] | undefined) => string;
 export declare const modelsOf: (provider: string, answer: unknown) => ModelInfo[];
 export declare const modelsOfAccount: (row: Pick<Account, 'provider' | 'state'>, answer: unknown) => ModelInfo[];
@@ -73,6 +77,8 @@ export declare function createAccounts(ctx: {
     }>;
     log?: (line: string) => void;
     reseal?: () => Promise<void>;
+    detect?: Detector;
+    catalog?: (provider: string) => ModelInfo[];
 }): {
     list(member: Member): Promise<Account[]>;
     add(member: Member, o: AddOptions, on: (v: SignInView) => void): Promise<AccountSignIn>;

package/dist/accounts.js

@@ -10,6 +10,7 @@ import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync
 import { randomBytes, randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
+import { detection } from './auth-status.js';
 import { providerOf, resolveSelection } from './pick.js';
 import { agentOf, memberOf as baseMemberOf } from './attribution.js';
 import { KEY_PREFIX, MEMBER_ID, NEW_MEMBER_ID, keyAgentId, untilListed, untilUnlisted } from './members.js';
@@ -19,6 +20,35 @@ const record = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 // A provider-local engine model id as the kit's `provider/model` reference; an id already prefixed with its own
 // provider is left alone.
 export const kitId = (provider, id) => providerOf(id) === provider.toLowerCase() ? id : `${provider}/${id}`;
+// The id the pinned engine keeps for a catalog row: it rewrites a row id when it writes the config. A Google
+// preview id becomes the id Google calls it (`google/gemini-3.1-flash-lite-preview` becomes
+// `google/gemini-3.1-flash-lite`), and a bare id of a provider that names it carries that provider. The kit names
+// every row by the id the engine keeps, so the engine's list and the kit's never disagree, and two rows the engine
+// would keep under one id are one row: a list with both is refused ("Ambiguous duplicate ID").
+const googlePreviewIds = {
+    'gemini-3-pro': 'gemini-3.1-pro-preview',
+    'gemini-3-pro-preview': 'gemini-3.1-pro-preview',
+    'gemini-3.1-pro': 'gemini-3.1-pro-preview',
+    'gemini-3-flash': 'gemini-3-flash-preview',
+    'gemini-3.1-flash': 'gemini-3-flash-preview',
+    'gemini-3.1-flash-preview': 'gemini-3-flash-preview',
+    'gemini-3.1-flash-lite-preview': 'gemini-3.1-flash-lite',
+    'gemma-4-26b': 'gemma-4-26b-a4b-it',
+};
+/** The id the engine keeps for a row of `provider` (5.6): a Google preview id (a row of a provider that carries
+ *  Google's models) and a bare id of a provider that names it. Every other id is the vendor's own, kept as it is. */
+export const engineModelId = (provider, id) => {
+    const at = id.indexOf('/');
+    const maker = at < 0 ? '' : id.slice(0, at);
+    const model = at < 0 ? id : id.slice(at + 1);
+    if (maker === 'google') {
+        const kept = googlePreviewIds[model] ?? model;
+        return kept === model ? id : `${maker}/${kept}`;
+    }
+    if (provider === 'openrouter' && at < 0)
+        return `${provider}/${id}`;
+    return id;
+};
 // The engine's provider-local id for a kit `provider/model` reference, resolved against that provider's rows.
 export const engineId = (provider, model, rows) => {
     for (const row of rows ?? []) {
@@ -538,8 +568,9 @@ export function createAccounts(ctx) {
         return { rows, dirty };
     };
     // A detected Claude Code login has no profile in the kit: it stays in Claude Code. The engine's detection says whether
-    // it is there, and a detected one is the member's signed-in claude-cli profile for this read.
-    const claudeDetected = (agentId) => ctx.request('openclaw.setup.detect', { agentId }, { timeoutMs: 20_000 })
+    // it is there, and a detected one is the member's signed-in claude-cli profile for this read. The shared detection
+    // answers it for every reader (one probe per agent, reused briefly), so a listing and a readiness read cost one probe.
+    const claudeDetected = (agentId) => detection(ctx.request, agentId, ctx.detect)
         .then((r) => r.candidates?.some((c) => c.kind === 'claude-cli' && c.credentials === true) === true, () => false);
     const gather = async (agentId) => {
         const [roster, profiles, claude] = await Promise.all([rosterOf(), profilesOf(agentId), claudeDetected(agentId)]);
@@ -669,8 +700,21 @@ export function createAccounts(ctx) {
         const { row, entry } = await entryOf(member, id);
         return readModels(row, entry);
     }
+    // The account's models: the engine's own rows, joined with the catalog rows the kit registered for that provider
+    // (the provider's live list). The engine's list can lag the registration, and a model the picker offered must
+    // stay pickable: the kit registered it, so the engine can run it. The engine's own row wins where both name it.
+    const withCatalog = (row, own) => {
+        const registered = ctx.catalog?.(row.provider) ?? [];
+        if (!registered.length)
+            return own;
+        const byId = new Map(own.map((m) => [m.id, m]));
+        for (const model of registered)
+            if (!byId.has(model.id))
+                byId.set(model.id, model);
+        return [...byId.values()];
+    };
     // The shared hold covers the read, so no kit read of the agent is in flight while it is removed.
-    const readModels = (row, entry) => ctx.locks.shared(entry.agent, async () => modelsOfAccount(row, await ctx.request('models.list', { agentId: entry.agent, view: 'all' })));
+    const readModels = (row, entry) => ctx.locks.shared(entry.agent, async () => withCatalog(row, modelsOfAccount(row, await ctx.request('models.list', { agentId: entry.agent, view: 'all' }))));
     async function room(member, id, demand) {
         check(member);
         await ctx.ensure(member);

package/dist/auth-status.d.ts

@@ -1,3 +1,4 @@
+import type { Detection, Detector } from './detect.ts';
 import type { GatewayTransport } from './types.ts';
 export type AuthStatus = {
     providers?: (string | {
@@ -14,14 +15,23 @@ export type AuthStatus = {
         message?: unknown;
     };
 };
+/** The engine's setup detection, through the shared detector when the caller has one: one probe per agent, reused
+ * briefly, so a poll that reads readiness and the account list does not pay for the probe twice. A failed probe reads
+ * as no detection: the caller decides what an unknown answer means. */
+export declare const detection: (request: GatewayTransport['request'], agentId: string, detect?: Detector, o?: {
+    fresh?: boolean;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}) => Promise<Detection>;
 /** Native Claude login stays in Claude Code. The pin's profile status does not include this synthetic auth;
- * setup detection asks the CLI itself, without handing credentials to the kit. */
-export declare function authStatus(request: GatewayTransport['request'], agentId: string, refresh?: boolean, native?: boolean): Promise<AuthStatus>;
+ * setup detection asks the CLI itself, without handing credentials to the kit. The detection and the pin's own status
+ * are independent reads, so they run together rather than one after the other. */
+export declare function authStatus(request: GatewayTransport['request'], agentId: string, refresh?: boolean, native?: boolean, detect?: Detector): Promise<AuthStatus>;
 /** Admission snapshots, never credentials: per kit/agent/native route, at most 30s and never past reported expiry.
  * Witness only app-owned file metadata (absence included); changed/unreadable state and auth/lifecycle mutations recheck.
  * Remote revocation still comes from the real run's signed-out error (a local status read cannot prove it either).
  */
-export declare function createAuthStatus(root: string, request: GatewayTransport['request'], codex?: () => Promise<boolean>): {
+export declare function createAuthStatus(root: string, request: GatewayTransport['request'], codex?: () => Promise<boolean>, detect?: Detector): {
     read: (agentId: string, refresh?: boolean, native?: boolean, reuse?: boolean) => Promise<AuthStatus>;
     invalidate: () => void;
 };

package/dist/auth-status.js

@@ -1,16 +1,27 @@
 import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import { signedInProviders, USABLE } from './runs.js';
+/** The engine's setup detection, through the shared detector when the caller has one: one probe per agent, reused
+ * briefly, so a poll that reads readiness and the account list does not pay for the probe twice. A failed probe reads
+ * as no detection: the caller decides what an unknown answer means. */
+export const detection = async (request, agentId, detect, o) => {
+    if (detect)
+        return detect.detect(agentId, { fresh: o?.fresh, timeoutMs: o?.timeoutMs, ...(o?.signal ? { signal: o.signal } : {}) });
+    return await request('openclaw.setup.detect', { agentId }, { timeoutMs: o?.timeoutMs ?? 20_000, ...(o?.signal ? { signal: o.signal } : {}) });
+};
 /** Native Claude login stays in Claude Code. The pin's profile status does not include this synthetic auth;
- * setup detection asks the CLI itself, without handing credentials to the kit. */
-export async function authStatus(request, agentId, refresh = false, native = false) {
-    const status = await request('models.authStatus', { agentId, ...(refresh ? { refresh: true } : {}) }, { timeoutMs: 20_000 });
-    return native ? nativeStatus(request, agentId, status) : status;
+ * setup detection asks the CLI itself, without handing credentials to the kit. The detection and the pin's own status
+ * are independent reads, so they run together rather than one after the other. */
+export async function authStatus(request, agentId, refresh = false, native = false, detect) {
+    const [status, detected] = await Promise.all([
+        request('models.authStatus', { agentId, ...(refresh ? { refresh: true } : {}) }, { timeoutMs: 20_000 }),
+        native ? detection(request, agentId, detect).catch(() => ({})) : undefined,
+    ]);
+    return native ? nativeStatus(status, detected) : status;
 }
-async function nativeStatus(request, agentId, status) {
-    const detected = await request('openclaw.setup.detect', { agentId }, { timeoutMs: 20_000 }).catch(() => ({}));
+function nativeStatus(status, detected) {
     const rows = (status.providers ?? []).filter((row) => (typeof row === 'string' ? row : row.provider) !== 'claude-cli');
-    if (detected.candidates?.some((candidate) => candidate.kind === 'claude-cli' && candidate.credentials === true)) {
+    if (detected?.candidates?.some((candidate) => candidate.kind === 'claude-cli' && candidate.credentials === true)) {
         return { providers: [...rows, { provider: 'claude-cli', status: 'ok' }] };
     }
     return { ...status, providers: rows };
@@ -19,8 +30,9 @@ async function nativeStatus(request, agentId, status) {
  * Witness only app-owned file metadata (absence included); changed/unreadable state and auth/lifecycle mutations recheck.
  * Remote revocation still comes from the real run's signed-out error (a local status read cannot prove it either).
  */
-export function createAuthStatus(root, request, codex) {
+export function createAuthStatus(root, request, codex, detect) {
     const snapshots = new Map();
+    const witnesses = new Map();
     let generation = 0;
     const invalidate = () => { generation++; snapshots.clear(); };
     const witness = (agentId) => {
@@ -54,13 +66,24 @@ export function createAuthStatus(root, request, codex) {
             return cached.status;
         snapshots.delete(key);
         snapshots.delete(`${agentId}:false`);
-        const profiles = await authStatus(request, agentId, refresh);
+        // The detection answers about the same state this witness covers (the engine's own logins), so a changed witness
+        // drops it: the next reader asks the engine again instead of reading an earlier answer.
+        const seen = witnesses.get(agentId);
+        if (before !== undefined)
+            witnesses.set(agentId, before);
+        if (before !== undefined && seen !== undefined && seen !== before)
+            detect?.invalidate(agentId);
+        // The pin's own status and the setup detection are independent reads: they run together, not one after the other.
+        const [profiles, detected] = await Promise.all([
+            authStatus(request, agentId, refresh),
+            native ? detection(request, agentId, detect).catch(() => undefined) : undefined,
+        ]);
         if (codex) {
             profiles.providers = (profiles.providers ?? []).filter(row => (typeof row === 'string' ? row : row.provider) !== 'openai-codex');
             if (await codex())
                 profiles.providers.push({ provider: 'openai-codex', status: 'ok' });
         }
-        const status = native ? await nativeStatus(request, agentId, profiles) : profiles;
+        const status = native ? nativeStatus(profiles, detected) : profiles;
         if (before !== undefined && epoch === generation && witness(agentId) === before) {
             for (const [route, answer] of (native ? [[false, profiles], [true, status]] : [[false, profiles]])) {
                 const usable = signedInProviders(answer);

package/dist/bridge.js

@@ -3,7 +3,6 @@ import { randomBytes } from 'node:crypto';
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createServer } from 'node:net';
 import { rm } from 'node:fs/promises';
-import { provider } from '@byokit/accounts';
 import { words } from './words.js';
 import { HelperError } from './helpers.js';
 /** Newline-framed JSON, one request per connection; anything larger is not a gate request. */
@@ -40,8 +39,9 @@ export function writePlugin(dir, o) {
         name: 'BYOKit bridge',
         activation: { onStartup: true },
         cliBackends: ['openai-codex'],
-        // The Codex CLI route lists the ChatGPT catalogue's models; the engine lists a plugin route's rows only from here.
-        modelCatalog: { providers: { 'openai-codex': { models: [provider('chatgpt').models.strong, provider('chatgpt').models.fast].map((id) => ({ id, name: id })) } }, discovery: { 'openai-codex': 'static' } },
+        // The engine lists a plugin route's rows only from here. Named exception: the Codex CLI's own list (its app-server
+        // `model/list`) is not read yet, so the route names these two ids; a recorded real `model/list` reply lifts it.
+        modelCatalog: { providers: { 'openai-codex': { models: ['gpt-6-sol', 'gpt-6-luna'].map((id) => ({ id, name: id })) } }, discovery: { 'openai-codex': 'static' } },
         contracts: { tools: o.tools.map((t) => t.name), ...(o.browser ? { agentToolResultMiddleware: ['openclaw', 'codex'] } : {}) },
         configSchema: { type: 'object', additionalProperties: false },
     };

package/dist/constants.d.ts

@@ -1,6 +1,5 @@
 export declare const ENGINE_VERSION = "2026.8.35";
 export declare const PROTOCOL_VERSION = 4;
-export declare const LIVE_CATALOGS: string[];
 export declare const REGISTERED_CATALOGS: string[];
-export declare const OPEN_CATALOGS: string[];
+export declare const LIVE_LIST_ADDS: string[];
 export declare const OPERATOR_SCOPES: readonly ['operator.read', 'operator.write', 'operator.admin', 'operator.approvals', 'operator.questions', 'operator.pairing', 'operator.talk'];

package/dist/constants.js

@@ -2,15 +2,15 @@
 // `needs-update`, never silently run.
 export const ENGINE_VERSION = '2026.8.35';
 export const PROTOCOL_VERSION = 4;
-// Providers whose live catalog lists and checks a key's chosen model (5.6), through the catalog hook. OpenRouter is
-// pay-as-you-go: its key takes any model its own catalog lists, with no plan to include it.
-export const LIVE_CATALOGS = ['opencode-go', 'openrouter', 'minimax'];
-// Live catalogs the kit registers whole. The engine canonicalizes Google preview ids on config write, so OpenRouter's
-// list collides with itself (`google/x-preview` and `google/x`); an OpenRouter add registers only the chosen model.
+// Live catalogs (5.6) the kit registers whole; every other key route registers its chosen model alone. The engine
+// canonicalizes Google preview ids on config write, so the rows are deduped by the id it keeps (`engineModelId`)
+// before they are written.
 export const REGISTERED_CATALOGS = ['opencode-go', 'minimax'];
-// Pay-as-you-go catalogs whose vendor list can lag a model that already runs: an id the list lacks is warned about, never
-// refused, and takes the capabilities of the route's own models.
-export const OPEN_CATALOGS = ['minimax'];
+// The providers whose key add registers the provider's live list beside the chosen model, so the member keeps every
+// model the vendor lists to pick from (the chosen model id sits beside the provider's own default, `openrouter/auto`).
+// The engine's catalog stops at a registered list, so an add that registered the chosen model alone would leave the
+// member with that one row and nothing else to pick.
+export const LIVE_LIST_ADDS = ['openrouter'];
 export const OPERATOR_SCOPES = [
     'operator.read',
     'operator.write',

package/dist/detect.d.ts

@@ -0,0 +1,30 @@
+import type { GatewayTransport } from './types.ts';
+export type Detection = {
+    candidates?: {
+        kind?: string;
+        credentials?: boolean;
+    }[];
+};
+export type DetectOptions = {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    fresh?: boolean;
+};
+export type Detector = {
+    /** The engine's setup detection for one agent. `fresh` skips the cache and the in-flight probe: a sign-in that
+     *  verifies what the person just did must read the engine, not an earlier answer. */
+    detect(agentId: string, o?: DetectOptions): Promise<Detection>;
+    /** Drops the cached answer (one agent, or every agent). */
+    invalidate(agentId?: string): void;
+};
+/** How long a detection answer is reused. The answer is a CLI probe the kit cannot witness (the login lives in the
+ *  person's own home), so the window bounds how long an outside sign-in stays unseen; every sign-in, sign-out and
+ *  account change the kit sees drops it at once. */
+export declare const DETECT_TTL_MS = 10000;
+/**
+ * The shared detection. One probe per agent at a time, its answer reused briefly, a failure never cached (the next
+ * reader tries again) and a fresh read never served from the cache.
+ */
+export declare function createDetect(request: GatewayTransport['request'], o?: {
+    ttlMs?: number;
+}): Detector;

package/dist/detect.js

@@ -0,0 +1,39 @@
+/** How long a detection answer is reused. The answer is a CLI probe the kit cannot witness (the login lives in the
+ *  person's own home), so the window bounds how long an outside sign-in stays unseen; every sign-in, sign-out and
+ *  account change the kit sees drops it at once. */
+export const DETECT_TTL_MS = 10_000;
+/**
+ * The shared detection. One probe per agent at a time, its answer reused briefly, a failure never cached (the next
+ * reader tries again) and a fresh read never served from the cache.
+ */
+export function createDetect(request, o) {
+    const ttl = o?.ttlMs ?? DETECT_TTL_MS;
+    const cache = new Map();
+    const inflight = new Map();
+    const detect = (agentId, options = {}) => {
+        const hit = cache.get(agentId);
+        if (!options.fresh && hit && hit.until > Date.now())
+            return Promise.resolve(hit.value);
+        const running = options.fresh ? undefined : inflight.get(agentId);
+        if (running)
+            return running;
+        const call = request('openclaw.setup.detect', { agentId }, { timeoutMs: options.timeoutMs ?? 20_000, ...(options.signal ? { signal: options.signal } : {}) })
+            .then((value) => { cache.set(agentId, { until: Date.now() + ttl, value }); return value; })
+            .finally(() => { if (inflight.get(agentId) === call)
+            inflight.delete(agentId); });
+        inflight.set(agentId, call);
+        return call;
+    };
+    return {
+        detect,
+        invalidate: (agentId) => {
+            if (agentId === undefined) {
+                cache.clear();
+                inflight.clear();
+                return;
+            }
+            cache.delete(agentId);
+            inflight.delete(agentId);
+        },
+    };
+}

package/dist/keys.js

@@ -4,8 +4,8 @@ import { openCodeWorkspaces } from '@byokit/accounts/opencode-go';
 import { activate } from './activation.js';
 import { keyAgentId, MEMBER_ID, KEY_PREFIX, untilListed } from './members.js';
 import { providerOf } from './pick.js';
-import { kitId, modelsOf } from './accounts.js';
-import { LIVE_CATALOGS, OPEN_CATALOGS, REGISTERED_CATALOGS } from './constants.js';
+import { kitId, modelsOf, engineModelId } from './accounts.js';
+import { LIVE_LIST_ADDS } from './constants.js';
 export function createKeys(ctx) {
     // Serialize key replacement and key runs, so an in-flight run never sees a half-installed replacement.
     const tails = new Map();
@@ -58,12 +58,14 @@ export function createKeys(ctx) {
         return ['ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN', 'ETIMEDOUT', 'CLIENT_TIMEOUT', 'NETWORK_ERROR'].includes(e?.code ?? '')
             || e?.name === 'TimeoutError' ? 'network' : 'engine';
     };
-    // The engine writes a Google preview id without its `-preview` suffix, so the kit names the id it keeps.
-    const canonical = (id) => id.startsWith('google/') && id.endsWith('-preview')
-        ? id.slice(0, -'-preview'.length) : id;
+    // The kit's name for a model: the provider and the row id the engine keeps (a model reference already carries its
+    // provider, so the row id is never prefixed twice).
     const canonicalModel = (model) => {
         const at = model.indexOf('/');
-        return at < 0 ? model : `${model.slice(0, at)}/${canonical(model.slice(at + 1))}`;
+        if (at < 0)
+            return model;
+        const provider = model.slice(0, at);
+        return kitId(provider, engineModelId(provider, model.slice(at + 1)));
     };
     // The live catalog's rows, as the engine registers them (provider-local ids, deduped by the id it keeps).
     const catalog = async (member, provider) => {
@@ -74,7 +76,7 @@ export function createKeys(ctx) {
                 throw new Error('Model catalog is unavailable.');
             return [];
         }
-        const rows = (answer.models ?? []).map((m) => ({ ...m, id: canonical(String(m.id)) }));
+        const rows = (answer.models ?? []).map((m) => ({ ...m, id: engineModelId(provider, String(m.id)) }));
         return [...new Map(rows.map((m) => [String(m.id), m])).values()];
     };
     // The key route a choice names: its own, or the only key route of the provider whose other sign-in it names, billed
@@ -96,7 +98,7 @@ export function createKeys(ctx) {
     // The vendor's list can lag a model that runs: an id it lacks rides the route's own models (the richest row's api,
     // base URL and context, every input modality any row takes), unpriced. Nothing is added to an empty list.
     const unlisted = (provider, rows, model) => {
-        if (!rows.length || rows.some((m) => kitId(provider, String(m.id)) === model))
+        if (!rows.length || !model.startsWith(`${provider}/`) || rows.some((m) => kitId(provider, String(m.id)) === model))
             return [];
         const base = rows.reduce((a, b) => (Number(b.contextWindow) || 0) > (Number(a.contextWindow) || 0) ? b : a);
         const input = ['text', 'image'].filter((i) => rows.some((m) => Array.isArray(m.input) && m.input.includes(i)));
@@ -108,7 +110,7 @@ export function createKeys(ctx) {
         if (!check(member))
             throw new Error('Choose your own member.');
         const route = keyRoute(o.authChoice);
-        if (route.readiness !== 'ready' || !LIVE_CATALOGS.includes(route.provider))
+        if (route.readiness !== 'ready')
             return [];
         try {
             return listed(route.provider, await catalog(member, route.provider));
@@ -138,7 +140,7 @@ export function createKeys(ctx) {
                 if (!o.apiKey.trim())
                     return failure('invalid', 'empty');
                 const route = keyRoute(o.authChoice);
-                if (route.readiness !== 'ready' || (o.model !== undefined && !LIVE_CATALOGS.includes(route.provider)))
+                if (route.readiness !== 'ready')
                     return failure('not_included', 'model');
                 const model = o.model === undefined ? undefined : canonicalModel(o.model);
                 // A workspace names a Go login's own workspace only; another route takes no header, and a
@@ -227,7 +229,7 @@ export function createKeys(ctx) {
                         if (result.late)
                             return abandon(failure('retry', 'busy'));
                         const rows = model === undefined ? [] : await catalog(member, route.provider);
-                        const lagging = model !== undefined && OPEN_CATALOGS.includes(route.provider) ? unlisted(route.provider, rows, model) : [];
+                        const lagging = model !== undefined ? unlisted(route.provider, rows, model) : [];
                         rows.push(...lagging);
                         if (model !== undefined && !listed(route.provider, rows).some((m) => m.id === model && m.available))
                             return abandon(failure('not_included', 'model'));
@@ -240,10 +242,16 @@ export function createKeys(ctx) {
                         }
                         if (ac.signal.aborted)
                             return abandon(cancelled());
-                        // A live catalog the kit does not register whole (OpenRouter) registers the chosen model alone.
-                        if (model !== undefined && (!REGISTERED_CATALOGS.includes(route.provider) || lagging.length))
+                        // The provider's live list, for a provider whose add registers it (the engine's catalog stops at a
+                        // registered list, so the chosen model alone would leave the member with that one row to pick): the
+                        // chosen model id sits beside the provider's own default, `openrouter/auto`.
+                        if (model !== undefined && LIVE_LIST_ADDS.includes(route.provider))
+                            await ctx.registerModels(route.provider, rows).catch(() => { });
+                        // The chosen model is registered on its own, whatever the provider's catalog is: a list the engine
+                        // refuses (two rows it would keep under one id) must never cost the member's own choice.
+                        if (model !== undefined)
                             await ctx.registerModels(route.provider, rows.filter((m) => kitId(route.provider, String(m.id)) === model)).catch(() => { });
-                        if (model !== undefined && LIVE_CATALOGS.includes(route.provider) && !(await registered(route.provider, model)))
+                        if (model !== undefined && !(await registered(route.provider, model)))
                             return abandon(failure('retry', 'model'));
                         if (!(await control(member, 'seal', undefined, model)).ok)
                             return abandon(failure('retry', 'engine'));

package/dist/kit.d.ts

@@ -73,6 +73,7 @@ export declare class OpenClawKit {
     private readonly delegations;
     private readonly keys;
     private readonly admission;
+    private readonly detect;
     private readonly approvalsCtl;
     private listeners;
     private off;
@@ -88,6 +89,7 @@ export declare class OpenClawKit {
     private engineExit?;
     private swept;
     private catalogs;
+    private readonly registered;
     browser?: BrowserHost;
     private browserHost?;
     private readonly brokers;

package/dist/kit.js

@@ -15,12 +15,13 @@ import { AuthStoreSealSizeError } from './auth-store.js';
 import { gatewayTransport } from './transport.js';
 import { createMembers } from './members.js';
 import { createHelpers, HELPER_TAIL, HelperError } from './helpers.js';
-import { createAccounts, memberOfAccount } from './accounts.js';
+import { createAccounts, memberOfAccount, modelsOf, engineModelId } from './accounts.js';
 import { createLocks } from './locks.js';
 import { keyAgentId, KEY_PREFIX, MEMBER_ID } from './members.js';
 import { confirmRetainedLogin as confirmLogin, migrateRetainedLogin as migrateLogin } from './migrate.js';
 import { createRuns, RunReplay, signedInProviders } from './runs.js';
 import { authStatus, createAuthStatus } from './auth-status.js';
+import { createDetect } from './detect.js';
 import { outputSchema } from './output.js';
 import { words } from './words.js';
 import { createKeys } from './keys.js';
@@ -457,6 +458,9 @@ export class OpenClawKit {
     delegations;
     keys;
     admission;
+    // One setup detection for every reader (readiness, the account list, a sign-in): the engine's probe asks the
+    // installed CLI itself and takes seconds, so a poll that reads both pays for it once, not once per reader.
+    detect;
     approvalsCtl;
     listeners = new Set();
     off = [];
@@ -472,6 +476,8 @@ export class OpenClawKit {
     engineExit;
     swept = false;
     catalogs = Promise.resolve();
+    // The catalog rows the kit registered, per provider: the provider's live list, as the engine can run it.
+    registered = new Map();
     browser;
     browserHost;
     brokers = new Map();
@@ -679,6 +685,9 @@ export class OpenClawKit {
                 throw new Error(`invalid tool name: ${t.name}`);
         }
         this.o = { ...o, stateDir: canonicalStateDir(o.stateDir) };
+        // The shared detection, above the request path: the witness check and the engine's probe run only when a probe is
+        // really made, so a cached answer costs nothing.
+        this.detect = createDetect((method, params, options) => this.request()(method, params, options));
         this.engine = new Engine({ ...o, pluginId: o.plugin?.id ?? 'byokit', tools: [...o.tools ?? [], ...(o.browser ? [{
                         name: 'request_sign_in', description: 'Ask the person to sign in to the current browser site.',
                         parameters: { type: 'object', additionalProperties: false, properties: {
@@ -688,7 +697,7 @@ export class OpenClawKit {
             ...(o.browser ? { browserConfig: () => this.browserConfig() } : {}),
             gateBuiltins: o.gateBuiltins !== false, spawnEngine: o.spawnEngine !== false,
             onState: (s) => this.setState(s), onExit: () => this.closed('engine exited') });
-        this.admission = createAuthStatus(this.engine.root, (method, params, options) => this.request()(method, params, options), () => this.engine.installedCodexSignedIn());
+        this.admission = createAuthStatus(this.engine.root, (method, params, options) => this.request()(method, params, options), () => this.engine.installedCodexSignedIn(), this.detect);
         this.keys = createKeys({ root: this.engine.root,
             prepareOwner: (agentId) => this.prepareKeyOwner(agentId),
             indexLane: (member, route) => this.indexKeyLane(member, route),
@@ -760,8 +769,10 @@ export class OpenClawKit {
         slot.bridge = this.bridge;
     }
     setState(s) {
-        if (s.phase !== 'ready')
+        if (s.phase !== 'ready') {
             this.admission?.invalidate();
+            this.detect?.invalidate();
+        }
         this.current = { ...s, ...(this.engine.patchSet !== undefined ? { patchSet: this.engine.patchSet } : {}) };
         this.o.onState?.(this.current);
         for (const fn of this.phaseListeners)
@@ -850,7 +861,8 @@ export class OpenClawKit {
             this.accountsCtl = createAccounts({ request: (method, params, o) => this.request()(method, params, o), root: this.engine.root,
                 ensure: (member) => this.ensureMember(member), locks: this.locks,
                 signIn: (agentId, o, on, fresh) => startSignIn({ ...this.signInCtx(), ensure: async () => ({ agentId }), fresh }, agentId, o, on),
-                routes: this.routeMap, log: this.o.log, reseal: () => this.engine.authStore.reseal() });
+                routes: this.routeMap, log: this.o.log, reseal: () => this.engine.authStore.reseal(), detect: this.detect,
+                catalog: (provider) => this.registered.get(provider) ?? [] });
             this.helpersCtl = createHelpers({ root: this.engine.root, list: (member) => this.accounts(member) });
             // The fail-closed tool bridge feeds the kit's single Approval surface (5.9, O5).
             await Promise.race([this.bridge.start(), exit]);
@@ -1038,11 +1050,23 @@ export class OpenClawKit {
                 await this.start();
                 return this.request()(method, params, options);
             }
+            // An account change (a sealed, cleared or adopted account) moves the detection too: a Claude Code login the
+            // person just made is an account the kit now knows about. A read of the accounts changes nothing.
+            if (method === 'byokit.accounts') {
+                const action = params?.action;
+                if (action !== 'list' && action !== 'ready')
+                    this.detect.invalidate();
+            }
             const changesAuth = /^(models\.authLogout|openclaw\.setup\.(auth\.start|activate)|wizard\.(next|cancel)|config\.(apply|patch|set)|agents\.(create|update|delete)|secrets\.(reload|store\.(set|delete))|byokit\.keys)$/.test(method);
             if (!changesAuth || (method === 'byokit.keys' && params?.action === 'ready'))
                 return transport.request(method, params, options);
             this.admission.invalidate();
-            return Promise.resolve().then(() => transport.request(method, params, options)).finally(() => this.admission.invalidate());
+            // A sign-in, a sign-out or a key change moves the detection too: its answer is about this engine's logins.
+            this.detect.invalidate();
+            return Promise.resolve().then(() => transport.request(method, params, options)).finally(() => {
+                this.admission.invalidate();
+                this.detect.invalidate();
+            });
         };
     }
     call(method, params, o) {
@@ -1117,6 +1141,7 @@ export class OpenClawKit {
         return { request: (method, params, o) => this.request()(method, params, o),
             // 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),
+            detect: this.detect,
             ensure: (member) => this.ensureMember(member), callbackPort: this.o.callbackPort ?? 1455,
             nativeClaudeLogin: () => this.engine.nativeClaudeLogin(),
             resetNativeClaudeLogin: () => this.engine.resetNativeClaudeLogin(),
@@ -1361,14 +1386,19 @@ export class OpenClawKit {
                 this.o.log?.(`catalog sync ${provider}: failed`); });
         }
     }
-    // Merges catalog rows into the registered list by id; an unchanged list is never rewritten.
+    // Merges catalog rows into the registered list by the id the engine keeps (it rewrites a Google preview id when it
+    // writes the config, so two rows it would keep under one id are one row and never a refused write); an unchanged
+    // list is never rewritten.
     async registerModels(provider, rows) {
         const { config } = await this.request()('config.get');
         const registered = config?.models?.providers?.[provider]?.models ?? [];
-        const byId = new Map(registered.map((m) => [m.id, m]));
+        const byId = new Map(registered.map((m) => { const id = engineModelId(provider, m.id); return [id, { ...m, id }]; }));
         for (const m of rows)
-            byId.set(m.id, m);
+            byId.set(engineModelId(provider, m.id), { ...m, id: engineModelId(provider, m.id) });
         const models = [...byId.values()];
+        // What the kit registered is what the engine can run for that provider: the account list joins it, so a model
+        // the live catalog offers is pickable even while the engine's own list still lags the registration.
+        this.registered.set(provider, modelsOf(provider, { models: models.map((m) => ({ ...m, provider })) }));
         if (!isDeepStrictEqual(models, registered))
             await this.patchConfig({ models: { providers: { [provider]: { models } } } });
     }

package/dist/signin.d.ts

@@ -1,9 +1,11 @@
 import type { remoteCliHost } from '@byokit/accounts/cli';
 import { authStatus } from './auth-status.ts';
+import type { Detector } from './detect.ts';
 import type { CliLoginCause, GatewayTransport, Member, SignInOptions, SignInView } from './types.ts';
 export type SignInCtx = {
     request: GatewayTransport['request'];
     authStatus?: (agentId: string, refresh: boolean, native: boolean) => ReturnType<typeof authStatus>;
+    detect?: Detector;
     ensure(member: Member): Promise<{
         agentId: string;
     }>;

package/dist/signin.js

@@ -3,7 +3,7 @@
 import { randomUUID } from 'node:crypto';
 import { createServer } from 'node:http';
 import { activate, LATE_RESTART } from './activation.js';
-import { authStatus } from './auth-status.js';
+import { authStatus, detection } from './auth-status.js';
 import { routes } from './routes.js';
 import { signedInProviders } from './runs.js';
 import { words } from './words.js';
@@ -134,6 +134,9 @@ export function signIn(ctx, member, o, on) {
         returned = undefined;
         pasteIn = undefined;
         await closeCallback();
+        // A drive moves the login state, so the shared detection is dropped: the next reader asks the engine.
+        if (agentId !== undefined)
+            ctx.detect?.invalidate(agentId);
         if (sensitive && view.state === 'failed' && view.why === 'failed')
             view = { ...view, error: secretFailure };
         on(view);
@@ -222,6 +225,10 @@ export function signIn(ctx, member, o, on) {
                 return { state: 'failed', via, why: 'busy' };
         }
         ({ agentId } = await ctx.ensure(member));
+        // A drive moves the login state, so the shared detection is dropped before it reads one: the drive's own decision
+        // (is a Claude Code login there?) must be the engine's answer now, not an earlier one.
+        if (agentId !== undefined)
+            ctx.detect?.invalidate(agentId);
         if (reconfirm && ctx.onDisconnect) {
             before = profiles(await authStatus(ctx.request, agentId).catch(() => undefined), false);
             if (signal.aborted)
@@ -235,8 +242,11 @@ export function signIn(ctx, member, o, on) {
             settleStart();
             let apiKey;
             if (o.authChoice === 'anthropic-cli') {
+                // The drive reads the engine, never a reused answer: what it decides (is a Claude Code login there? did the
+                // one the person just made land?) must be the engine's answer now.
+                const probe = agentId;
                 const detected = async () => {
-                    const value = await ctx.request('openclaw.setup.detect', { agentId }, { timeoutMs: STATUS_MS, signal });
+                    const value = await detection(ctx.request, probe, ctx.detect, { fresh: true, signal, timeoutMs: STATUS_MS });
                     return value.candidates?.some(candidate => candidate.kind === 'claude-cli' && candidate.credentials === true);
                 };
                 native = ctx.nativeClaudeLogin?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "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,7 +60,7 @@
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"
   },
   "dependencies": {
-    "@byokit/accounts": "0.29.0",
+    "@byokit/accounts": "0.30.0",
     "@byokit/pair": "0.10.4",
     "@byokit/relay": "0.8.2",
     "@byokit/discover": "0.8.4",

package/plugin/catalog.js

@@ -1,6 +1,6 @@
 // byokit.catalog (5.6 live provider catalogs): the provider plugin's own live model list, with each model's api and
-// baseUrl from its catalog data, so the kit can register models embedded runs cannot resolve otherwise. The engine's
-// catalog loader stops at a registered list; the provider's catalog hook does not.
+// baseUrl from its catalog data, joined by the vendor's own model list, so the kit can register models embedded runs
+// cannot resolve otherwise. The engine's catalog loader stops at a registered list; the provider's catalog hook does not.
 export function registerCatalog(api) {
   api.registerGatewayMethod('byokit.catalog', async ({ params, respond }) => {
     try {
@@ -11,7 +11,8 @@ export function registerCatalog(api) {
       const { resolveApiKeyForProvider } = await import('openclaw/plugin-sdk/provider-auth-runtime');
       const config = getRuntimeConfig();
       const hook = resolvePluginProviders({ config, env: process.env }).find((p) => p.id === provider)?.catalog;
-      if (!provider || typeof hook?.run !== 'function') return respond(true, { ok: false, reason: 'failed' });
+      if (!provider) return respond(true, { ok: false, reason: 'failed' });
+      if (typeof hook?.run !== 'function') return respond(true, { ok: true, models: [] }); // a provider with no catalog lists nothing
       // The first agent holding the provider's key; every account of one provider sees the same catalog.
       let unreadable = false;
       for (const agentId of new Set([...Object.keys(config.agents?.entries ?? {}), 'main'])) {
@@ -38,13 +39,16 @@ export function registerCatalog(api) {
         const models = [...live.models, ...(pinned?.models ?? []).filter((m) => !liveIds.has(m.id))]
           .map(({ provider: _p, apiKey: _k, headers: _h, ...model }) =>
             (endpoint.has(model.api) ? { ...model, baseUrl: endpoint.get(model.api) } : model));
-        // MiniMax's engine catalog is a fixed list: its vendor `/models` lists newer ids, which join it with the richest
-        // row's api, base URL and capabilities (the vendor lists ids only). A failed fetch keeps the engine's list.
-        if (provider === 'minimax' && models.length) {
-          const base = models.reduce((a, b) => (b.contextWindow ?? 0) > (a.contextWindow ?? 0) ? b : a);
+        // A plugin catalog can be a fixed list (MiniMax's): the vendor's own `/models` lists newer ids, which join it with
+        // the richest row's api, base URL and capabilities (a vendor list carries ids only). Same rule as
+        // @byokit/accounts' live lists; another api, or a failed fetch, keeps the plugin's rows.
+        const base = models.reduce((a, b) => (b.contextWindow ?? 0) > (a.contextWindow ?? 0) ? b : a);
+        const openai = String(base.api).startsWith('openai-');
+        if (base.baseUrl && (openai || base.api === 'anthropic-messages')) {
           const input = ['text', 'image'].filter((i) => models.some((m) => m.input?.includes(i)));
-          const listed = await fetch(`${String(base.baseUrl).replace(/\/$/, '')}/v1/models`,
-            { headers: { authorization: `Bearer ${apiKey}`, 'anthropic-version': '2023-06-01' }, signal: AbortSignal.timeout(10_000) })
+          const bearer = openai || /^minimax/.test(provider);
+          const listed = await fetch(`${String(base.baseUrl).replace(/\/$/, '')}${openai ? '/models' : '/v1/models'}`, { signal: AbortSignal.timeout(10_000),
+            headers: bearer ? { authorization: `Bearer ${apiKey}`, 'anthropic-version': '2023-06-01' } : { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' } })
             .then((r) => r.ok ? r.json() : null, () => null);
           const have = new Set(models.map((m) => m.id));
           for (const m of Array.isArray(listed?.data) ? listed.data : [])