@remnic/core 9.69.37 → 9.69.39

package/dist/{chunk-YEN4TREG.js → chunk-LQNRVPTV.js}

@@ -11,17 +11,18 @@ import {
   loadModelsJsonProviders
 } from "./chunk-45GF7Y3V.js";
 import {
-  callCodexCliFallback,
-  isCodexCliFallbackRunnerRegistered,
-  normalizeCodexCliTimeoutMs,
-  setCodexCliFallbackRunnerForProcess
-} from "./chunk-65RENJGB.js";
+  CODEX_SUBSCRIPTION_PROVIDER_ID,
+  abortReason,
+  codexSubscriptionBuiltinProviderConfig,
+  getCodexSubscriptionRunnerForOwner,
+  isTerminalCodexSubscriptionError,
+  raceFallbackLlmDeadline,
+  tryCodexSubscriptionProvider,
+  withCodexRuntimeShutdown
+} from "./chunk-CWTCMZGE.js";
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
-import {
-  launchProcess
-} from "./chunk-ZEFVK7XC.js";
 import {
   expandTildePath
 } from "./chunk-6KH5NLQS.js";
@@ -33,525 +34,7 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/fallback-llm.ts
-import path2 from "path";
-
-// src/providers/codex-subscription.ts
-import { mkdir, mkdtemp, readFile, rm } from "fs/promises";
-import os from "os";
 import path from "path";
