create-walle 0.9.30 → 0.9.32

package/template/wall-e/llm/codex-cli.js

@@ -25,14 +25,12 @@ const MODELS = [
     name: 'GPT-5.4 Mini (via ChatGPT subscription)',
     capabilities: { vision: false, tools: false, streaming: false, reasoning: true },
   },
-  {
-    id: 'gpt-5.3-codex',
-    name: 'GPT-5.3 Codex (via ChatGPT subscription)',
-    capabilities: { vision: false, tools: false, streaming: false, reasoning: true },
-  },
 ];
 
-const CODEX_CLI_MODEL_RE = /^(gpt-5\.5|gpt-5\.4|gpt-5\.4-mini|gpt-5\.3-codex)$/i;
+const DEFAULT_CODEX_CLI_MODEL = 'gpt-5.5';
+const CODEX_CLI_MODEL_RE = /^(gpt-5\.5|gpt-5\.4|gpt-5\.4-mini)$/i;
+const DEFAULT_CODEX_CLI_REASONING_EFFORT = 'low';
+const CODEX_CLI_REASONING_EFFORT_RE = /^(minimal|low|medium|high|xhigh)$/i;
 
 const CODEX_APP_BINARY = '/Applications/Codex.app/Contents/Resources/codex';
 
@@ -76,7 +74,58 @@ function _serializeMessages(messages, system) {
   return parts.join('\n\n');
 }
 
