traderclaw-cli 1.0.51 → 1.0.53

package/bin/installer-step-engine.mjs

@@ -1,4 +1,4 @@
-import { execSync, spawn } from "child_process";
+import { execFileSync, execSync, spawn } from "child_process";
 import { randomBytes } from "crypto";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
 import { homedir, tmpdir } from "os";
@@ -1214,8 +1214,21 @@ function persistXProfileIdentities(configPath, modeConfig, identities) {
 }
 
 function listProviderModels(provider) {
-  const cmd = `openclaw models list --all --provider ${shellQuote(provider)} --json`;
-  const raw = getCommandOutput(cmd);
+  let raw;
+  try {
+    raw = execFileSync(
+      "openclaw",
+      ["models", "list", "--all", "--provider", provider, "--json"],
+      {
+        encoding: "utf-8",
+        maxBuffer: 25 * 1024 * 1024,
+        timeout: 20_000,
+        env: NO_COLOR_ENV,
+      },
+    ).trim();
+  } catch {
+    return [];
+  }
   if (!raw) return [];
   const parsed = extractJson(raw);
   if (!parsed) return [];

package/bin/llm-model-preference.mjs

@@ -211,14 +211,21 @@ export function modelPreferenceScore(provider, modelId) {
   return score;
 }
 
+/** Cap list size after scoring so huge catalogs stay fast for sort + JSON payloads. */
+export const MAX_MODELS_PER_PROVIDER_SORT = 1500;
+
 /**
  * Best-first order for dropdowns and validation.
+ * Uses a score cache because sort() may compare the same ids many times.
  */
 export function sortModelsByPreference(provider, modelIds) {
   const items = [...new Set((modelIds || []).filter(Boolean))];
-  return items.sort(
-    (a, b) => modelPreferenceScore(provider, b) - modelPreferenceScore(provider, a) || String(a).localeCompare(String(b)),
-  );
+  const cache = new Map();
+  const score = (id) => {
+    if (!cache.has(id)) cache.set(id, modelPreferenceScore(provider, id));
+    return cache.get(id);
+  };
+  return items.sort((a, b) => score(b) - score(a) || String(a).localeCompare(String(b)));
 }
 
 export function choosePreferredProviderModel(provider, models = []) {

package/bin/openclaw-trader.mjs

@@ -5,11 +5,17 @@ import { readFileSync, writeFileSync, mkdirSync, appendFileSync, existsSync } fr
 import { join } from "path";
 import { homedir } from "os";
 import { randomUUID, createPrivateKey, sign as cryptoSign } from "crypto";
-import { execSync } from "child_process";
+import { execFile, execSync } from "child_process";
+import { promisify } from "util";
 import { createServer } from "http";
-import { sortModelsByPreference } from "./llm-model-preference.mjs";
+import { sortModelsByPreference, MAX_MODELS_PER_PROVIDER_SORT } from "./llm-model-preference.mjs";
 import { resolvePluginPackageRoot } from "./resolve-plugin-root.mjs";
 
+const execFileAsync = promisify(execFile);
+
+/** Parallel per-provider `openclaw models list` — wall time ~max(single), not sum of all providers. */
+const OPENCLAW_MODELS_PER_PROVIDER_TIMEOUT_MS = 16_000;
+
 const PLUGIN_ROOT = resolvePluginPackageRoot(import.meta.url);
 const PACKAGE_JSON = JSON.parse(readFileSync(join(PLUGIN_ROOT, "package.json"), "utf-8"));
 const VERSION = PACKAGE_JSON.version;
@@ -1766,7 +1772,7 @@ function parseJsonBody(req) {
   });
 }
 