-var CODEX_SUBSCRIPTION_PROVIDER_ID = "codex-subscription";
-var CODEX_EXECUTABLE_ENV = "REMNIC_CODEX_EXECUTABLE";
-var DEFAULT_REASONING_EFFORT = "medium";
-var DEFAULT_TIMEOUT_MS = 12e4;
-var LOGIN_STATUS_TIMEOUT_MS = 1e4;
-var LOGIN_STATUS_CACHE_TTL_MS = 10 * 6e4;
-var STDIO_LIMIT = 64e3;
-var OUTPUT_SUMMARY_LIMIT = 500;
-var CODEX_RUNTIME_ENV_ALLOWLIST = Object.freeze({
-  ALL_PROXY: true,
-  APPDATA: true,
-  CODEX_HOME: true,
-  COLORTERM: true,
-  COMSPEC: true,
-  FORCE_COLOR: true,
-  HOME: true,
-  HOMEDRIVE: true,
-  HOMEPATH: true,
-  LANG: true,
-  LOCALAPPDATA: true,
-  LOGNAME: true,
-  NO_COLOR: true,
-  NODE_EXTRA_CA_CERTS: true,
-  NO_PROXY: true,
-  NUMBER_OF_PROCESSORS: true,
-  OS: true,
-  PATH: true,
-  PATHEXT: true,
-  PROGRAMDATA: true,
-  PROCESSOR_ARCHITECTURE: true,
-  HTTP_PROXY: true,
-  HTTPS_PROXY: true,
-  SHELL: true,
-  SSL_CERT_DIR: true,
-  SSL_CERT_FILE: true,
-  SYSTEMDRIVE: true,
-  SYSTEMROOT: true,
-  TEMP: true,
-  TERM: true,
-  TMP: true,
-  TMPDIR: true,
-  USER: true,
-  USERNAME: true,
-  USERPROFILE: true,
-  WINDIR: true,
-  XDG_CACHE_HOME: true,
-  XDG_CONFIG_HOME: true,
-  XDG_DATA_HOME: true,
-  XDG_RUNTIME_DIR: true
-});
-var LOGIN_OK_PATTERN = /logged in using chatgpt/i;
-var LOGIN_API_KEY_PATTERN = /api key/i;
-var AUTH_FAILURE_PATTERN = /\b401\b|\b403\b|unauthorized|forbidden|not logged in|no active|re-?authenticat|token expired|session expired|please log ?in/i;
-var TIMEOUT_PATTERN = /timed out after \d+ms/i;
-var SECRET_ECHO_PATTERNS = [
-  /sk-[A-Za-z0-9_-]{8,}/g,
-  /Bearer\s+[A-Za-z0-9._-]{8,}/g,
-  /eyJ[A-Za-z0-9._-]{10,}/g
-];
-function codexSubscriptionBuiltinProviderConfig() {
-  return {
-    baseUrl: "codex-cli://subscription",
-    api: "codex-cli",
-    models: []
-  };
-}
-var CodexSubscriptionAuthError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "CodexSubscriptionAuthError";
-    this.reason = reason;
-  }
-};
-var CodexSubscriptionConfigError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CodexSubscriptionConfigError";
-  }
-};
-var CodexSubscriptionTimeoutError = class extends Error {
-  constructor(timeoutMs) {
-    super(`codex-subscription request timed out after ${timeoutMs}ms`);
-    this.name = "TimeoutError";
-  }
-};
-var loginStatusCache = /* @__PURE__ */ new Map();
-var coreRunnerRegistered = false;
-function createCodexSubscriptionRunner(deps = {}) {
-  const envSource = deps.env ?? process.env;
-  return (request) => runCodexSubscriptionRequest(request, deps, envSource);
-}
-function ensureCodexSubscriptionRunnerRegistered(deps = {}) {
-  if (isCodexCliFallbackRunnerRegistered()) return false;
-  setCodexCliFallbackRunnerForProcess(createCodexSubscriptionRunner(deps));
-  coreRunnerRegistered = true;
-  return true;
-}
-async function runCodexSubscriptionRequest(request, deps, envSource) {
-  const { config } = request;
-  assertNoApiKeyConfig(config);
-  const executable = resolveExecutable(config, envSource);
-  const env = buildIsolatedEnv(envSource);
-  const providerTimeoutMs = config.retryOptions?.timeoutMs !== void 0 ? normalizeCodexCliTimeoutMs(config.retryOptions.timeoutMs) : void 0;
-  const timeoutMs = request.options.timeoutMs ?? providerTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const now = deps.now ?? Date.now;
-  const deadlineStartedAt = now();
-  await assertSubscriptionLogin(executable, env, deps, Math.min(LOGIN_STATUS_TIMEOUT_MS, timeoutMs));
-  if (request.options.signal?.aborted) {
-    throw abortErrorOf(request.options.signal);
-  }
-  const remainingTimeoutMs = timeoutMs - (now() - deadlineStartedAt);
-  if (remainingTimeoutMs <= 0) {
-    throw new CodexSubscriptionTimeoutError(timeoutMs);
-  }
-  let tempDir;
-  try {
-    tempDir = await mkdtemp(path.join(deps.tmpdir?.() ?? os.tmpdir(), "remnic-codex-sub-"));
-    const workspacePath = path.join(tempDir, "workspace");
-    const outputPath = path.join(tempDir, "last-message.txt");
-    await mkdir(workspacePath, { recursive: true });
-    const runCodexExec = deps.runCodexExec ?? runCodexExecSubprocess;
-    const result = await runCodexExec({
-      executable,
-      args: buildExecArgs(request.modelId, config, workspacePath, outputPath),
-      input: buildPrompt(request.messages),
-      env,
-      outputPath,
-      workspacePath,
-      timeoutMs: remainingTimeoutMs,
-      signal: request.options.signal
-    });
-    if (request.options.signal?.aborted) {
-      throw abortErrorOf(request.options.signal);
-    }
-    if (result.status !== 0) {
-      throw execFailureError(result, remainingTimeoutMs, executable, env);
-    }
-    const content = result.outputText.trim();
-    if (content.length === 0) {
-      throw new Error(
-        `codex-subscription: codex exec returned no final message (${summarizeOutput(result.stderr, result.stdout)})`
-      );
-    }
-    return { content, ...usageFrom(result) };
-  } finally {
-    if (tempDir) {
-      await rm(tempDir, { force: true, recursive: true }).catch(() => {
-      });
-    }
-  }
-}
-function assertNoApiKeyConfig(config) {
-  if (config.apiKey !== void 0 && config.apiKey !== "") {
-    throw new CodexSubscriptionConfigError(
-      `${CODEX_SUBSCRIPTION_PROVIDER_ID} does not accept apiKey configuration: it authenticates through the Codex CLI login. Remove the apiKey field and run \`codex login\` with a ChatGPT account instead.`
-    );
-  }
-}
-function resolveExecutable(config, env) {
-  const configured = config.codexCliExecutable ?? config.executable ?? env[CODEX_EXECUTABLE_ENV] ?? "codex";
-  const expanded = expandTildePath(String(configured).trim());
-  if (expanded.trim().length === 0) {
-    throw new CodexSubscriptionConfigError(`${CODEX_EXECUTABLE_ENV} / executable must not be empty`);
-  }
-  if (expanded.includes("/") || expanded.includes("\\")) {
-    return path.resolve(expanded);
-  }
-  return expanded;
-}
-function buildIsolatedEnv(source) {
-  const env = {};
-  for (const [key, value] of Object.entries(source)) {
-    if (value !== void 0 && isAllowedEnvKey(key)) {
-      env[key] = value;
-    }
-  }
-  return env;
-}
-function isAllowedEnvKey(key) {
-  const normalized = key.toUpperCase();
-  return CODEX_RUNTIME_ENV_ALLOWLIST[normalized] === true || normalized.startsWith("LC_");
-}
-async function assertSubscriptionLogin(executable, env, deps, loginStatusTimeoutMs) {
-  const now = deps.now ?? Date.now;
-  const cacheKey = `${executable}\0${env.CODEX_HOME ?? env.HOME ?? ""}`;
-  const cached = loginStatusCache.get(cacheKey);
-  if (cached && now() - cached.at < LOGIN_STATUS_CACHE_TTL_MS) {
-    await cached.promise;
-    return;
-  }
-  const promise = (async () => {
-    const runLoginStatus = deps.runLoginStatus ?? runLoginStatusSubprocess;
-    const result = await runLoginStatus(executable, env, loginStatusTimeoutMs);
-    const output = `${result.stdout}
-${result.stderr}`.trim();
-    if (TIMEOUT_PATTERN.test(output)) {
-      throw new CodexSubscriptionTimeoutError(loginStatusTimeoutMs);
-    }
-    if (result.status === 0 && LOGIN_OK_PATTERN.test(output)) {
-      return;
-    }
-    const apiKeyNote = LOGIN_API_KEY_PATTERN.test(output) ? " The CLI currently reports an API-key login; subscription extraction needs a ChatGPT login." : "";
-    throw new CodexSubscriptionAuthError(
-      "unauthenticated",
-      `codex-subscription: no ChatGPT-backed Codex login found. Run \`codex login\` and choose the ChatGPT account option, then retry.${apiKeyNote}`
-    );
-  })();
-  loginStatusCache.set(cacheKey, { at: now(), promise });
-  try {
-    await promise;
-  } catch (err) {
-    loginStatusCache.delete(cacheKey);
-    throw err;
-  }
-}
-function buildExecArgs(modelId, config, workspacePath, outputPath) {
-  const reasoningEffort = readReasoningEffort(config) ?? DEFAULT_REASONING_EFFORT;
-  return [
-    "exec",
-    "--strict-config",
-    "--model",
-    modelId,
-    "--config",
-    `model_reasoning_effort=${JSON.stringify(reasoningEffort)}`,
-    "--config",
-    'approval_policy="never"',
-    "--config",
-    'web_search="disabled"',
-    "--disable",
-    "hooks",
-    "--disable",
-    "shell_tool",
-    "--disable",
-    "unified_exec",
-    "--disable",
-    "apps",
-    "--disable",
-    "plugins",
-    "--disable",
-    "remote_plugin",
-    "--disable",
-    "multi_agent",
-    "--disable",
-    "browser_use",
-    "--disable",
-    "browser_use_external",
-    "--disable",
-    "computer_use",
-    "--disable",
-    "image_generation",
-    "--disable",
-    "in_app_browser",
-    "--disable",
-    "goals",
-    "--disable",
-    "memories",
-    "--disable",
-    "chronicle",
-    "--disable",
-    "tool_suggest",
-    "--disable",
-    "workspace_dependencies",
-    "--disable",
-    "shell_snapshot",
-    "--ephemeral",
-    "--ignore-user-config",
-    "--ignore-rules",
-    "--sandbox",
-    "read-only",
-    "--cd",
-    workspacePath,
-    "--skip-git-repo-check",
-    "--json",
-    "--output-last-message",
-    outputPath,
-    "-"
-  ];
-}
-function readReasoningEffort(config) {
-  for (const value of [config.codexCliReasoningEffort, config.reasoningEffort]) {
-    if (typeof value === "string") {
-      const normalized = value.trim().toLowerCase();
-      if (normalized === "low" || normalized === "medium" || normalized === "high" || normalized === "xhigh") {
-        return normalized;
-      }
-      throw new CodexSubscriptionConfigError(
-        "codex-subscription reasoningEffort must be one of low, medium, high, xhigh (got unrecognized value)"
-      );
-    }
-  }
-  return void 0;
-}
-function buildPrompt(messages) {
-  const transcript = messages.map((message) => JSON.stringify({ role: message.role, content: message.content })).join("\n");
-  return [
-    "You are acting as an LLM completion endpoint for a memory-extraction pipeline, not as a coding agent.",
-    "Answer the request in the transcript below. Do not inspect files, run commands, browse, or use tools.",
-    "Return only the final answer text. If the request asks for JSON, return raw JSON only.",
-    "",
-    'TRANSCRIPT (JSON Lines: one {"role":"...","content":"..."} object per message; newlines inside content are escaped):',
-    transcript
-  ].join("\n");
-}
-function execFailureError(result, timeoutMs, executable, env) {
-  const combined = `${result.stderr}
-${result.stdout}`;
-  if (AUTH_FAILURE_PATTERN.test(combined)) {
-    loginStatusCache.delete(`${executable}\0${env.CODEX_HOME ?? env.HOME ?? ""}`);
-    return new CodexSubscriptionAuthError(
-      "expired_or_revoked",
-      "codex-subscription: the Codex CLI rejected the request as unauthenticated (session expired or revoked). Run `codex login` again to re-authenticate, then retry."
-    );
-  }
-  if (TIMEOUT_PATTERN.test(combined)) {
-    return new CodexSubscriptionTimeoutError(timeoutMs);
-  }
-  const exitLabel = result.signal ? `signal ${result.signal}` : `exit ${result.status ?? "unknown"}`;
-  return new Error(
-    `codex-subscription: codex exec failed (${exitLabel}): ${summarizeOutput(result.stderr, result.stdout)}`
-  );
-}
-function summarizeOutput(stderr, stdout) {
-  const summary = [stderr.trim(), stdout.trim()].filter((part) => part.length > 0).join("\n");
-  if (summary.length === 0) {
-    return "no process output";
-  }
-  return redactSecretEchoes(summary).slice(-OUTPUT_SUMMARY_LIMIT);
-}
-function redactSecretEchoes(value) {
-  let redacted = value;
-  for (const pattern of SECRET_ECHO_PATTERNS) {
-    redacted = redacted.replace(pattern, "[redacted]");
-  }
-  return redacted;
-}
-function usageFrom(result) {
-  const usage = parseCodexJsonlUsage(`${result.stdout}
-${result.stderr}`);
-  if (!usage) {
-    return {};
-  }
-  return {
-    usage: {
-      inputTokens: usage.inputTokens,
-      outputTokens: usage.outputTokens,
-      totalTokens: usage.inputTokens + usage.outputTokens
-    }
-  };
-}
-function parseCodexJsonlUsage(output) {
-  let usage;
-  for (const line of output.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("{")) continue;
-    try {
-      const event = JSON.parse(trimmed);
-      if (event.type !== "turn.completed" || !event.usage) continue;
-      const inputTokens = readCounter(event.usage.input_tokens);
-      const outputTokens = readCounter(event.usage.output_tokens);
-      if (inputTokens !== void 0 && outputTokens !== void 0) {
-        usage = { inputTokens, outputTokens };
-      }
-    } catch {
-    }
-  }
-  return usage;
-}
-function readCounter(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    return void 0;
-  }
-  return value;
-}
-function abortErrorOf(signal) {
-  if (signal.reason instanceof Error) return signal.reason;
-  if (signal.reason !== void 0) return new Error(String(signal.reason));
-  return new DOMException("The operation was aborted.", "AbortError");
-}
-function appendBounded(existing, next) {
-  const redacted = redactSecretEchoes(existing + next);
-  return redacted.length > STDIO_LIMIT ? redacted.slice(-STDIO_LIMIT) : redacted;
-}
-async function runLoginStatusSubprocess(executable, env, timeoutMs) {
-  return await runSubprocess(executable, ["login", "status"], {
-    env,
-    stdin: void 0,
-    timeoutMs,
-    timeoutLabel: "login status"
-  });
-}
-async function runCodexExecSubprocess(request) {
-  const result = await runSubprocess(request.executable, request.args, {
-    env: request.env,
-    stdin: request.input,
-    timeoutMs: request.timeoutMs,
-    timeoutLabel: "exec",
-    signal: request.signal,
-    cwd: request.workspacePath
-  });
-  let outputText = "";
-  try {
-    outputText = (await readFile(request.outputPath, "utf8")).trim();
-  } catch {
-  }
-  return { ...result, outputText };
-}
-async function runSubprocess(executable, args, options) {
-  return await new Promise((resolve, reject) => {
-    if (options.signal?.aborted) {
-      reject(abortErrorOf(options.signal));
-      return;
-    }
-    const child = launchProcess(executable, args, {
-      ...options.cwd ? { cwd: options.cwd } : {},
-      env: options.env,
-      stdio: [options.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
-      detached: process.platform !== "win32",
-      windowsHide: true
-    });
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    let killTimeout;
-    const clearKillTimeout = () => {
-      if (killTimeout) {
-        clearTimeout(killTimeout);
-        killTimeout = void 0;
-      }
-    };
-    const terminate = (signal) => {
-      if (child.pid && process.platform !== "win32") {
-        try {
-          process.kill(-child.pid, signal);
-          return;
-        } catch {
-        }
-      }
-      child.kill(signal);
-    };
-    const scheduleForcedKill = () => {
-      clearKillTimeout();
-      killTimeout = setTimeout(() => terminate("SIGKILL"), 1e3);
-      killTimeout.unref();
-    };
-    const onAbort = () => {
-      terminate("SIGTERM");
-      scheduleForcedKill();
-    };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    const timeout = options.timeoutMs ? setTimeout(() => {
-      timedOut = true;
-      stderr = appendBounded(
-        stderr,
-        `
-codex-subscription: ${options.timeoutLabel} timed out after ${options.timeoutMs}ms.`
-      );
-      terminate("SIGTERM");
-      scheduleForcedKill();
-    }, options.timeoutMs) : void 0;
-    timeout?.unref();
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-      stdout = appendBounded(stdout, chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr = appendBounded(stderr, chunk);
-    });
-    child.stdin?.on("error", (error) => {
-      stderr = appendBounded(stderr, `
-codex-subscription: stdin error: ${error.code ?? error.message}`);
-    });
-    const settle = (fn) => {
-      clearTimeout(timeout);
-      clearKillTimeout();
-      options.signal?.removeEventListener("abort", onAbort);
-      fn();
-    };
-    child.on("error", (error) => {
-      settle(() => {
-        reject(
-          child.pid ? new Error(`codex-subscription: codex CLI failed after start: ${safeMessage(error)}`, { cause: error }) : new CodexSubscriptionAuthError(
-            "unauthenticated",
-            `codex-subscription: codex CLI not found at \`${executable}\` \u2014 install the Codex CLI and run \`codex login\` with a ChatGPT account, then retry.`
-          )
-        );
-      });
-    });
-    child.on("close", (status, signal) => {
-      settle(() => {
-        resolve({
-          status: timedOut ? status ?? 124 : status,
-          signal: timedOut ? signal ?? "SIGTERM" : signal,
-          stdout,
-          stderr
-        });
-      });
-    });
-    if (options.stdin !== void 0) {
-      try {
-        child.stdin?.end(options.stdin);
-      } catch (error) {
-        log.debug(`codex-subscription: failed writing prompt to stdin: ${safeMessage(error)}`);
-      }
-    }
-  });
-}
-function safeMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/fallback-llm.ts
 function gatewayTaskChainOptions(config) {
   if (config.modelSource !== "gateway") return {};
   if (config.taskModelChain) return { modelChain: config.taskModelChain };
@@ -562,6 +45,7 @@ function fallbackLlmRuntimeContextFromConfig(config, overrides = {}) {
     workspaceDir: config.workspaceDir,
     resolveApiKeyForProvider: config.providerApiKeyResolver,
     getRuntimeAuthForModel: config.runtimeAuthForModelResolver,
+    codexSubscriptionRunner: getCodexSubscriptionRunnerForOwner(config),
     ...overrides
   };
 }
