@chrysb/alphaclaw 0.9.19 → 0.9.21

package/lib/public/js/components/models-tab/index.js

@@ -13,13 +13,15 @@ import {
   buildSyntheticModelEntry,
   getModelCatalogProvider,
   getModelsTabAuthProvider,
+  getModelsTabRequiredAuthProviders,
+  getProviderAuthDisplayOrder,
   getProviderSortIndex,
   SearchableModelPicker,
 } from "./model-picker.js";
 import { ProviderAuthCard } from "./provider-auth-card.js";
 import {
   getFeaturedModels,
-  kProviderOrder,
+  withAlwaysAvailableModels,
 } from "../../lib/model-config.js";
 
 const html = htm.bind(h);
@@ -27,19 +29,13 @@ const html = htm.bind(h);
 const deriveRequiredProviders = (configuredModels) => {
   const providers = new Set();
   for (const modelKey of Object.keys(configuredModels)) {
-    const provider = getModelsTabAuthProvider(modelKey);
-    if (provider) providers.add(provider);
+    for (const provider of getModelsTabRequiredAuthProviders(modelKey)) {
+      providers.add(provider);
+    }
   }
   return [...providers];
 };
 
-const kProviderDisplayOrder = [
-  "anthropic",
-  "openai",
-  "openai-codex",
-  ...kProviderOrder.filter((provider) => !["anthropic", "openai"].includes(provider)),
-];
-
 export const Models = ({ onRestartRequired = () => {}, agentId, embedded = false }) => {
   const {
     catalog,
@@ -70,14 +66,22 @@ export const Models = ({ onRestartRequired = () => {}, agentId, embedded = false
     [configuredModels],
   );
 
-  const featuredModels = useMemo(() => getFeaturedModels(catalog), [catalog]);
+  const selectableCatalog = useMemo(
+    () => withAlwaysAvailableModels(catalog),
+    [catalog],
+  );
+
+  const featuredModels = useMemo(
+    () => getFeaturedModels(selectableCatalog),
+    [selectableCatalog],
+  );
   const popularPickerModels = useMemo(
     () => featuredModels.filter((model) => !configuredKeys.has(model.key)),
     [featuredModels, configuredKeys],
   );
 
   const pickerModels = useMemo(() => {
-    return [...catalog]
+    return [...selectableCatalog]
       .filter((model) => !configuredKeys.has(model.key))
       .sort((a, b) => {
         const providerCompare =
@@ -86,7 +90,7 @@ export const Models = ({ onRestartRequired = () => {}, agentId, embedded = false
         if (providerCompare !== 0) return providerCompare;
         return String(a.label || a.key).localeCompare(String(b.label || b.key));
       });
-  }, [catalog, configuredKeys]);
+  }, [selectableCatalog, configuredKeys]);
 
   const requiredProviders = useMemo(
     () => deriveRequiredProviders(configuredModels),
@@ -94,14 +98,7 @@ export const Models = ({ onRestartRequired = () => {}, agentId, embedded = false
   );
 
   const sortedProviders = useMemo(() => {
-    const ordered = [];
-    for (const p of kProviderDisplayOrder) {
-      if (requiredProviders.includes(p)) ordered.push(p);
-    }
-    for (const p of requiredProviders) {
-      if (!ordered.includes(p)) ordered.push(p);
-    }
-    return ordered;
+    return getProviderAuthDisplayOrder(requiredProviders);
   }, [requiredProviders]);
 
   const providerHasAuth = useMemo(

package/lib/public/js/components/models-tab/model-picker.js

@@ -19,10 +19,30 @@ const kProviderDisplayOrder = [
 
 export const getModelsTabAuthProvider = (modelKey) => {
   const provider = getModelProvider(modelKey);
-  if (provider === "openai-codex") return "openai-codex";
+  if (provider === "openai" || provider === "openai-codex") {
+    return "openai-codex";
+  }
   return getAuthProviderFromModelProvider(provider);
 };
 
+export const getModelsTabRequiredAuthProviders = (modelKey) => {
+  const provider = getModelProvider(modelKey);
+  if (provider === "openai" || provider === "openai-codex") {
+    return ["openai", "openai-codex"];
+  }
+  const authProvider = getAuthProviderFromModelProvider(provider);
+  return authProvider ? [authProvider] : [];
+};
+
+export const getProviderAuthDisplayOrder = (requiredProviders = []) => {
+  const required = new Set(["openai-codex", ...requiredProviders]);
+  const ordered = kProviderDisplayOrder.filter((provider) => required.has(provider));
+  for (const provider of required) {
+    if (!ordered.includes(provider)) ordered.push(provider);
+  }
+  return ordered;
+};
+
 export const getModelCatalogProvider = (model) =>
   String(model?.provider || getModelProvider(model?.key)).trim();
 
@@ -88,6 +108,9 @@ export const buildProviderHasAuth = ({
   if (codexStatus?.connected) {
     result["openai-codex"] = true;
   }
+  if (result.openai) {
+    result["openai-codex"] = true;
+  }
   return result;
 };
 

package/lib/public/js/lib/model-config.js

@@ -27,11 +27,14 @@ export const kFeaturedModelDefs = [
   },
   {
     label: "Codex 5.3",
-    preferredKeys: ["openai-codex/gpt-5.3-codex"],
+    preferredKeys: [
+      "openai/gpt-5.3-codex",
+      "openai-codex/gpt-5.3-codex",
+    ],
   },
   {
     label: "GPT-5.5",
-    preferredKeys: ["openai-codex/gpt-5.5"],
+    preferredKeys: ["openai/gpt-5.5", "openai-codex/gpt-5.5"],
   },
   {
     label: "Gemini 3.1 Pro",
@@ -39,6 +42,23 @@ export const kFeaturedModelDefs = [
   },
 ];
 
+export const kAlwaysAvailableModelDefs = [
+  {
+    key: "openai/gpt-5.5",
+    provider: "openai",
+    label: "GPT-5.5",
+  },
+];
+
+export const withAlwaysAvailableModels = (models = []) => {
+  const merged = [...models];
+  const keys = new Set(merged.map((model) => model?.key));
+  for (const model of kAlwaysAvailableModelDefs) {
+    if (!keys.has(model.key)) merged.push(model);
+  }
+  return merged;
+};
+
 export const getFeaturedModels = (allModels) => {
   const picked = [];
   const used = new Set();

package/lib/scripts/migrate-openclaw-codex.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+const { migrateLegacyCodexState } = require("../server/openclaw-codex-migration");
+
+migrateLegacyCodexState()
+  .then((result) => {
+    if (result.changed) {
+      console.log("[alphaclaw] Migrated legacy OpenAI Codex model and auth state");
+    }
+    for (const warning of result.warnings) {
+      console.warn(`[alphaclaw] Codex migration warning: ${warning}`);
+    }
+  })
+  .catch((error) => {
+    console.error(`[alphaclaw] Codex migration failed: ${error.message}`);
+    process.exitCode = 1;
+  });

package/lib/server/auth-profiles.js

@@ -281,7 +281,12 @@ const createAuthProfiles = () => {
 
   // ── Legacy Codex-specific wrappers ──
 
-  const listCodexProfiles = () => listProfilesByProvider("openai-codex");
+  const listCodexProfiles = () =>
+    listProfiles().filter(
+      (profile) =>
+        profile.type === "oauth" &&
+        (profile.provider === "openai" || profile.provider === "openai-codex"),
+    );
 
   const getCodexProfile = () => {
     const profiles = listCodexProfiles();
@@ -299,7 +304,7 @@ const createAuthProfiles = () => {
   const upsertCodexProfile = ({ access, refresh, expires, accountId }) => {
     upsertProfile(CODEX_PROFILE_ID, {
       type: "oauth",
-      provider: "openai-codex",
+      provider: "openai",
       access,
       refresh,
       expires,
@@ -311,7 +316,10 @@ const createAuthProfiles = () => {
     const store = loadAuthStore();
     let changed = false;
     for (const [id, cred] of Object.entries(store.profiles || {})) {
-      if (cred?.provider === "openai-codex") {
+      if (
+        cred?.type === "oauth" &&
+        (cred.provider === "openai" || cred.provider === "openai-codex")
+      ) {
         delete store.profiles[id];
         changed = true;
       }
@@ -321,7 +329,10 @@ const createAuthProfiles = () => {
       if (!canSyncOpenclawAuthReferences()) return changed;
       let cfg = loadOpenclawConfig();
       for (const [id, cred] of Object.entries(cfg.auth?.profiles || {})) {
-        if (cred?.provider === "openai-codex") {
+        if (
+          cred?.mode === "oauth" &&
+          (cred.provider === "openai" || cred.provider === "openai-codex")
+        ) {
           cfg = removeConfigAuthReference(cfg, id);
         }
       }

package/lib/server/constants.js

@@ -28,7 +28,7 @@ const AUTH_PROFILES_PATH = path.join(
   "agent",
   "auth-profiles.json",
 );
-const CODEX_PROFILE_ID = "openai-codex:codex-cli";
+const CODEX_PROFILE_ID = "openai:codex-cli";
 const CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const CODEX_OAUTH_AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize";
 const CODEX_OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
@@ -173,13 +173,13 @@ const kMinimalFallbackOnboardingModels = [
     label: "Claude Haiku 4.6",
   },
   {
-    key: "openai-codex/gpt-5.5",
-    provider: "openai-codex",
+    key: "openai/gpt-5.5",
+    provider: "openai",
     label: "GPT-5.5",
   },
   {
-    key: "openai-codex/gpt-5.3-codex",
-    provider: "openai-codex",
+    key: "openai/gpt-5.3-codex",
+    provider: "openai",
     label: "Codex GPT-5.3",
   },
   {

package/lib/server/openclaw-codex-migration.js

@@ -0,0 +1,78 @@
+const fs = require("fs");
+const path = require("path");
+const { pathToFileURL } = require("url");
+
+const findOpenclawDistModule = (prefix) => {
+  const entryPath = require.resolve("openclaw");
+  const distDir = path.dirname(entryPath);
+  const filename = fs
+    .readdirSync(distDir)
+    .find((name) => name.startsWith(`${prefix}-`) && name.endsWith(".js"));
+  if (!filename) throw new Error(`OpenClaw migration module not found: ${prefix}`);
+  return path.join(distDir, filename);
+};
+
+const writeConfig = (configPath, cfg) => {
+  fs.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}\n`, "utf8");
+};
+
+const migrateLegacyCodexState = async ({
+  configPath = process.env.OPENCLAW_CONFIG_PATH,
+  env = process.env,
+} = {}) => {
+  if (!configPath || !fs.existsSync(configPath)) {
+    return { changed: false, changes: [], warnings: [] };
+  }
+
+  const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  const routeModule = await import(
+    pathToFileURL(findOpenclawDistModule("codex-route-warnings")).href
+  );
+  const authModule = await import(
+    pathToFileURL(findOpenclawDistModule("doctor-auth-flat-profiles")).href
+  );
+
+  const changes = [];
+  const warnings = [];
+  const routeRepair = routeModule.r({ cfg, env, shouldRepair: true });
+  let nextCfg = routeRepair.cfg;
+  changes.push(...routeRepair.changes);
+  warnings.push(...routeRepair.warnings);
+
+  const profileIdMap = authModule.t({ cfg: nextCfg, env });
+  const configAuthRepair = authModule.a(nextCfg, { profileIdMap });
+  nextCfg = configAuthRepair.config;
+  changes.push(...configAuthRepair.changes);
+  warnings.push(...configAuthRepair.warnings);
+
+  if (changes.length > 0) writeConfig(configPath, nextCfg);
+
+  const storeRepair = await authModule.o({ cfg: nextCfg, env });
+  changes.push(...storeRepair.changes);
+  warnings.push(...storeRepair.warnings);
+
+  const sqliteMigration = await authModule.n({
+    cfg: nextCfg,
+    env,
+    prompter: { confirmAutoFix: async () => true },
+  });
+  changes.push(...sqliteMigration.changes);
+  warnings.push(...sqliteMigration.warnings);
+  if (sqliteMigration.configChanged) writeConfig(configPath, nextCfg);
+
+  const sessionRepair = await routeModule.i({
+    cfg: nextCfg,
+    env,
+    shouldRepair: true,
+  });
+  changes.push(...sessionRepair.changes);
+  warnings.push(...sessionRepair.warnings);
+
+  return {
+    changed: changes.length > 0,
+    changes,
+    warnings,
+  };
+};
+
+module.exports = { migrateLegacyCodexState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "publishConfig": {
     "access": "public"
   },