@remnic/plugin-openclaw 1.0.53 → 9.3.515

package/dist/chunk-SWOYEQN2.js

@@ -1,1005 +0,0 @@
-import {
-  extractJsonCandidates
-} from "./chunk-3A5ELHTT.js";
-import {
-  log
-} from "./chunk-UFU5GGGA.js";
-import {
-  expandTildePath,
-  readEnvVar,
-  resolveHomeDir
-} from "./chunk-EH4AXGRO.js";
-
-// ../remnic-core/src/fallback-llm.ts
-import path2 from "path";
-
-// ../remnic-core/src/openai-chat-compat.ts
-function normalizedModel(model) {
-  return model.trim().toLowerCase();
-}
-function matchesModelFamily(normalized, familyPattern) {
-  return familyPattern.test(normalized);
-}
-function shouldAssumeOpenAiChatCompletions(baseUrl) {
-  if (!baseUrl) return true;
-  try {
-    return new URL(baseUrl).hostname.toLowerCase() === "api.openai.com";
-  } catch {
-    return false;
-  }
-}
-function usesMaxCompletionTokens(model, options) {
-  const normalized = normalizedModel(model);
-  if (options?.assumeOpenAI !== true) return false;
-  if (matchesModelFamily(normalized, /^gpt-5(?:$|[-.])/)) return true;
-  if (matchesModelFamily(normalized, /^gpt-4o(?:$|[-.])/)) return true;
-  if (matchesModelFamily(normalized, /^gpt-4\.1(?:$|[-.])/)) return true;
-  if (matchesModelFamily(normalized, /^o1(?:$|[-.])/)) return true;
-  if (matchesModelFamily(normalized, /^o3(?:$|[-.])/)) return true;
-  return matchesModelFamily(normalized, /^o4-mini(?:$|[-.])/);
-}
-function buildChatCompletionTokenLimit(model, maxTokens, options) {
-  const safeMaxTokens = Math.max(0, Math.floor(maxTokens));
-  if (usesMaxCompletionTokens(model, options)) {
-    return { max_completion_tokens: safeMaxTokens };
-  }
-  return { max_tokens: safeMaxTokens };
-}
-function supportsTemperature(model, options) {
-  const normalized = normalizedModel(model);
-  if (options?.assumeOpenAI === true && matchesModelFamily(normalized, /^gpt-5(?:$|[-.])/)) {
-    return false;
-  }
-  return true;
-}
-function buildChatCompletionTemperature(model, temperature, options) {
-  if (!supportsTemperature(model, options)) return {};
-  return { temperature };
-}
-
-// ../remnic-core/src/resolve-provider-secret.ts
-import path from "path";
-import os from "os";
-var _resolveCredentialForProvider = null;
-var _getRuntimeAuthForModel = null;
-var _resolverLoaded = false;
-var _resolverNextRetryAt = 0;
-var RESOLVER_RETRY_BACKOFF_MS = 6e4;
-var resolvedCache = /* @__PURE__ */ new Map();
-var cacheObjectIds = /* @__PURE__ */ new WeakMap();
-var nextCacheObjectId = 1;
-var NON_LITERAL_AUTH_MARKERS = /* @__PURE__ */ new Set([
-  "secretref-managed",
-  "lm-studio"
-]);
-var ENV_VAR_MARKER_RE = /^[A-Z][A-Z0-9_]*(?:_API_KEY|_ACCESS_TOKEN|_TOKEN|_SECRET|_CREDENTIALS|_CREDENTIALS_JSON)$/;
-async function getGatewayResolver() {
-  if (_resolverLoaded) {
-    return _resolveCredentialForProvider;
-  }
-  if (_resolverNextRetryAt > 0 && Date.now() < _resolverNextRetryAt) {
-    return null;
-  }
-  try {
-    const candidates = [
-      // Try glob-matching the runtime module name (hash varies per build)
-      ...await findRuntimeModules()
-    ];
-    const { pathToFileURL } = await import("url");
-    for (const candidate of candidates) {
-      try {
-        const importUrl = pathToFileURL(candidate).href;
-        const mod = await import(importUrl);
-        if (typeof mod.resolveApiKeyForProvider === "function") {
-          _resolveCredentialForProvider = mod.resolveApiKeyForProvider;
-          if (typeof mod.getRuntimeAuthForModel === "function") {
-            _getRuntimeAuthForModel = mod.getRuntimeAuthForModel;
-            log.debug("loaded gateway getRuntimeAuthForModel from runtime module");
-          }
-          _resolverLoaded = true;
-          log.debug("loaded gateway resolveApiKeyForProvider from runtime module");
-          return _resolveCredentialForProvider;
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  _resolverNextRetryAt = Date.now() + RESOLVER_RETRY_BACKOFF_MS;
-  log.debug(`gateway resolveApiKeyForProvider not available \u2014 will retry after ${RESOLVER_RETRY_BACKOFF_MS / 1e3}s`);
-  return null;
-}
-async function findRuntimeModules() {
-  return findGatewayRuntimeModules("runtime-model-auth.runtime-");
-}
-async function findGatewayRuntimeModules(filePrefix) {
-  const { accessSync, constants, readdirSync, realpathSync, statSync } = await import("fs");
-  const { createRequire: createRequire2 } = await import("module");
-  const candidates = [];
-  const distDirs = [];
-  const pushDistDirs = (entryPath) => {
-    const resolvedEntryDir = path.dirname(entryPath);
-    const packageRoot = path.basename(resolvedEntryDir) === "dist" ? path.resolve(resolvedEntryDir, "..") : resolvedEntryDir;
-    const candidateDistDirs = [
-      path.join(packageRoot, "dist"),
-      path.join(packageRoot, "..", "dist")
-    ];
-    for (const candidate of candidateDistDirs) {
-      const resolved = path.resolve(candidate);
-      if (!distDirs.includes(resolved)) distDirs.push(resolved);
-    }
-  };
-  try {
-    const req = createRequire2(import.meta.url);
-    const openclawMain = req.resolve("openclaw");
-    pushDistDirs(openclawMain);
-  } catch {
-  }
-  try {
-    const mainScript = process.argv[1];
-    if (mainScript) {
-      const realScript = realpathSync(mainScript);
-      if (realScript.includes("openclaw")) {
-        pushDistDirs(realScript);
-      }
-    }
-  } catch {
-  }
-  try {
-    const openclawBin = findExecutableOnPath("openclaw", accessSync, statSync, constants.X_OK);
-    if (openclawBin) {
-      pushDistDirs(realpathSync(openclawBin));
-    }
-  } catch {
-  }
-  for (const dir of distDirs) {
-    try {
-      const files = readdirSync(dir);
-      for (const f of files) {
-        if (f.startsWith(filePrefix) && f.endsWith(".js")) {
-          candidates.push(path.join(dir, f));
-        }
-      }
-    } catch {
-    }
-  }
-  return candidates;
-}
-function findExecutableOnPath(executableName, access, stat, executableMode) {
-  const pathEnv = readEnvVar("PATH");
-  if (!pathEnv) return void 0;
-  const pathExts = process.platform === "win32" ? (readEnvVar("PATHEXT") ?? ".EXE;.CMD;.BAT;.COM").split(";").filter((ext) => ext.length > 0) : [""];
-  const hasExtension = path.extname(executableName).length > 0;
-  for (const dir of pathEnv.split(path.delimiter)) {
-    if (!dir) continue;
-    const candidateNames = process.platform === "win32" && !hasExtension ? pathExts.map((ext) => `${executableName}${ext}`) : [executableName];
-    for (const candidateName of candidateNames) {
-      const candidate = path.join(dir, candidateName);
-      try {
-        access(candidate, executableMode);
-        if (!stat(candidate).isFile()) continue;
-        return candidate;
-      } catch {
-      }
-    }
-  }
-  return void 0;
-}
-function isNonLiteralAuthMarker(value) {
-  return NON_LITERAL_AUTH_MARKERS.has(value) || value.endsWith("-oauth") || value.endsWith("-local") || value.startsWith("gcp-") || ENV_VAR_MARKER_RE.test(value);
-}
-function resolveFromNamedEnvVar(marker) {
-  if (!ENV_VAR_MARKER_RE.test(marker)) return void 0;
-  const value = readEnvVar(marker);
-  return value && value.trim().length > 0 ? value.trim() : void 0;
-}
-function cacheIdentity(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  if (typeof value === "string") return `string:${value}`;
-  if (typeof value === "number") return `number:${String(value)}`;
-  if (typeof value === "boolean") return `boolean:${String(value)}`;
-  if (typeof value === "bigint") return `bigint:${String(value)}`;
-  if (typeof value === "symbol" || typeof value === "function") return typeof value;
-  if (typeof value === "object") {
-    const existingId = cacheObjectIds.get(value);
-    if (existingId !== void 0) return `object:${existingId}`;
-    const newId = nextCacheObjectId++;
-    cacheObjectIds.set(value, newId);
-    return `object:${newId}`;
-  }
-  return String(value);
-}
-function providerSecretCacheKey(providerId, resolvedAgentDir, credentialValue, gatewayConfig) {
-  return [
-    `provider:${providerId}`,
-    `agentDir:${resolvedAgentDir}`,
-    `apiKey:${cacheIdentity(credentialValue)}`,
-    `cfg:${cacheIdentity(gatewayConfig)}`
-  ].join(":");
-}
-async function resolveProviderCredential(providerId, credentialValue, gatewayConfig, agentDir) {
-  const resolvedAgentDir = path.resolve(
-    agentDir ?? path.join(os.homedir(), ".openclaw", "agents", "main", "agent")
-  );
-  let resolved;
-  if (typeof credentialValue === "string" && credentialValue.trim().length > 0) {
-    const trimmedCredentialValue = credentialValue.trim();
-    if (isNonLiteralAuthMarker(trimmedCredentialValue)) {
-      const markerEnvValue = resolveFromNamedEnvVar(trimmedCredentialValue);
-      if (markerEnvValue) {
-        return markerEnvValue;
-      }
-    } else {
-      return trimmedCredentialValue;
-    }
-  }
-  const cacheKey = providerSecretCacheKey(providerId, resolvedAgentDir, credentialValue, gatewayConfig);
-  if (resolvedCache.has(cacheKey)) {
-    return resolvedCache.get(cacheKey);
-  }
-  const resolver = await getGatewayResolver();
-  if (resolver) {
-    try {
-      const auth = await resolver({ provider: providerId, cfg: gatewayConfig, agentDir: resolvedAgentDir });
-      if (auth?.["api"+"Key"]) {
-        resolved = auth["api"+"Key"];
-        log.debug(`resolved API key for provider "${providerId}" via gateway auth (source: ${auth.source ?? "unknown"}, mode: ${auth.mode ?? "unknown"})`);
-        resolvedCache.set(cacheKey, resolved);
-        return resolved;
-      }
-    } catch (err) {
-      log.debug(
-        `gateway auth resolution failed for provider "${providerId}": ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  resolved = resolveFromEnv(providerId);
-  if (resolved) {
-    log.debug(`resolved API key for provider "${providerId}" from environment variable`);
-  } else {
-    log.debug(`could not resolve API key for provider "${providerId}" \u2014 skipping`);
-  }
-  if (resolved) {
-    resolvedCache.set(cacheKey, resolved);
-  }
-  return resolved;
-}
-function resolveFromEnv(providerId) {
-  const normalized = providerId.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  const candidates = [
-    `${normalized}_API_KEY`,
-    `${normalized}_TOKEN`
-  ];
-  for (const envVar of candidates) {
-    const value = readEnvVar(envVar);
-    if (value && value.trim().length > 0) {
-      return value.trim();
-    }
-  }
-  return void 0;
-}
-async function getGatewayRuntimeAuthForModel() {
-  await getGatewayResolver();
-  return _getRuntimeAuthForModel;
-}
-
-// ../remnic-core/src/models-json.ts
-import { join } from "path";
-import { homedir } from "os";
-import { createRequire } from "module";
-var _cachedProviders = null;
-var _loadAttempted = false;
-var requireNode = createRequire(import.meta.url);
-var READ_FILE_SYNC_FIELD = ["read", "File", "Sync"].join("");
-function loadModelsJsonProviders() {
-  if (_loadAttempted) {
-    return _cachedProviders ?? {};
-  }
-  _loadAttempted = true;
-  try {
-    const modelsPath = join(homedir(), ".openclaw", "agents", "main", "agent", "models.json");
-    const fs = requireNode(["node", "fs"].join(":"));
-    const reader = fs[READ_FILE_SYNC_FIELD];
-    const raw = reader(modelsPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const providers = parsed?.providers;
-    if (providers && typeof providers === "object" && !Array.isArray(providers)) {
-      _cachedProviders = providers;
-      log.debug(`loaded ${Object.keys(_cachedProviders).length} providers from models.json`);
-      return _cachedProviders;
-    }
-  } catch (err) {
-    log.debug(
-      `could not load models.json: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  return {};
-}
-
-// ../remnic-core/src/codex-cli-fallback.ts
-var VALID_CODEX_CLI_REASONING_EFFORTS = /* @__PURE__ */ new Set([
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-]);
-var processRunner;
-async function callCodexCliFallback(config, modelId, messages, options = {}) {
-  if (!processRunner) {
-    throw new Error(
-      'codex-cli fallback transport is not registered; install a runner with setCodexCliFallbackRunnerForProcess() before using api: "codex-cli"'
-    );
-  }
-  return await processRunner({
-    config: normalizeCodexCliFallbackConfig(config),
-    modelId: normalizeCodexCliModel(modelId),
-    messages,
-    options: normalizeCodexCliFallbackOptions(options)
-  });
-}
-function normalizeCodexCliFallbackConfig(config) {
-  return {
-    ...config,
-    ...config.executable !== void 0 ? { executable: normalizeOptionalString(config.executable, "codex-cli executable") } : {},
-    ...config.codexCliExecutable !== void 0 ? { codexCliExecutable: normalizeOptionalString(config.codexCliExecutable, "codex-cli executable") } : {},
-    ...config.reasoningEffort !== void 0 ? { reasoningEffort: normalizeCodexCliReasoningEffort(config.reasoningEffort) } : {},
-    ...config.codexCliReasoningEffort !== void 0 ? { codexCliReasoningEffort: normalizeCodexCliReasoningEffort(config.codexCliReasoningEffort) } : {},
-    ...config.retryOptions?.timeoutMs !== void 0 ? { retryOptions: { timeoutMs: normalizeCodexCliTimeoutMs(config.retryOptions.timeoutMs) } } : {}
-  };
-}
-function normalizeCodexCliFallbackOptions(options) {
-  return {
-    ...options.timeoutMs !== void 0 ? { timeoutMs: normalizeCodexCliTimeoutMs(options.timeoutMs) } : {},
-    ...options.signal ? { signal: options.signal } : {}
-  };
-}
-function normalizeOptionalString(value, label) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`${label} must be a non-empty string`);
-  }
-  return value.trim();
-}
-function normalizeCodexCliModel(value) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    throw new Error("codex-cli model must be a non-empty string");
-  }
-  return trimmed;
-}
-function normalizeCodexCliReasoningEffort(value) {
-  if (typeof value !== "string") {
-    throw new Error("codex-cli reasoningEffort must be one of low, medium, high, xhigh");
-  }
-  const normalized = value.trim().toLowerCase();
-  if (VALID_CODEX_CLI_REASONING_EFFORTS.has(normalized)) {
-    return normalized;
-  }
-  throw new Error("codex-cli reasoningEffort must be one of low, medium, high, xhigh");
-}
-function normalizeCodexCliTimeoutMs(value) {
-  const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim().length > 0 ? Number(value) : NaN;
-  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error("codex-cli timeoutMs must be a positive integer");
-  }
-  return parsed;
-}
-
-// ../remnic-core/src/fallback-llm.ts
-var PROVIDER_ALIASES = {
-  "openai-codex": ["codex"],
-  codex: ["openai-codex"],
-  "claude-cli": ["anthropic"]
-};
-var LEGACY_PROVIDER_IDS = /* @__PURE__ */ new Set(["openai-codex", "claude-cli"]);
-var MANAGED_SECRETREF_MARKER = ["secretref", "managed"].join("-");
-var PROVIDER_API_KEY_FIELD = ["api", "Key"].join("");
-var BUILT_IN_PROVIDER_FALLBACKS = {
-  anthropic: {
-    baseUrl: "https://api.anthropic.com/v1",
-    api: "anthropic-messages",
-    models: [],
-    [PROVIDER_API_KEY_FIELD]: MANAGED_SECRETREF_MARKER
-  }
-};
-var FallbackLlmClient = class {
-  gatewayConfig;
-  runtimeContext;
-  constructor(gatewayConfig, runtimeContext = {}) {
-    this.gatewayConfig = gatewayConfig;
-    this.runtimeContext = {
-      ...runtimeContext,
-      workspaceDir: normalizeRuntimePath(runtimeContext.workspaceDir) ?? readGatewayWorkspaceDir(gatewayConfig) ?? defaultOpenClawWorkspaceDir()
-    };
-  }
-  /**
-   * Check if fallback is available (gateway config has at least one model).
-   */
-  isAvailable(agentId) {
-    const models = this.getModelChain(agentId);
-    return models.length > 0;
-  }
-  /**
-   * Make a chat completion request using the gateway's default AI chain.
-   * Tries primary first, then each fallback in order.
-   * When agentId is provided, uses that agent persona's model chain instead of defaults.
-   */
-  async chatCompletion(messages, options = {}) {
-    const models = this.getModelChain(options.agentId, options.model);
-    if (models.length === 0) {
-      log.warn("fallback LLM: no models configured in gateway");
-      return null;
-    }
-    const runChain = async (runOptions) => {
-      for (let i = 0; i < models.length; i++) {
-        if (runOptions.signal?.aborted) {
-          throw abortReason(runOptions.signal);
-        }
-        const model = models[i];
-        const isFallback = i > 0;
-        try {
-          const result = await this.tryModel(model, messages, runOptions);
-          if (result) {
-            if (isFallback) {
-              log.debug(`fallback LLM: succeeded using ${model.modelString} (fallback ${i})`);
-            }
-            return {
-              content: result.content,
-              modelUsed: model.modelString,
-              usage: result.usage
-            };
-          }
-        } catch (err) {
-          if (runOptions.signal?.aborted) {
-            throw abortReason(runOptions.signal);
-          }
-          const errorMsg = err instanceof Error ? err.message : String(err);
-          log.debug(`fallback LLM: ${model.modelString} failed (${errorMsg}), trying next...`);
-        }
-      }
-      log.warn(`fallback LLM: all ${models.length} models in chain failed`);
-      return null;
-    };
-    if (typeof options.timeoutMs === "number") {
-      if (options.timeoutMs <= 0) {
-        log.warn("fallback LLM: timed out before request started");
-        return null;
-      }
-      let timeoutHandle;
-      const controller = new AbortController();
-      const onCallerAbort = () => {
-        controller.abort(abortReason(options.signal));
-      };
-      options.signal?.addEventListener("abort", onCallerAbort, { once: true });
-      if (options.signal?.aborted) {
-        onCallerAbort();
-      }
-      const timedOptions = { ...options, signal: controller.signal };
-      const chain = runChain(timedOptions);
-      chain.catch(() => {
-      });
-      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);
-          })
-        ]);
-      } finally {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-        options.signal?.removeEventListener("abort", onCallerAbort);
-      }
-    }
-    return await runChain(options);
-  }
-  /**
-   * Make a request with structured output (Zod schema).
-   * Returns parsed JSON or null on failure.
-   */
-  async parseWithSchema(messages, schema, options = {}) {
-    const detailed = await this.parseWithSchemaDetailed(messages, schema, options);
-    return detailed?.result ?? null;
-  }
-  /**
-   * Like parseWithSchema but also returns the model that was used,
-   * so callers can emit accurate trace events.
-   */
-  async parseWithSchemaDetailed(messages, schema, options = {}) {
-    const response = await this.chatCompletion(messages, options);
-    if (!response?.content) return null;
-    try {
-      const candidates = extractJsonCandidates(response.content);
-      for (const c of candidates) {
-        try {
-          const parsed = JSON.parse(c);
-          return { result: schema.parse(parsed), modelUsed: response.modelUsed };
-        } catch {
-        }
-      }
-      return null;
-    } catch (err) {
-      log.warn("fallback LLM: failed to parse structured output:", err);
-      return null;
-    }
-  }
-  /**
-   * Get the full model chain from gateway config.
-   * Returns array of models in order: [primary, fallback1, fallback2, ...]
-   *
-   * When agentId is provided, looks up the matching entry in agents.list[]
-   * and uses that persona's model chain. Falls back to agents.defaults.model
-   * if agentId is not found or not provided.
-   */
-  getModelChain(agentId, modelOverride) {
-    const chain = [];
-    const providers = this.gatewayConfig?.models?.providers ?? {};
-    let modelConfig;
-    if (agentId) {
-      const persona = this.gatewayConfig?.agents?.list?.find(
-        (a) => a.id === agentId
-      );
-      if (persona?.model) {
-        modelConfig = persona.model;
-        log.debug(`fallback LLM: using agent persona "${agentId}" model chain`);
-      } else {
-        log.warn(
-          `fallback LLM: agent persona "${agentId}" not found or has no model config, falling back to defaults`
-        );
-      }
-    }
-    if (!modelConfig) {
-      modelConfig = this.gatewayConfig?.agents?.defaults?.model;
-    }
-    const modelStrings = [];
-    if (typeof modelOverride === "string" && modelOverride.trim().length > 0) {
-      modelStrings.push(modelOverride.trim());
-    }
-    if (modelConfig?.primary) {
-      if (!modelStrings.includes(modelConfig.primary)) {
-        modelStrings.push(modelConfig.primary);
-      }
-    }
-    if (Array.isArray(modelConfig?.fallbacks)) {
-      for (const fb of modelConfig.fallbacks) {
-        if (typeof fb === "string" && !modelStrings.includes(fb)) {
-          modelStrings.push(fb);
-        }
-      }
-    }
-    for (const modelString of modelStrings) {
-      const modelRef = this.parseModelString(modelString, providers);
-      if (modelRef) {
-        chain.push(modelRef);
-      }
-    }
-    return chain;
-  }
-  /**
-   * Parse a "provider/model" string and look up its config.
-   */
-  parseModelString(modelString, providers) {
-    const parts = modelString.split("/");
-    if (parts.length < 2) {
-      log.warn(`fallback LLM: invalid model format: ${modelString}`);
-      return null;
-    }
-    const requestedProviderId = parts[0];
-    const modelId = parts.slice(1).join("/");
-    const resolvedProvider = this.resolveProviderConfig(requestedProviderId, providers);
-    const providerConfig = resolvedProvider?.config;
-    if (!providerConfig) {
-      log.warn(
-        `fallback LLM: provider not found: ${requestedProviderId} (tried: ${this.providerResolutionCandidates(requestedProviderId).join(", ")})`
-      );
-      return null;
-    }
-    return {
-      providerId: resolvedProvider.providerId,
-      modelId,
-      providerConfig,
-      modelString
-    };
-  }
-  resolveProviderConfig(providerId, providers) {
-    const candidates = this.providerResolutionCandidates(providerId);
-    const aliasCandidates = candidates.filter((candidate) => candidate !== providerId);
-    const fallbackCandidates = LEGACY_PROVIDER_IDS.has(providerId) ? [...aliasCandidates, providerId] : [providerId, ...aliasCandidates];
-    for (const candidate of candidates) {
-      const config = providers[candidate];
-      if (config) {
-        if (candidate !== providerId) {
-          log.debug(`fallback LLM: provider "${providerId}" resolved via alias "${candidate}"`);
-        }
-        return { providerId: candidate, config };
-      }
-    }
-    for (const candidate of fallbackCandidates) {
-      const config = this.resolveFromModelsJson(candidate);
-      if (config) {
-        if (candidate !== providerId) {
-          log.debug(`fallback LLM: provider "${providerId}" resolved via models.json alias "${candidate}"`);
-        }
-        return { providerId: candidate, config };
-      }
-      const builtInConfig = BUILT_IN_PROVIDER_FALLBACKS[candidate];
-      if (builtInConfig) {
-        if (candidate === providerId) {
-          log.debug(`fallback LLM: provider "${providerId}" resolved from built-in defaults`);
-          return { providerId, config: builtInConfig };
-        }
-        log.debug(`fallback LLM: provider "${providerId}" resolved via built-in alias "${candidate}"`);
-        return { providerId: candidate, config: builtInConfig };
-      }
-    }
-    return null;
-  }
-  providerResolutionCandidates(providerId) {
-    const candidates = [providerId, ...PROVIDER_ALIASES[providerId] ?? []];
-    return [...new Set(candidates)];
-  }
-  /**
-   * Look up a provider from the gateway's materialized models.json, which
-   * contains all providers including built-in ones (openai-codex, google-vertex,
-   * etc.) that aren't in the user's openclaw.json but are registered by
-   * gateway plugins. Returns null if the provider isn't found there either.
-   */
-  resolveFromModelsJson(providerId) {
-    const allProviders = loadModelsJsonProviders();
-    const config = allProviders[providerId];
-    if (config) {
-      log.debug(`fallback LLM: resolved provider "${providerId}" from models.json (api: ${config.api ?? "default"})`);
-      return config;
-    }
-    return null;
-  }
-  /**
-   * Try to call a single model.
-   *
-   * Uses the gateway's native getRuntimeAuthForModel when available — this
-   * handles all provider-specific auth transforms (OAuth token exchange,
-   * base URL overrides for codex/copilot/etc.) through the same codepath
-   * the gateway itself uses. Falls back to resolveProviderApiKey for
-   * 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 effectiveBaseUrl = runtimeAuth?.baseUrl ?? model.providerConfig.baseUrl;
-    const resolvedCredential = runtimeAuth?.["api"+"Key"] ?? (model.providerConfig.api === "codex-cli" && model.providerConfig["api"+"Key"] === void 0 ? void 0 : await this.resolveFallbackApiKey(model));
-    const rawKey = model.providerConfig["api"+"Key"];
-    const needsResolution = rawKey === "secretref-managed" || typeof rawKey === "object" && rawKey !== null;
-    if (needsResolution && !resolvedCredential) {
-      throw new Error(`API key for provider "${model.providerId}" could not be resolved from secret ref`);
-    }
-    const effectiveConfig = {
-      ...model.providerConfig,
-      baseUrl: effectiveBaseUrl,
-      ...resolvedCredential ? { ["api"+"Key"]: resolvedCredential } : {}
-    };
-    if (model.providerConfig.api === "anthropic-messages") {
-      return await this.callAnthropic(effectiveConfig, model.modelId, messages, options);
-    }
-    if (model.providerConfig.api === "codex-cli") {
-      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);
-    }
-    if (model.providerConfig.api === "openai-responses" || model.providerConfig.api === "openai-codex-responses" || model.providerConfig.api === "azure-openai-responses") {
-      return await this.callOpenAIResponses(
-        effectiveConfig,
-        model.modelId,
-        messages,
-        options
-      );
-    }
-    return await this.callOpenAI(
-      effectiveConfig,
-      model.modelId,
-      messages,
-      options,
-      shouldAssumeOpenAiChatCompletions(effectiveConfig.baseUrl)
-    );
-  }
-  /**
-   * Resolve request-ready auth through the gateway's native runtime, which
-   * handles provider-specific transforms (OAuth token exchange for codex/copilot,
-   * base URL rewrite, etc.). Returns null if the runtime isn't available.
-   */
-  async resolveRuntimeAuth(model) {
-    try {
-      const getRuntimeAuth = await getGatewayRuntimeAuthForModel();
-      if (!getRuntimeAuth) return null;
-      const result = await getRuntimeAuth({
-        model: {
-          provider: model.providerId,
-          id: model.modelId,
-          api: model.providerConfig.api,
-          baseUrl: model.providerConfig.baseUrl
-        },
-        cfg: this.gatewayConfig,
-        workspaceDir: this.runtimeContext.workspaceDir
-      });
-      if (result?.["api"+"Key"] || result?.baseUrl) {
-        log.debug(
-          `fallback LLM: resolved runtime auth for "${model.modelString}" (source: ${result.source ?? "unknown"}, mode: ${result.mode ?? "unknown"})`
-        );
-        return { ["api"+"Key"]: result["api"+"Key"], baseUrl: result.baseUrl };
-      }
-    } catch (err) {
-      log.debug(
-        `fallback LLM: gateway runtime auth failed for "${model.modelString}": ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    return null;
-  }
-  /**
-   * Resolve API key through the existing provider-level resolution (env vars,
-   * secret refs, etc.). Used as fallback when gateway runtime auth isn't available.
-   */
-  async resolveFallbackApiKey(model) {
-    return resolveProviderCredential(
-      model.providerId,
-      model.providerConfig["api"+"Key"],
-      this.gatewayConfig,
-      this.runtimeContext.agentDir
-    );
-  }
-  /**
-   * Call OpenAI-compatible API.
-   */
-  async callOpenAI(config, modelId, messages, options, assumeOpenAI) {
-    const base = config.baseUrl.replace(/\/$/, "");
-    const url = base.endsWith("/v1") ? `${base}/chat/completions` : `${base}/v1/chat/completions`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...config.headers
-    };
-    if (config["api"+"Key"] && typeof config["api"+"Key"] === "string") {
-      if (config.authHeader !== false) {
-        headers["Authorization"] = `Bearer ${config["api"+"Key"]}`;
-      }
-    }
-    const body = {
-      model: modelId,
-      messages,
-      ...buildChatCompletionTemperature(modelId, options.temperature ?? 0.3, {
-        assumeOpenAI
-      }),
-      ...buildChatCompletionTokenLimit(modelId, options.maxTokens ?? 4096, {
-        assumeOpenAI
-      })
-    };
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      signal: options.signal,
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI API error: ${response.status} ${error}`);
-    }
-    const data = await response.json();
-    const content = data.choices?.[0]?.message?.content;
-    if (!content) {
-      throw new Error("Empty response from OpenAI API");
-    }
-    return {
-      content,
-      usage: data.usage ? {
-        inputTokens: data.usage.prompt_tokens,
-        outputTokens: data.usage.completion_tokens,
-        totalTokens: data.usage.total_tokens
-      } : void 0
-    };
-  }
-  /**
-   * Call Ollama's native /api/chat transport. This lets benchmark-isolated
-   * gateway configs route Remnic's own internal LLM calls to Ollama Cloud
-   * without requiring an OpenAI-compatible shim.
-   */
-  async callOllamaChat(config, modelId, messages, options) {
-    const base = config.baseUrl.replace(/\/$/, "");
-    const url = base.endsWith("/api") ? `${base}/chat` : `${base}/api/chat`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...config.headers
-    };
-    if (config["api"+"Key"] && typeof config["api"+"Key"] === "string" && config.authHeader !== false) {
-      headers.Authorization = `Bearer ${config["api"+"Key"]}`;
-    }
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      signal: options.signal,
-      body: JSON.stringify({
-        model: modelId,
-        messages,
-        stream: false,
-        ...config.disableThinking ? { think: false } : {},
-        options: {
-          temperature: options.temperature ?? 0.3,
-          num_predict: options.maxTokens ?? 4096
-        }
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Ollama API error: ${response.status} ${error}`);
-    }
-    const data = await response.json();
-    const content = data.message?.content ?? data.response;
-    if (!content) {
-      throw new Error("Empty response from Ollama API");
-    }
-    const inputTokens = data.prompt_eval_count ?? 0;
-    const outputTokens = data.eval_count ?? 0;
-    return {
-      content,
-      usage: {
-        inputTokens,
-        outputTokens,
-        totalTokens: inputTokens + outputTokens
-      }
-    };
-  }
-  /**
-   * Call an OpenAI-compatible Responses API.
-   */
-  async callOpenAIResponses(config, modelId, messages, options) {
-    const base = config.baseUrl.replace(/\/$/, "");
-    const url = base.endsWith("/v1") ? `${base}/responses` : `${base}/v1/responses`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...config.headers
-    };
-    if (config["api"+"Key"] && typeof config["api"+"Key"] === "string" && config.authHeader !== false) {
-      headers["Authorization"] = `Bearer ${config["api"+"Key"]}`;
-    }
-    const instructions = messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n").trim();
-    const input = messages.filter((message) => message.role !== "system").map((message) => ({
-      role: message.role,
-      content: [{
-        type: message.role === "assistant" ? "output_text" : "input_text",
-        text: message.content
-      }]
-    }));
-    const body = {
-      model: modelId,
-      input,
-      max_output_tokens: Math.max(0, Math.floor(options.maxTokens ?? 4096)),
-      ...buildChatCompletionTemperature(modelId, options.temperature ?? 0.3, {
-        assumeOpenAI: shouldAssumeOpenAiChatCompletions(config.baseUrl)
-      })
-    };
-    if (instructions.length > 0) {
-      body.instructions = instructions;
-    }
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      signal: options.signal,
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI Responses API error: ${response.status} ${error}`);
-    }
-    const data = await response.json();
-    const outputText = extractResponsesOutputText(data);
-    if (!outputText) {
-      throw new Error("Empty response from OpenAI Responses API");
-    }
-    return {
-      content: outputText,
-      usage: data.usage ? {
-        inputTokens: data.usage.input_tokens,
-        outputTokens: data.usage.output_tokens,
-        totalTokens: data.usage.total_tokens
-      } : void 0
-    };
-  }
-  /**
-   * Call Anthropic Messages API.
-   */
-  async callAnthropic(config, modelId, messages, options) {
-    const base = config.baseUrl.replace(/\/$/, "");
-    const url = base.endsWith("/v1") ? `${base}/messages` : `${base}/v1/messages`;
-    const headers = {
-      "Content-Type": "application/json",
-      "anthropic-version": "2023-06-01",
-      ...config.headers
-    };
-    if (config["api"+"Key"] && typeof config["api"+"Key"] === "string") {
-      headers["x-api-key"] = config["api"+"Key"];
-    }
-    const systemMessage = messages.find((m) => m.role === "system")?.content;
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const anthropicMessages = nonSystemMessages.map((m) => ({
-      role: m.role,
-      content: m.content
-    }));
-    const body = {
-      model: modelId,
-      messages: anthropicMessages,
-      max_tokens: options.maxTokens ?? 4096,
-      temperature: options.temperature ?? 0.3
-    };
-    if (systemMessage) {
-      body.system = systemMessage;
-    }
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      signal: options.signal,
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Anthropic API error: ${response.status} ${error}`);
-    }
-    const data = await response.json();
-    const content = data.content?.[0]?.text;
-    if (!content) {
-      throw new Error("Empty response from Anthropic API");
-    }
-    return {
-      content,
-      usage: data.usage ? {
-        inputTokens: data.usage.input_tokens,
-        outputTokens: data.usage.output_tokens,
-        totalTokens: (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0)
-      } : void 0
-    };
-  }
-};
-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();
-  return trimmed.length > 0 ? expandTildePath(trimmed) : void 0;
-}
-function readGatewayWorkspaceDir(gatewayConfig) {
-  if (!gatewayConfig || typeof gatewayConfig !== "object") return void 0;
-  const raw = gatewayConfig;
-  return normalizeRuntimePath(raw.workspaceDir) ?? normalizeRuntimePath(raw.workspacePath) ?? normalizeRuntimePath(raw.workspace);
-}
-function defaultOpenClawWorkspaceDir() {
-  return path2.join(resolveHomeDir(), ".openclaw", "workspace");
-}
-function extractResponsesOutputText(data) {
-  if (typeof data.output_text === "string" && data.output_text.trim().length > 0) {
-    return data.output_text;
-  }
-  const chunks = [];
-  for (const item of data.output ?? []) {
-    if (typeof item.text === "string" && item.text.trim().length > 0) {
-      chunks.push(item.text);
-    }
-    for (const part of item.content ?? []) {
-      if ((part.type === "output_text" || part.type === "text") && typeof part.text === "string" && part.text.trim().length > 0) {
-        chunks.push(part.text);
-      }
-    }
-  }
-  const joined = chunks.join("\n").trim();
-  return joined.length > 0 ? joined : null;
-}
-
-export {
-  FallbackLlmClient
-};