@@ -635,9 +119,11 @@ var FallbackLlmClient = class {
       log.warn("fallback LLM: no models configured in gateway");
       return null;
     }
+    options = withCodexRuntimeShutdown(options, this.runtimeContext.codexSubscriptionRunner);
     const runChain = async (initialOptions) => {
       let runOptions = initialOptions;
       let lastRejectedResponse = null;
+      let terminalError;
       for (let i = 0; i < models.length; i++) {
         if (runOptions.signal?.aborted) {
           throw abortReason(runOptions.signal);
@@ -663,6 +149,9 @@ var FallbackLlmClient = class {
             return response;
           }
         } catch (err) {
+          if (isTerminalCodexSubscriptionError(err) && runOptions.signal?.aborted) {
+            throw err;
+          }
           if (runOptions.signal?.aborted) {
             throw abortReason(runOptions.signal);
           }
@@ -689,19 +178,31 @@ var FallbackLlmClient = class {
                 continue;
               }
             } catch (retryError) {
+              if (isTerminalCodexSubscriptionError(retryError) && runOptions.signal?.aborted) {
+                throw retryError;
+              }
               if (runOptions.signal?.aborted) throw abortReason(runOptions.signal);
               const retryErrorMsg = runOptions.redactProviderErrors ? "provider error details redacted" : retryError instanceof Error ? retryError.message : String(retryError);
               log.debug(
                 `fallback LLM: ${model.modelString} unstructured retry failed (${retryErrorMsg})`
               );
+              if (isTerminalCodexSubscriptionError(retryError)) {
+                terminalError = retryError;
+              }
             }
             continue;
           }
           const errorMsg = runOptions.redactProviderErrors ? "provider error details redacted" : err instanceof Error ? err.message : String(err);
           log.debug(`fallback LLM: ${model.modelString} failed (${errorMsg}), trying next...`);
+          if (isTerminalCodexSubscriptionError(err)) {
+            terminalError = err;
+          }
         }
       }
       log.warn(`fallback LLM: all ${models.length} models in chain failed`);
