@remnic/plugin-openclaw 1.0.0

package/dist/chunk-TJZ7KBCC.js

@@ -0,0 +1,577 @@
+import {
+  log
+} from "./chunk-DMGIUDBO.js";
+
+// ../remnic-core/src/json-extract.ts
+function stripCodeFences(text) {
+  return text.replace(/```(?:json)?\s*([\s\S]*?)```/gi, (_m, inner) => String(inner).trim());
+}
+function extractJsonCandidates(text) {
+  const trimmed = text.trim();
+  const cleaned = stripCodeFences(trimmed);
+  const candidates = [];
+  if (cleaned.length > 0) candidates.push(cleaned);
+  candidates.push(...scanBalancedJsonBlocks(cleaned));
+  const objMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (objMatch) candidates.push(objMatch[0]);
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.map((c) => c.trim()).filter((c) => c.length > 0).filter((c) => {
+    if (seen.has(c)) return false;
+    seen.add(c);
+    return true;
+  });
+}
+function scanBalancedJsonBlocks(text) {
+  const out = [];
+  const opens = /* @__PURE__ */ new Set(["{", "["]);
+  const closes = { "{": "}", "[": "]" };
+  for (let i = 0; i < text.length; i++) {
+    const start = text[i];
+    if (!opens.has(start)) continue;
+    const expectedClose = closes[start];
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let j = i; j < text.length; j++) {
+      const ch = text[j];
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+        continue;
+      }
+      if (ch === start) depth++;
+      if (ch === expectedClose) depth--;
+      if (depth === 0) {
+        out.push(text.slice(i, j + 1).trim());
+        i = j;
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+// ../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 };
+}
+
+// ../remnic-core/src/runtime/env.ts
+import os from "os";
+var REMNIC_ENGRAM_PREFIX_PAIRS = [
+  ["REMNIC_", "ENGRAM_"],
+  ["ENGRAM_", "REMNIC_"]
+];
+function getEnvMap() {
+  const runtimeProcess = globalThis.process;
+  return runtimeProcess?.["env"];
+}
+function legacyEnvCandidates(name) {
+  const candidates = [name];
+  for (const [primary, legacy] of REMNIC_ENGRAM_PREFIX_PAIRS) {
+    if (name.startsWith(primary)) {
+      candidates.push(`${legacy}${name.slice(primary.length)}`);
+    }
+  }
+  return candidates;
+}
+function readEnvVar(name) {
+  const env = getEnvMap();
+  for (const candidate of legacyEnvCandidates(name)) {
+    const value = env?.[candidate];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function resolveHomeDir() {
+  return readEnvVar("HOME") || os.homedir();
+}
+function cloneEnv() {
+  return { ...getEnvMap() ?? {} };
+}
+function mergeEnv(overrides) {
+  const merged = cloneEnv();
+  for (const [key, value] of Object.entries(overrides)) {
+    if (typeof value === "string") merged[key] = value;
+    else delete merged[key];
+  }
+  return merged;
+}
+
+// ../remnic-core/src/resolve-provider-secret.ts
+import path from "path";
+import os2 from "os";
+var _resolveApiKeyForProvider = null;
+var _resolverLoaded = false;
+var _resolverNextRetryAt = 0;
+var RESOLVER_RETRY_BACKOFF_MS = 6e4;
+var resolvedCache = /* @__PURE__ */ new Map();
+async function getGatewayResolver() {
+  if (_resolverLoaded) {
+    return _resolveApiKeyForProvider;
+  }
+  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") {
+          _resolveApiKeyForProvider = mod.resolveApiKeyForProvider;
+          _resolverLoaded = true;
+          log.debug("loaded gateway resolveApiKeyForProvider from runtime module");
+          return _resolveApiKeyForProvider;
+        }
+      } 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() {
+  const { readdirSync } = await import("fs");
+  const { createRequire } = await import("module");
+  const candidates = [];
+  const distDirs = [];
+  try {
+    const req = createRequire(import.meta.url);
+    const openclawMain = req.resolve("openclaw");
+    const openclawDist = path.join(path.dirname(openclawMain), "..", "dist");
+    if (openclawDist) distDirs.push(path.resolve(openclawDist));
+  } catch {
+  }
+  try {
+    const { realpathSync } = await import("fs");
+    const mainScript = process.argv[1];
+    if (mainScript) {
+      const realScript = realpathSync(mainScript);
+      if (realScript.includes("openclaw")) {
+        const distDir = path.dirname(realScript);
+        if (!distDirs.includes(distDir)) distDirs.push(distDir);
+      }
+    }
+  } catch {
+  }
+  for (const dir of distDirs) {
+    try {
+      const files = readdirSync(dir);
+      for (const f of files) {
+        if (f.startsWith("runtime-model-auth.runtime-") && f.endsWith(".js")) {
+          candidates.push(path.join(dir, f));
+        }
+      }
+    } catch {
+    }
+  }
+  return candidates;
+}
+async function resolveProviderApiKey(providerId, apiKeyValue, gatewayConfig, agentDir) {
+  const cacheKey = `provider:${providerId}`;
+  if (resolvedCache.has(cacheKey)) {
+    return resolvedCache.get(cacheKey);
+  }
+  let resolved;
+  if (typeof apiKeyValue === "string" && apiKeyValue.trim().length > 0) {
+    if (apiKeyValue === "secretref-managed" || apiKeyValue.endsWith("-oauth") || apiKeyValue.endsWith("-local") || apiKeyValue === "lm-studio" || apiKeyValue.startsWith("gcp-")) {
+    } else {
+      resolved = apiKeyValue;
+      resolvedCache.set(cacheKey, resolved);
+      return resolved;
+    }
+  }
+  const resolver = await getGatewayResolver();
+  if (resolver) {
+    try {
+      const resolvedAgentDir = agentDir ?? path.join(os2.homedir(), ".openclaw", "agents", "main", "agent");
+      const auth = await resolver({ provider: providerId, cfg: gatewayConfig, agentDir: resolvedAgentDir });
+      if (auth?.apiKey) {
+        resolved = auth.apiKey;
+        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;
+}
+
+// ../remnic-core/src/fallback-llm.ts
+var FallbackLlmClient = class {
+  gatewayConfig;
+  constructor(gatewayConfig) {
+    this.gatewayConfig = gatewayConfig;
+  }
+  /**
+   * 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);
+    if (models.length === 0) {
+      log.warn("fallback LLM: no models configured in gateway");
+      return null;
+    }
+    const runChain = async () => {
+      for (let i = 0; i < models.length; i++) {
+        const model = models[i];
+        const isFallback = i > 0;
+        try {
+          const result = await this.tryModel(model, messages, options);
+          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) {
+          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;
+      try {
+        return await Promise.race([
+          runChain(),
+          new Promise((resolve) => {
+            timeoutHandle = setTimeout(() => {
+              log.warn(`fallback LLM: timed out after ${options.timeoutMs}ms`);
+              resolve(null);
+            }, options.timeoutMs);
+          })
+        ]);
+      } finally {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+      }
+    }
+    return await runChain();
+  }
+  /**
+   * 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) {
+    const chain = [];
+    const providers = this.gatewayConfig?.models?.providers;
+    if (!providers) return chain;
+    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 (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 providerId = parts[0];
+    const modelId = parts.slice(1).join("/");
+    const providerConfig = providers[providerId];
+    if (!providerConfig) {
+      log.warn(`fallback LLM: provider not found: ${providerId}`);
+      return null;
+    }
+    return { providerId, modelId, providerConfig, modelString };
+  }
+  /**
+   * Resolve the API key for a provider, handling OpenClaw secret ref formats.
+   * Results are cached per provider so exec calls only happen once.
+   */
+  async resolveApiKey(providerId, providerConfig) {
+    return resolveProviderApiKey(providerId, providerConfig.apiKey, this.gatewayConfig);
+  }
+  /**
+   * Try to call a single model.
+   */
+  async tryModel(model, messages, options) {
+    const rawKey = model.providerConfig.apiKey;
+    const needsResolution = rawKey === "secretref-managed" || typeof rawKey === "object" && rawKey !== null;
+    const resolvedApiKey = await this.resolveApiKey(model.providerId, model.providerConfig);
+    if (needsResolution && !resolvedApiKey) {
+      throw new Error(`API key for provider "${model.providerId}" could not be resolved from secret ref`);
+    }
+    const configWithResolvedKey = resolvedApiKey ? { ...model.providerConfig, apiKey: resolvedApiKey } : model.providerConfig;
+    switch (model.providerConfig.api) {
+      case "anthropic-messages":
+        return await this.callAnthropic(configWithResolvedKey, model.modelId, messages, options);
+      case "openai-completions":
+      default:
+        return await this.callOpenAI(
+          configWithResolvedKey,
+          model.modelId,
+          messages,
+          options,
+          shouldAssumeOpenAiChatCompletions(model.providerConfig.baseUrl)
+        );
+    }
+  }
+  /**
+   * 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.apiKey && typeof config.apiKey === "string") {
+      if (config.authHeader !== false) {
+        headers["Authorization"] = `Bearer ${config.apiKey}`;
+      }
+    }
+    const body = {
+      model: modelId,
+      messages,
+      temperature: options.temperature ?? 0.3,
+      ...buildChatCompletionTokenLimit(modelId, options.maxTokens ?? 4096, {
+        assumeOpenAI
+      })
+    };
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      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 Anthropic Messages API.
+   */
+  async callAnthropic(config, modelId, messages, options) {
+    const url = `${config.baseUrl.replace(/\/$/, "")}/messages`;
+    const headers = {
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01",
+      ...config.headers
+    };
+    if (config.apiKey && typeof config.apiKey === "string") {
+      headers["x-api-key"] = config.apiKey;
+    }
+    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,
+      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
+    };
+  }
+};
+
+export {
+  readEnvVar,
+  resolveHomeDir,
+  mergeEnv,
+  extractJsonCandidates,
+  shouldAssumeOpenAiChatCompletions,
+  buildChatCompletionTokenLimit,
+  FallbackLlmClient
+};