-function loadWizardLlmCatalog() {
+async function loadWizardLlmCatalogAsync() {
   const supportedProviders = new Set([
     "anthropic",
     "openai",
@@ -1830,24 +1836,62 @@ function loadWizardLlmCatalog() {
     return { ...fallback, warning: "openclaw_not_found" };
   }
 
-  try {
+  const providerIds = [...supportedProviders].sort((a, b) => a.localeCompare(b));
+
+  async function fetchModelsForProvider(provider) {
+    try {
+      const { stdout } = await execFileAsync(
+        "openclaw",
+        ["models", "list", "--all", "--provider", provider, "--json"],
+        {
+          encoding: "utf-8",
+          maxBuffer: 25 * 1024 * 1024,
+          timeout: OPENCLAW_MODELS_PER_PROVIDER_TIMEOUT_MS,
+          env: NO_COLOR_ENV,
+        },
+      );
+      return { provider, stdout };
+    } catch (err) {
+      return { provider, error: err };
+    }
+  }
+
+  function buildProvidersFromMap(providerMap) {
+    return providerIds
+      .map((id) => {
+        const rawModels = providerMap.get(id) || [];
+        const sortedIds = sortModelsByPreference(
+          id,
+          rawModels.map((m) => m.id),
+        );
+        const byId = new Map(rawModels.map((m) => [m.id, m]));
+        const limitedIds = sortedIds.slice(0, MAX_MODELS_PER_PROVIDER_SORT);
+        const models = limitedIds.map((mid) => byId.get(mid)).filter(Boolean);
+        return { id, models };
+      })
+      .filter((entry) => supportedProviders.has(entry.id))
+      .filter((entry) => entry.models.length > 0);
+  }
+
+  /** When `openclaw models list --all --json` returns models; used if per-provider calls yield nothing. */
+  function mergeFlatCatalogIntoMap(providerMap) {
     const raw = execSync("openclaw models list --all --json", {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       maxBuffer: 50 * 1024 * 1024,
-      timeout: 30_000,
+      timeout: 45_000,
       env: NO_COLOR_ENV,
     });
     const parsed = extractJson(raw);
-    if (!parsed) throw new Error(`Could not extract JSON from openclaw models list output (first 200 chars): ${stripAnsi(raw).slice(0, 200)}`);
+    if (!parsed) return;
     const models = Array.isArray(parsed?.models) ? parsed.models : [];
-    const providerMap = new Map();
     for (const entry of models) {
       if (!entry || typeof entry.key !== "string") continue;
       const modelId = String(entry.key);
       const slash = modelId.indexOf("/");
       if (slash <= 0 || slash === modelId.length - 1) continue;
       const provider = modelId.slice(0, slash);
+      if (!supportedProviders.has(provider)) continue;
       const existing = providerMap.get(provider) || [];
       existing.push({
         id: modelId,
@@ -1855,30 +1899,66 @@ function loadWizardLlmCatalog() {
       });
       providerMap.set(provider, existing);
     }
+  }
+
+  try {
+    const t0 = Date.now();
+    const batches = await Promise.all(providerIds.map((p) => fetchModelsForProvider(p)));
+    const providerMap = new Map();
+
+    for (const batch of batches) {
+      if (batch.error || !batch.stdout) continue;
+      const parsed = extractJson(batch.stdout);
+      if (!parsed) continue;
+      const models = Array.isArray(parsed?.models) ? parsed.models : [];
+      const want = batch.provider;
+      for (const entry of models) {
+        if (!entry || typeof entry.key !== "string") continue;
+        const modelId = String(entry.key);
+        const slash = modelId.indexOf("/");
+        if (slash <= 0 || slash === modelId.length - 1) continue;
+        const provider = modelId.slice(0, slash);
+        if (provider !== want) continue;
+        const existing = providerMap.get(provider) || [];
+        existing.push({
+          id: modelId,
+          name: typeof entry.name === "string" && entry.name.trim() ? entry.name : modelId,
+        });
+        providerMap.set(provider, existing);
+      }
+    }
 
-    const providers = [...providerMap.keys()]
-      .sort((a, b) => a.localeCompare(b))
-      .map((id) => {
-        const rawModels = providerMap.get(id) || [];
-        const sortedIds = sortModelsByPreference(
-          id,
-          rawModels.map((m) => m.id),
+    let providers = buildProvidersFromMap(providerMap);
+    let catalogStrategy = "parallel";
+
+    if (providers.length === 0) {
+      catalogStrategy = "legacy_fallback";
+      try {
+        mergeFlatCatalogIntoMap(providerMap);
+        providers = buildProvidersFromMap(providerMap);
+      } catch (legacyErr) {
+        console.error(
+          `[traderclaw] loadWizardLlmCatalog legacy fallback failed: ${legacyErr instanceof Error ? legacyErr.message : String(legacyErr)}`,
         );
-        const byId = new Map(rawModels.map((m) => [m.id, m]));
-        const models = sortedIds.map((mid) => byId.get(mid)).filter(Boolean);
-        return { id, models };
-      })
-      .filter((entry) => supportedProviders.has(entry.id))
-      .filter((entry) => entry.models.length > 0);
+      }
+    }
 
     if (providers.length === 0) {
-      return { ...fallback, warning: "openclaw_model_catalog_empty" };
+      const failedParallel = batches.filter((b) => b.error).length;
+      const hint =
+        failedParallel > 0
+          ? ` (${failedParallel}/${batches.length} per-provider openclaw calls failed — check OpenClaw version supports: openclaw models list --all --provider <id> --json)`
+          : "";
+      return { ...fallback, warning: `openclaw_model_catalog_empty${hint}` };
     }
 
+    const elapsedMs = Date.now() - t0;
     return {
       source: "openclaw",
       providers,
       generatedAt: new Date().toISOString(),
+      catalogFetchMs: elapsedMs,
+      catalogStrategy,
     };
   } catch (err) {
     const detail = err?.message || String(err);
@@ -2629,7 +2709,15 @@ async function cmdInstall(args) {
     }
 
     if (req.method === "GET" && req.url === "/api/llm/options") {
-      respondJson(200, loadWizardLlmCatalog());
+      try {
+        const payload = await loadWizardLlmCatalogAsync();
+        respondJson(200, payload);
+      } catch (err) {
+        respondJson(500, {
+          source: "error",
+          message: err instanceof Error ? err.message : String(err),
+        });
+      }
       return;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "traderclaw-cli",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "Global TraderClaw CLI (install --wizard, setup, precheck). Installs solana-traderclaw as a dependency for OpenClaw plugin files.",
   "type": "module",
   "bin": {