+      if (terminalError !== void 0) {
+        throw terminalError;
+      }
       return lastRejectedResponse;
     };
     if (typeof options.timeoutMs === "number") {
@@ -709,7 +210,6 @@ var FallbackLlmClient = class {
         log.warn("fallback LLM: timed out before request started");
         return null;
       }
-      let timeoutHandle;
       const controller = new AbortController();
       const onCallerAbort = () => {
         controller.abort(abortReason(options.signal));
@@ -720,23 +220,22 @@ var FallbackLlmClient = class {
       }
       const timedOptions = { ...options, signal: controller.signal };
       const chain = runChain(timedOptions);
-      chain.catch(() => {
-      });
+      const guarded = chain.then(
+        (value) => value,
+        (err) => {
+          if (isTerminalCodexSubscriptionError(err)) throw err;
+          return null;
+        }
+      );
       try {
-        return await Promise.race([
-          chain,
-          new Promise((resolve) => {
-            timeoutHandle = setTimeout(() => {
-              log.warn(`fallback LLM: timed out after ${options.timeoutMs}ms`);
-              controller.abort(
-                new Error(`fallback LLM timed out after ${options.timeoutMs}ms`)
-              );
-              resolve(null);
-            }, options.timeoutMs);
-          })
-        ]);
+        const outcome = await raceFallbackLlmDeadline(guarded, options.timeoutMs, () => {
+          log.warn(`fallback LLM: timed out after ${options.timeoutMs}ms`);
+          controller.abort(
+            new Error(`fallback LLM timed out after ${options.timeoutMs}ms`)
+          );
+        });
+        return outcome.timedOut ? null : outcome.value;
       } finally {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
         options.signal?.removeEventListener("abort", onCallerAbort);
       }
     }
@@ -759,7 +258,7 @@ var FallbackLlmClient = class {
     try {
       response = await this.chatCompletion(messages, options);
     } catch (err) {
-      if (options.signal?.aborted) throw err;
+      if (options.signal?.aborted || isTerminalCodexSubscriptionError(err)) throw err;
       log.warn("fallback LLM: chatCompletion threw during structured parse:", err);
       return { result: null, failureReason: "http_error" };
     }
@@ -953,9 +452,17 @@ var FallbackLlmClient = class {
    * simpler providers or when the runtime module isn't loaded.
    */
   async tryModel(model, messages, options) {
-    const runtimeAuth = model.providerConfig.api === "codex-cli" ? null : await this.resolveRuntimeAuth(model);
+    const codexResult = await tryCodexSubscriptionProvider(
+      model,
+      messages,
+      options,
+      () => this.resolveFallbackApiKey(model),
+      this.runtimeContext.codexSubscriptionRunner
+    );
+    if (codexResult !== void 0) return codexResult;
+    const runtimeAuth = await this.resolveRuntimeAuth(model);
     const effectiveBaseUrl = runtimeAuth?.baseUrl ?? model.providerConfig.baseUrl;
-    const resolvedApiKey = runtimeAuth?.apiKey ?? (model.providerConfig.api === "codex-cli" && model.providerConfig.apiKey === void 0 ? void 0 : await this.resolveFallbackApiKey(model));
+    const resolvedApiKey = runtimeAuth?.apiKey ?? await this.resolveFallbackApiKey(model);
     const rawKey = model.providerConfig.apiKey;
     const needsResolution = rawKey === "secretref-managed" || typeof rawKey === "object" && rawKey !== null;
     if (needsResolution && !resolvedApiKey) {
@@ -969,15 +476,6 @@ var FallbackLlmClient = class {
     if (model.providerConfig.api === "anthropic-messages") {
       return await this.callAnthropic(effectiveConfig, model.modelId, messages, options);
     }
-    if (model.providerConfig.api === "codex-cli") {
-      ensureCodexSubscriptionRunnerRegistered();
-      return await callCodexCliFallback(
-        effectiveConfig,
-        model.modelId,
-        messages,
-        { timeoutMs: options.timeoutMs, signal: options.signal }
-      );
-    }
     if (model.providerConfig.api === "ollama-chat") {
       return await this.callOllamaChat(effectiveConfig, model.modelId, messages, options);
     }
@@ -1276,10 +774,6 @@ var FallbackLlmClient = class {
     };
   }
 };
-function abortReason(signal) {
-  const reason = signal?.reason;
-  return reason instanceof Error ? reason : new Error("fallback LLM request aborted");
-}
 function normalizeRuntimePath(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
@@ -1291,7 +785,7 @@ function readGatewayWorkspaceDir(gatewayConfig) {
   return normalizeRuntimePath(raw.workspaceDir) ?? normalizeRuntimePath(raw.workspacePath) ?? normalizeRuntimePath(raw.workspace);
 }
 function defaultOpenClawWorkspaceDir() {
-  return path2.join(resolveHomeDir(), ".openclaw", "workspace");
+  return path.join(resolveHomeDir(), ".openclaw", "workspace");
 }
 function extractResponsesOutputText(data) {
   if (typeof data.output_text === "string" && data.output_text.trim().length > 0) {
@@ -1313,15 +807,8 @@ function extractResponsesOutputText(data) {
 }
 
 export {
-  CODEX_SUBSCRIPTION_PROVIDER_ID,
-  codexSubscriptionBuiltinProviderConfig,
-  CodexSubscriptionAuthError,
-  CodexSubscriptionConfigError,
-  CodexSubscriptionTimeoutError,
-  createCodexSubscriptionRunner,
-  ensureCodexSubscriptionRunnerRegistered,
   gatewayTaskChainOptions,
   fallbackLlmRuntimeContextFromConfig,
   FallbackLlmClient
 };
-//# sourceMappingURL=chunk-YEN4TREG.js.map
+//# sourceMappingURL=chunk-LQNRVPTV.js.map