@byokit/openclaw 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+## 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,19 @@ 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).
+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/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,4 @@
 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 OPERATOR_SCOPES: readonly ['operator.read', 'operator.write', 'operator.admin', 'operator.approvals', 'operator.questions', 'operator.pairing', 'operator.talk'];

package/dist/constants.js

@@ -2,15 +2,9 @@
 // `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
+// 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 OpenRouter's
 // list collides with itself (`google/x-preview` and `google/x`); an OpenRouter add registers only the chosen model.
 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'];
 export const OPERATOR_SCOPES = [
     'operator.read',
     'operator.write',

package/dist/keys.js

@@ -5,7 +5,7 @@ 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 { REGISTERED_CATALOGS } 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();
@@ -96,7 +96,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 +108,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 +138,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 +227,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 +240,10 @@ 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.
+                        // A catalog the kit does not register whole (OpenRouter's, and any other provider's) registers the chosen model alone.
                         if (model !== undefined && (!REGISTERED_CATALOGS.includes(route.provider) || lagging.length))
                             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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.25.0",
+  "version": "0.26.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,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 : [])