@remnic/plugin-openclaw 1.0.6 → 1.0.7

package/README.md

@@ -38,6 +38,42 @@ Then restart the gateway:
 launchctl kickstart -k gui/501/ai.openclaw.gateway
 ```
 
+## Benchmarking The OpenClaw Chain
+
+The benchmark CLI can now exercise the real OpenClaw-backed answer path instead
+of only the stripped retrieval harness. Use the `openclaw-chain` runtime
+profile to load the Remnic plugin config from `openclaw.json`, route answer
+generation through the configured gateway chain, and optionally attach a
+provider-backed judge:
+
+```bash
+remnic bench run longmemeval \
+  --runtime-profile openclaw-chain \
+  --openclaw-config ~/.openclaw/openclaw.json \
+  --gateway-agent-id memory-primary
+
+remnic bench run longmemeval \
+  --runtime-profile openclaw-chain \
+  --openclaw-config ~/.openclaw/openclaw.json \
+  --gateway-agent-id memory-primary \
+  --judge-provider openai \
+  --judge-model gpt-5.4-mini
+```
+
+To compare the stripped harness, direct Remnic runtime, and OpenClaw chain in a
+single pass, run a profile matrix:
+
+```bash
+remnic bench run longmemeval \
+  --matrix baseline,real,openclaw-chain \
+  --openclaw-config ~/.openclaw/openclaw.json \
+  --remnic-config ~/.config/remnic/config.json
+```
+
+Each stored result records its `runtimeProfile`, provider metadata, and the
+resolved Remnic config so benchmark comparisons can distinguish retrieval-only
+runs from real runtime and OpenClaw chain runs.
+
 ## What it does
 
 This plugin hooks into the OpenClaw gateway lifecycle:

package/dist/{calibration-3JHF25QT.js → calibration-BAC7KNKR.js}

@@ -1,6 +1,7 @@
 import {
   FallbackLlmClient
-} from "./chunk-3SA5F4WT.js";
+} from "./chunk-NXLHSCLU.js";
+import "./chunk-3A5ELHTT.js";
 import {
   listJsonFiles
 } from "./chunk-5LE4HTVL.js";

package/dist/{causal-consolidation-EBLROS42.js → causal-consolidation-S6M7UTZG.js}

@@ -12,7 +12,8 @@ import {
 } from "./chunk-YHH3SXKD.js";
 import {
   FallbackLlmClient
-} from "./chunk-3SA5F4WT.js";
+} from "./chunk-NXLHSCLU.js";
+import "./chunk-3A5ELHTT.js";
 import {
   listJsonFiles,
   readJsonFile

package/dist/chunk-3A5ELHTT.js

@@ -0,0 +1,61 @@
+// ../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;
+}
+
+export {
+  extractJsonCandidates
+};

package/dist/chunk-DIZW6H5J.js

@@ -0,0 +1,136 @@
+// ../remnic-core/src/contradiction/contradiction-review.ts
+import fs from "fs";
+import path from "path";
+import { createHash } from "crypto";
+function computePairId(memoryIdA, memoryIdB) {
+  const sorted = [memoryIdA, memoryIdB].sort();
+  return createHash("sha256").update(sorted.join("::")).digest("hex").slice(0, 24);
+}
+function reviewDir(memoryDir) {
+  return path.join(memoryDir, ".review", "contradictions");
+}
+function pairPath(memoryDir, pairId) {
+  if (pairId.includes("/") || pairId.includes("\\") || pairId.includes("..")) {
+    throw new Error(`Invalid pairId: ${pairId}`);
+  }
+  return path.join(reviewDir(memoryDir), `${pairId}.json`);
+}
+function ensureDir(memoryDir) {
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function writePair(memoryDir, pair) {
+  ensureDir(memoryDir);
+  const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1]);
+  const existing = readPair(memoryDir, pairId);
+  if (existing?.resolution) {
+    return existing;
+  }
+  if (existing && existing.confidence >= pair.confidence) {
+    return existing;
+  }
+  const full = {
+    ...pair,
+    pairId,
+    lastReviewedAt: existing?.lastReviewedAt,
+    resolution: existing?.resolution
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(full, null, 2), "utf-8");
+  fs.renameSync(tmpPath, filePath);
+  return full;
+}
+function writePairs(memoryDir, pairs) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const pair of pairs) {
+    const key = computePairId(pair.memoryIds[0], pair.memoryIds[1]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push(writePair(memoryDir, pair));
+  }
+  return results;
+}
+function readPair(memoryDir, pairId) {
+  const filePath = pairPath(memoryDir, pairId);
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.memoryIds)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function listPairs(memoryDir, options) {
+  const startTime = Date.now();
+  const dir = reviewDir(memoryDir);
+  const { filter = "all", namespace, limit = 50 } = options ?? {};
+  const pairs = [];
+  let total = 0;
+  if (!fs.existsSync(dir)) {
+    return { pairs: [], total: 0, durationMs: Date.now() - startTime };
+  }
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = fs.readFileSync(path.join(dir, entry), "utf-8");
+      const pair = JSON.parse(raw);
+      if (typeof pair !== "object" || pair === null) continue;
+      if (!Array.isArray(pair.memoryIds)) continue;
+      if (namespace && pair.namespace !== namespace) continue;
+      if (filter === "unresolved") {
+        if (pair.resolution) continue;
+        if (pair.verdict === "independent") continue;
+      } else if (filter !== "all" && pair.verdict !== filter) {
+        continue;
+      }
+      total++;
+      if (pairs.length < limit) pairs.push(pair);
+    } catch {
+      continue;
+    }
+  }
+  return { pairs, total, durationMs: Date.now() - startTime };
+}
+function isCoolingDown(pair, cooldownDays) {
+  if (cooldownDays <= 0) return false;
+  if (!pair.lastReviewedAt) return false;
+  const lastReviewed = new Date(pair.lastReviewedAt).getTime();
+  if (!Number.isFinite(lastReviewed)) return false;
+  const cooldownMs = cooldownDays * 24 * 60 * 60 * 1e3;
+  return Date.now() < lastReviewed + cooldownMs;
+}
+function resolvePair(memoryDir, pairId, verb) {
+  const existing = readPair(memoryDir, pairId);
+  if (!existing) return null;
+  const updated = {
+    ...existing,
+    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution: verb
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(updated, null, 2), "utf-8");
+  fs.renameSync(tmpPath, filePath);
+  return updated;
+}
+function memoryHashesChanged(_memoryDir, _pair, _getCurrentHash) {
+  return false;
+}
+
+export {
+  computePairId,
+  writePair,
+  writePairs,
+  readPair,
+  listPairs,
+  isCoolingDown,
+  resolvePair,
+  memoryHashesChanged
+};

package/dist/{chunk-3SA5F4WT.js → chunk-NXLHSCLU.js}

@@ -1,65 +1,10 @@
+import {
+  extractJsonCandidates
+} from "./chunk-3A5ELHTT.js";
 import {
   log
 } from "./chunk-UFU5GGGA.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();
@@ -183,13 +128,25 @@ async function getGatewayResolver() {
 async function findRuntimeModules() {
   const { readdirSync } = await import("fs");
   const { createRequire } = await import("module");
+  const { execFileSync } = await import("child_process");
   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 = createRequire(import.meta.url);
     const openclawMain = req.resolve("openclaw");
-    const openclawDist = path.join(path.dirname(openclawMain), "..", "dist");
-    if (openclawDist) distDirs.push(path.resolve(openclawDist));
+    pushDistDirs(openclawMain);
   } catch {
   }
   try {
@@ -198,12 +155,22 @@ async function findRuntimeModules() {
     if (mainScript) {
       const realScript = realpathSync(mainScript);
       if (realScript.includes("openclaw")) {
-        const distDir = path.dirname(realScript);
-        if (!distDirs.includes(distDir)) distDirs.push(distDir);
+        pushDistDirs(realScript);
       }
     }
   } catch {
   }
+  try {
+    const openclawBin = execFileSync("which", ["openclaw"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (openclawBin) {
+      const { realpathSync } = await import("fs");
+      pushDistDirs(realpathSync(openclawBin));
+    }
+  } catch {
+  }
   for (const dir of distDirs) {
     try {
       const files = readdirSync(dir);
@@ -218,7 +185,10 @@ async function findRuntimeModules() {
   return candidates;
 }
 async function resolveProviderApiKey(providerId, apiKeyValue, gatewayConfig, agentDir) {
-  const cacheKey = `provider:${providerId}`;
+  const resolvedAgentDir = path.resolve(
+    agentDir ?? path.join(os2.homedir(), ".openclaw", "agents", "main", "agent")
+  );
+  const cacheKey = `provider:${providerId}:agentDir:${resolvedAgentDir}`;
   if (resolvedCache.has(cacheKey)) {
     return resolvedCache.get(cacheKey);
   }
@@ -234,7 +204,6 @@ async function resolveProviderApiKey(providerId, apiKeyValue, gatewayConfig, age
   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;
@@ -310,8 +279,10 @@ function loadModelsJsonProviders() {
 // ../remnic-core/src/fallback-llm.ts
 var FallbackLlmClient = class {
   gatewayConfig;
-  constructor(gatewayConfig) {
+  runtimeContext;
+  constructor(gatewayConfig, runtimeContext = {}) {
     this.gatewayConfig = gatewayConfig;
+    this.runtimeContext = runtimeContext;
   }
   /**
    * Check if fallback is available (gateway config has at least one model).
@@ -513,6 +484,14 @@ var FallbackLlmClient = class {
     if (model.providerConfig.api === "anthropic-messages") {
       return await this.callAnthropic(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,
@@ -537,7 +516,8 @@ var FallbackLlmClient = class {
           api: model.providerConfig.api,
           baseUrl: model.providerConfig.baseUrl
         },
-        cfg: this.gatewayConfig
+        cfg: this.gatewayConfig,
+        workspaceDir: this.runtimeContext.workspaceDir
       });
       if (result?.apiKey || result?.baseUrl) {
         log.debug(
@@ -557,7 +537,12 @@ var FallbackLlmClient = class {
    * secret refs, etc.). Used as fallback when gateway runtime auth isn't available.
    */
   async resolveFallbackApiKey(model) {
-    return resolveProviderApiKey(model.providerId, model.providerConfig.apiKey, this.gatewayConfig);
+    return resolveProviderApiKey(
+      model.providerId,
+      model.providerConfig.apiKey,
+      this.gatewayConfig,
+      this.runtimeContext.agentDir
+    );
   }
   /**
    * Call OpenAI-compatible API.
@@ -605,11 +590,65 @@ var FallbackLlmClient = class {
       } : void 0
     };
   }
+  /**
+   * 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.apiKey && typeof config.apiKey === "string" && config.authHeader !== false) {
+      headers["Authorization"] = `Bearer ${config.apiKey}`;
+    }
+    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)),
+      temperature: options.temperature ?? 0.3
+    };
+    if (instructions.length > 0) {
+      body.instructions = instructions;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      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 url = `${config.baseUrl.replace(/\/$/, "")}/messages`;
+    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",
@@ -657,12 +696,29 @@ var FallbackLlmClient = class {
     };
   }
 };
+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 {
   readEnvVar,
   resolveHomeDir,
   mergeEnv,
-  extractJsonCandidates,
   shouldAssumeOpenAiChatCompletions,
   buildChatCompletionTokenLimit,
   FallbackLlmClient

package/dist/{chunk-GUKYM4XZ.js → chunk-SVGN3ACY.js}

@@ -4881,7 +4881,7 @@ var CompoundingEngine = class {
     let promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics) : [];
     if (this.config.cmcConsolidationEnabled) {
       try {
-        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-EBLROS42.js");
+        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-S6M7UTZG.js");
         const causalCandidates = await deriveCausalPromotionCandidates({
           memoryDir: this.config.memoryDir,
           causalTrajectoryStoreDir: this.config.causalTrajectoryStoreDir,
@@ -4913,7 +4913,7 @@ var CompoundingEngine = class {
     }
     if (this.config.calibrationEnabled) {
       try {
-        const { runCalibrationConsolidation } = await import("./calibration-3JHF25QT.js");
+        const { runCalibrationConsolidation } = await import("./calibration-BAC7KNKR.js");
         const calRules = await runCalibrationConsolidation({
           memoryDir: this.config.memoryDir,
           gatewayConfig: this.config.gatewayConfig,

package/dist/contradiction-review-SVGBS3V5.js

@@ -0,0 +1,21 @@
+import {
+  computePairId,
+  isCoolingDown,
+  listPairs,
+  memoryHashesChanged,
+  readPair,
+  resolvePair,
+  writePair,
+  writePairs
+} from "./chunk-DIZW6H5J.js";
+import "./chunk-MLKGABMK.js";
+export {
+  computePairId,
+  isCoolingDown,
+  listPairs,
+  memoryHashesChanged,
+  readPair,
+  resolvePair,
+  writePair,
+  writePairs
+};