-async function _spawnCodex(prompt, { model, signal, timeoutMs = 300000, cwd, binaryPath } = {}) {
+function resolveCodexCliModel(model) {
+  const text = String(model || '').trim();
+  return text && CODEX_CLI_MODEL_RE.test(text) ? text : undefined;
+}
+
+function resolveCodexCliReasoningEffort(value) {
+  if (value === false || value == null) return undefined;
+  const text = String(value || '').trim();
+  return text && CODEX_CLI_REASONING_EFFORT_RE.test(text) ? text : undefined;
+}
+
+function buildCodexExecArgs(prompt, {
+  model,
+  ignoreUserConfig = true,
+  reasoningEffort = DEFAULT_CODEX_CLI_REASONING_EFFORT,
+  outFile,
+} = {}) {
+  const args = ['exec'];
+  // Wall-E uses Codex CLI as a backend LLM provider, not as an interactive
+  // coding session. Keep ChatGPT auth, but avoid inheriting user/project
+  // coding-agent config such as xhigh reasoning or large skill/MCP contexts.
+  if (ignoreUserConfig !== false) args.push('--ignore-user-config');
+  args.push(
+    '--skip-git-repo-check',
+    '--ephemeral',
+    '--output-last-message', outFile,
+  );
+  const resolvedReasoningEffort = resolveCodexCliReasoningEffort(reasoningEffort);
+  if (resolvedReasoningEffort) {
+    args.push('-c', `model_reasoning_effort="${resolvedReasoningEffort}"`);
+  }
+  // ChatGPT-authed codex restricts which models work. Only forward `-m` for
+  // known-subscription-compatible models — otherwise let codex pick its own
+  // default. The Wall-E caller's model preference is best-effort; the trade-off
+  // for subscription billing.
+  const forwardedModel = resolveCodexCliModel(model);
+  if (forwardedModel) {
+    args.push('-m', forwardedModel);
+  }
+  args.push(prompt);
+  return { args, forwardedModel, resolvedReasoningEffort };
+}
+
+async function _spawnCodex(prompt, {
+  model,
+  signal,
+  timeoutMs = 300000,
+  cwd,
+  binaryPath,
+  ignoreUserConfig = true,
+  reasoningEffort = DEFAULT_CODEX_CLI_REASONING_EFFORT,
+} = {}) {
   // Codex writes its session journal to ~/.codex/. We pass --ephemeral to
   // suppress that. We also need to capture the final assistant message
   // somehow — `--output-last-message <FILE>` is the cleanest path. Use a
@@ -89,20 +138,7 @@ async function _spawnCodex(prompt, { model, signal, timeoutMs = 300000, cwd, bin
       rm(dir, { recursive: true, force: true }).catch(() => {});
       return reject(new Error('Aborted'));
     }
-    const args = [
-      'exec',
-      '--skip-git-repo-check',
-      '--ephemeral',
-      '--output-last-message', outFile,
-    ];
-    // ChatGPT-authed codex restricts which models work. Only forward `-m` for
-    // known-subscription-compatible
-    // models — otherwise let codex pick its own default. The wall-e caller's
-    // model preference is best-effort; the trade-off for subscription billing.
-    if (model && CODEX_CLI_MODEL_RE.test(model)) {
-      args.push('-m', model);
-    }
-    args.push(prompt);
+    const { args } = buildCodexExecArgs(prompt, { model, ignoreUserConfig, reasoningEffort, outFile });
 
     // Force ChatGPT auth path — strip OPENAI_API_KEY so codex doesn't
     // silently fall back to API-key billing when env exposes one.
@@ -239,13 +275,15 @@ function createCodexCliProvider(config = {}) {
         };
       }
       const start = Date.now();
-      const forwardedModel = model && CODEX_CLI_MODEL_RE.test(model) ? model : undefined;
+      const forwardedModel = resolveCodexCliModel(model);
       const { reply, stdout } = await _spawnCodex(prompt, {
         model: forwardedModel,
         signal,
         timeoutMs: config.timeoutMs,
         cwd: cwd || config.cwd,
         binaryPath: config.binaryPath,
+        ignoreUserConfig: config.ignoreUserConfig,
+        reasoningEffort: config.reasoningEffort,
       });
       const latencyMs = Date.now() - start;
 
@@ -263,7 +301,7 @@ function createCodexCliProvider(config = {}) {
         stopReason: 'end_turn',
         usage: totalTokens > 0 ? { input: 0, output: totalTokens } : undefined,
         latencyMs,
-        model: forwardedModel || 'gpt-5.5',
+        model: forwardedModel || DEFAULT_CODEX_CLI_MODEL,
         provider: 'codex-cli',
         raw: { reply, totalTokens },
       };
@@ -283,4 +321,14 @@ module.exports = {
   createCodexCliProvider,
   createCodexCliFromEnv,
   _spawnCodex,
+  _internals: {
+    CODEX_CLI_MODEL_RE,
+    CODEX_CLI_REASONING_EFFORT_RE,
+    DEFAULT_CODEX_CLI_MODEL,
+    DEFAULT_CODEX_CLI_REASONING_EFFORT,
+    MODELS,
+    buildCodexExecArgs,
+    resolveCodexCliModel,
+    resolveCodexCliReasoningEffort,
+  },
 };

package/template/wall-e/llm/codex-cli.plugin.json

@@ -10,6 +10,7 @@
   "label": "OpenAI Codex (subscription)",
   "defaultModel": "gpt-5.5",
   "modelPrefixes": [],
+  "modelAliases": ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini"],
   "capabilities": {
     "chat": true,
     "tools": false,

package/template/wall-e/llm/default-fallback.js

@@ -36,10 +36,11 @@ const TRANSIENT_CLASSES = new Set(['network', 'timeout', 'provider_unavailable',
 // fall through to the next candidate. auth_error is included (misconfigured /
 // expired credential) but is NOT retried on the same provider; likewise
 // quota_exceeded (depleted account/credits, e.g. DeepSeek "402 Insufficient
-// Balance") — retrying the same provider can't help, but another candidate can
-// serve. Anything else (invalid_request, content filter, unknown) is a real
-// error we must surface.
-const FALLTHROUGH_CLASSES = new Set(['network', 'timeout', 'provider_unavailable', 'rate_limited', 'auth_error', 'quota_exceeded']);
+// Balance") and model_unavailable (the selected provider/model cannot serve)
+// can't be fixed by retrying the same provider, but another candidate can serve.
+// Anything else (invalid_request, content filter, unknown) is a real error we
+// must surface.
+const FALLTHROUGH_CLASSES = new Set(['network', 'timeout', 'provider_unavailable', 'rate_limited', 'auth_error', 'quota_exceeded', 'model_unavailable']);
 
 function classify(err) {
   try {
@@ -53,6 +54,26 @@ function isTransientClass(cls) { return TRANSIENT_CLASSES.has(cls); }
 function shouldFallThroughClass(cls) { return FALLTHROUGH_CLASSES.has(cls); }
 function defaultDelay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
 
+function noEligibleProvidersError(chain) {
+  const labels = (Array.isArray(chain) ? chain : [])
+    .map((candidate) => candidate?.label || candidate?.type || candidate?.id)
+    .filter(Boolean);
+  const detail = labels.length ? ` Skipped routes: ${labels.join(', ')}.` : '';
+  const err = new Error(`No configured AI provider/model route is currently eligible. Waiting for health recovery probes or Setup changes.${detail}`);
+  err.status = 503;
+  err.code = 'AI_PROVIDER_UNAVAILABLE_LOCAL';
+  err.suppressProviderHealthRecord = true;
+  try {
+    err.providerError = classifyProviderError(err, {
+      type: 'provider_unavailable_local',
+      provider: chain?.[0]?.type || chain?.[0]?.id || null,
+      model: chain?.[0]?.model || null,
+      providerId: chain?.[0]?.id || null,
+    });
+  } catch {}
+  return err;
+}
+
 // A request that was CANCELLED (caller aborted, or an AbortError) is not a provider-health
 // signal — the caller no longer wants a result. classifyProviderError() lumps "aborted" into
 // 'timeout' (transient), which would otherwise make us retry + fall through the whole chain
@@ -96,9 +117,13 @@ function isCliBinaryAvailable(bin, opts = {}) {
  *   normal provider client (chat / chatStream / capabilities / type).
  * @param {object} deps
  * @param {object} [deps.health]      ProviderHealth instance (trackCall used).
- * @param {Function} [deps.isDown]    (id) => bool — skip providers already down.
+ * @param {Function} [deps.isDown]    (id,candidate,opts) => bool — skip providers/models already down.
  * @param {Function} [deps.onFallback] ({from,to,error}) => void — fired once when
  *   a non-primary candidate ends up serving the call.
+ * @param {Function} [deps.onCandidateOk] ({provider,model}) => void — fired when any
+ *   candidate succeeds.
+ * @param {Function} [deps.onCandidateFailure] ({provider,model,error,type,attempt}) => void —
+ *   fired for each real provider attempt that fails.
  * @param {Function} [deps.onExhausted] ({chain,error}) => void — every candidate failed.
  * @param {number} [deps.maxRetries=2] Per-candidate transient retries.
  * @param {number} [deps.baseDelayMs=400] Backoff base (exponential).
@@ -114,6 +139,8 @@ function makeResilientClient(chain, deps = {}) {
   const baseDelayMs = Number.isFinite(deps.baseDelayMs) ? deps.baseDelayMs : 400;
   const onFallback = typeof deps.onFallback === 'function' ? deps.onFallback : () => {};
   const onPrimaryOk = typeof deps.onPrimaryOk === 'function' ? deps.onPrimaryOk : () => {};
+  const onCandidateOk = typeof deps.onCandidateOk === 'function' ? deps.onCandidateOk : () => {};
+  const onCandidateFailure = typeof deps.onCandidateFailure === 'function' ? deps.onCandidateFailure : () => {};
   const onExhausted = typeof deps.onExhausted === 'function' ? deps.onExhausted : () => {};
   const sleep = typeof deps.sleep === 'function' ? deps.sleep : defaultDelay;
   const primary = chain[0];
@@ -137,16 +164,16 @@ function makeResilientClient(chain, deps = {}) {
   // Active candidates for this call: drop providers health marked 'down', and —
   // when the call needs tool calls — drop providers that can't do tools (e.g. the
   // claude-cli tail, capabilities.tools === false), leaving those to the coding
-  // orchestrator's own CLI fallback. Never return empty: fall back to the full
-  // chain so we always attempt something.
+  // orchestrator's own CLI fallback. Returning empty is intentional: a circuit-open
+  // model must only be retried through its explicit recovery-probe path.
   function activeChain(opts = {}) {
     const wantsTools = Array.isArray(opts.tools) && opts.tools.length > 0;
-    let cands = chain.filter((c) => !isDown(c.id));
+    let cands = chain.filter((c) => !isDown(c.id, c, optsForCandidate(c, opts)));
     if (wantsTools) {
       const toolCapable = cands.filter((c) => c.client?.capabilities?.tools !== false);
       if (toolCapable.length) cands = toolCapable;
     }
-    return cands.length ? cands : chain.slice(-1);
+    return cands;
   }
 
   // Run one candidate with transient retries. Returns {ok, res} or {ok:false, err, cls}.
@@ -157,6 +184,7 @@ function makeResilientClient(chain, deps = {}) {
       try {
         const res = await invoke(cand.client, callOpts);
         track(cand.id, true);
+        onCandidateOk({ provider: cand, model: callOpts?.model || cand.model || null });
         return { ok: true, res };
       } catch (err) {
         // Caller cancelled — propagate at once (no retry/fallthrough/health-failure).
@@ -165,7 +193,17 @@ function makeResilientClient(chain, deps = {}) {
         lastErr = err;
         lastCls = cls;
         track(cand.id, false, err);
-        if (isTransientClass(cls) && attempt < maxRetries) {
+        const willRetry = isTransientClass(cls) && attempt < maxRetries;
+        onCandidateFailure({
+          provider: cand,
+          model: callOpts?.model || cand.model || null,
+          error: err,
+          type: cls,
+          attempt,
+          willRetry,
+          willFallThrough: !willRetry && shouldFallThroughClass(cls),
+        });
+        if (willRetry) {
           await sleep(baseDelayMs * (2 ** attempt));
           continue;
         }
@@ -177,6 +215,11 @@ function makeResilientClient(chain, deps = {}) {
 
   async function callWithFallback(opts, invoke) {
     const cands = activeChain(opts);
+    if (!cands.length) {
+      const err = noEligibleProvidersError(chain);
+      onExhausted({ chain: cands, skippedChain: chain, error: err, noEligible: true });
+      throw err;
+    }
     let lastErr;
     for (let i = 0; i < cands.length; i++) {
       const cand = cands[i];
@@ -197,6 +240,11 @@ function makeResilientClient(chain, deps = {}) {
 
   async function* streamWithFallback(opts) {
     const cands = activeChain(opts);
+    if (!cands.length) {
+      const err = noEligibleProvidersError(chain);
+      onExhausted({ chain: cands, skippedChain: chain, error: err, noEligible: true });
+      throw err;
+    }
     let lastErr;
     for (let i = 0; i < cands.length; i++) {
       const cand = cands[i];
@@ -208,6 +256,7 @@ function makeResilientClient(chain, deps = {}) {
             if (!started) {
               started = true;
               track(cand.id, true);
+              onCandidateOk({ provider: cand, model: callOpts?.model || cand.model || null });
               if (cand.id !== primary.id) onFallback({ from: primary, to: cand, error: lastErr });
               else onPrimaryOk({ provider: cand });
             }
@@ -219,10 +268,20 @@ function makeResilientClient(chain, deps = {}) {
           if (isAbortError(err, callOpts)) throw err;
           const cls = classify(err);
           track(cand.id, false, err);
+          const willRetry = isTransientClass(cls) && attempt < maxRetries;
+          onCandidateFailure({
+            provider: cand,
+            model: callOpts?.model || cand.model || null,
+            error: err,
+            type: cls,
+            attempt,
+            willRetry,
+            willFallThrough: !willRetry && shouldFallThroughClass(cls),
+          });
           // Mid-stream we can't switch providers without re-emitting — propagate.
           if (started) throw err;
           lastErr = err;
-          if (isTransientClass(cls) && attempt < maxRetries) {
+          if (willRetry) {
             await sleep(baseDelayMs * (2 ** attempt));
             continue; // retry same candidate
           }
@@ -425,6 +484,7 @@ module.exports = {
   _internals: {
     classify,
     isTransientClass,
+    noEligibleProvidersError,
     shouldFallThroughClass,
     _configFromRow,
     _hasEnvKey,

package/template/wall-e/llm/mlx.js

@@ -4,6 +4,15 @@ const { execFile } = require('child_process');
 const path = require('path');
 const os = require('os');
 const fs = require('fs');
+const { workerKey, sharedPool } = require('./mlx-worker');
+
+// Tear down all persistent MLX workers. Long-running hosts rely on the
+// process-exit handler, but short-lived CLIs (the eval harness) must call this
+// explicitly — idle worker stdio pipes keep node's event loop alive, so without
+// it the process hangs after the run completes.
+function shutdownMlxWorkers() {
+  try { sharedPool().shutdownAll(); } catch { /* nothing to tear down */ }
+}
 
 const MLX_VENV = path.join(os.homedir(), '.mlx-env');
 const MLX_PYTHON = path.join(MLX_VENV, 'bin', 'python3');
@@ -139,6 +148,15 @@ function resolveInferenceTimeoutMs(config = {}) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
 }
 
+// Whether to route inference through the persistent warm-worker pool. Default
+// OFF so the primary Wall-E runtime keeps the conservative one-shot subprocess
+// behavior; opt in via config.persistentWorker or MLX_PERSISTENT_WORKER=1
+// (used by the eval harness to avoid reloading the model every turn).
+function resolveUsePersistentWorker(config = {}) {
+  if (config.persistentWorker !== undefined) return !!config.persistentWorker;
+  return process.env.MLX_PERSISTENT_WORKER === '1';
+}
+
 function buildInferenceExecOptions(config = {}, signal) {
   return {
     timeout: resolveInferenceTimeoutMs(config),
@@ -589,20 +607,34 @@ print(json.dumps({
 
       const start = Date.now();
       const maxTok = maxTokens || 1024;
+      const python = resolveMlxPython(config);
 
       try {
-        const { stdout, stderr } = await execAsync(
-          resolveMlxPython(config),
-          ['-c', pyScript, JSON.stringify(compactedChatMessages), String(maxTok), mlxModel, adapterPath || '', forcedGenerationPrefix],
-          buildInferenceExecOptions(config, signal)
-        );
-
-        // Find JSON line in output
-        const lines = stdout.trim().split('\n');
-        const jsonLine = lines.find(l => l.startsWith('{'));
-        if (!jsonLine) throw new Error(`MLX: no JSON in output. stderr: ${stderr?.slice(0, 200)}`);
-
-        const data = JSON.parse(jsonLine);
+        let data;
+        if (resolveUsePersistentWorker(config)) {
+          // Warm path: reuse a long-lived worker so the model loads once instead
+          // of once per turn. Falls back to the cold subprocess on worker failure.
+          const pool = config.mlxWorkerPool || sharedPool();
+          const key = workerKey(python, mlxModel, adapterPath);
+          data = await pool.request(
+            key,
+            { python, model: mlxModel, adapterPath: adapterPath || '' },
+            { messages: compactedChatMessages, max_tokens: maxTok, forced_generation_prefix: forcedGenerationPrefix },
+            { timeoutMs: resolveInferenceTimeoutMs(config), signal }
+          );
+        } else {
+          const { stdout, stderr } = await execAsync(
+            python,
+            ['-c', pyScript, JSON.stringify(compactedChatMessages), String(maxTok), mlxModel, adapterPath || '', forcedGenerationPrefix],
+            buildInferenceExecOptions(config, signal)
+          );
+
+          // Find JSON line in output
+          const lines = stdout.trim().split('\n');
+          const jsonLine = lines.find(l => l.startsWith('{'));
+          if (!jsonLine) throw new Error(`MLX: no JSON in output. stderr: ${stderr?.slice(0, 200)}`);
+          data = JSON.parse(jsonLine);
+        }
         const latencyMs = Date.now() - start;
 
         // Parse tool calls from output if tools were provided
@@ -691,6 +723,8 @@ module.exports = {
   resolveModelSpec,
   resolveMlxPython,
   resolveInferenceTimeoutMs,
+  resolveUsePersistentWorker,
+  shutdownMlxWorkers,
   buildInferenceExecOptions,
   normalizeToolCallFormat,
   normalizeToolSpec,

package/template/wall-e/llm/provider-error.js

@@ -112,7 +112,12 @@ function classifyType(status, lower) {
     || status === 403
     || /invalid[_ -]?(api[_ -]?)?key|unauthori[sz]ed|forbidden|authentication|auth token|authtoken|api[_ -]?key|could not resolve authentication method|expected either apikey or authtoken|oauth token not found|claude auth login|anthropic_api_key|token refresh failed|permission denied/i.test(lower)
   ) return 'auth_error';
-  if (status === 404 || /model .*not found|not_found_error|model_not_found|does not exist|unknown model/i.test(lower)) return 'model_unavailable';
+  if (
+    status === 404
+    || /model .*not found|not_found_error|model_not_found|does not exist|unknown model/i.test(lower)
+    || /(?:model|mode)[^.\n]*(?:not available|not supported|unavailable|unsupported|invalid|unknown|does not exist)/i.test(lower)
+    || /invalid_request_error[^.\n]*(?:model|mode)|(?:model|mode)[^.\n]*invalid_request_error/i.test(lower)
+  ) return 'model_unavailable';
   if (/context length exceeded|context_length_exceeded|maximum context|token limit/i.test(lower)) return 'context_window';
   // Connect-phase failures mean the endpoint was never reached (DNS, routing,
   // VPN-only gateways). They must classify as 'network' even though undici
@@ -260,13 +265,14 @@ function toApiPayload(err, context = {}) {
   };
 }
 
-function recordProviderFailureAlert(providerError, brain) {
+function recordProviderFailureAlert(providerError, brain, opts = {}) {
   if (!providerError) return { alerted: false };
   try {
-    try {
+    if (opts.recordHealth !== false) try {
       const { recordProviderHealthStatus } = require('./provider-health-state');
       recordProviderHealthStatus({
         provider: providerError.provider || 'default',
+        provider_id: providerError.providerId || null,
         model: providerError.model || '',
         ok: false,
         source: 'provider-error',