@memtensor/memos-local-openclaw-plugin 1.0.4-beta.0 → 1.0.4-beta.10

package/src/index.ts

@@ -1,5 +1,6 @@
 import { v4 as uuid } from "uuid";
 import { buildContext } from "./config";
+import { ensureSqliteBinding } from "./storage/ensure-binding";
 import { SqliteStore } from "./storage/sqlite";
 import { Embedder } from "./embedding";
 import { IngestWorker } from "./ingest/worker";
@@ -56,13 +57,17 @@ export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
 
   ctx.log.info("Initializing memos-local plugin...");
 
+  ensureSqliteBinding(ctx.log);
+
   const store = new SqliteStore(ctx.config.storage!.dbPath!, ctx.log);
   const embedder = new Embedder(ctx.config.embedding, ctx.log, ctx.openclawAPI);
   const worker = new IngestWorker(store, embedder, ctx);
   const engine = new RecallEngine(store, embedder, ctx);
 
+  const sharedState = { lastSearchTime: 0 };
+
   const tools: ToolDefinition[] = [
-    createMemorySearchTool(engine, store, ctx),
+    createMemorySearchTool(engine, store, ctx, sharedState),
     createMemoryTimelineTool(store),
     createMemoryGetTool(store),
     createNetworkMemoryDetailTool(store, ctx),
@@ -84,7 +89,10 @@ export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
       const turnId = uuid();
       const tag = ctx.config.capture?.evidenceWrapperTag ?? "STORED_MEMORY";
 
-      const captured = captureMessages(messages, session, turnId, tag, ctx.log, owner);
+      const userSearchTime = sharedState.lastSearchTime || 0;
+      sharedState.lastSearchTime = 0;
+
+      const captured = captureMessages(messages, session, turnId, tag, ctx.log, owner, userSearchTime);
       if (captured.length > 0) {
         worker.enqueue(captured);
       }

package/src/ingest/providers/index.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, OpenClawAPI } from "../../types";
+import type { SummarizerConfig, SummaryProvider, Logger, OpenClawAPI } from "../../types";
 import { summarizeOpenAI, summarizeTaskOpenAI, generateTaskTitleOpenAI, judgeNewTopicOpenAI, filterRelevantOpenAI, judgeDedupOpenAI, parseFilterResult, parseDedupResult } from "./openai";
 import type { FilterResult, DedupResult } from "./openai";
 export type { FilterResult, DedupResult } from "./openai";
@@ -8,6 +8,40 @@ import { summarizeAnthropic, summarizeTaskAnthropic, generateTaskTitleAnthropic,
 import { summarizeGemini, summarizeTaskGemini, generateTaskTitleGemini, judgeNewTopicGemini, filterRelevantGemini, judgeDedupGemini } from "./gemini";
 import { summarizeBedrock, summarizeTaskBedrock, generateTaskTitleBedrock, judgeNewTopicBedrock, filterRelevantBedrock, judgeDedupBedrock } from "./bedrock";
 
+/**
+ * Detect provider type from provider key name or base URL.
+ */
+function detectProvider(
+  providerKey: string | undefined,
+  baseUrl: string,
+): SummaryProvider {
+  const key = providerKey?.toLowerCase() ?? "";
+  const url = baseUrl.toLowerCase();
+  if (key.includes("anthropic") || url.includes("anthropic")) return "anthropic";
+  if (key.includes("gemini") || url.includes("generativelanguage.googleapis.com")) {
+    return "gemini";
+  }
+  if (key.includes("bedrock") || url.includes("bedrock")) return "bedrock";
+  return "openai_compatible";
+}
+
+/**
+ * Return the correct endpoint for a given provider and base URL.
+ */
+function normalizeEndpointForProvider(
+  provider: SummaryProvider,
+  baseUrl: string,
+): string {
+  const stripped = baseUrl.replace(/\/+$/, "");
+  if (provider === "anthropic") {
+    if (stripped.endsWith("/v1/messages")) return stripped;
+    return `${stripped}/v1/messages`;
+  }
+  if (stripped.endsWith("/chat/completions")) return stripped;
+  if (stripped.endsWith("/completions")) return stripped;
+  return `${stripped}/chat/completions`;
+}
+
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
  * This serves as the final fallback when both strongCfg and plugin summarizer fail or are absent.
@@ -15,7 +49,8 @@ import { summarizeBedrock, summarizeTaskBedrock, generateTaskTitleBedrock, judge
 function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
   try {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+    const ocHome = process.env.OPENCLAW_STATE_DIR || path.join(home, ".openclaw");
+    const cfgPath = path.join(ocHome, "openclaw.json");
     if (!fs.existsSync(cfgPath)) return undefined;
 
     const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
@@ -36,13 +71,12 @@ function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const endpoint = baseUrl.endsWith("/chat/completions")
-      ? baseUrl
-      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+    const provider = detectProvider(providerKey, baseUrl);
+    const endpoint = normalizeEndpointForProvider(provider, baseUrl);
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
     return {
-      provider: "openai_compatible",
+      provider,
       endpoint,
       apiKey,
       model: modelId,

package/src/recall/engine.ts

@@ -74,10 +74,60 @@ export class RecallEngine {
       score: 1 / (i + 1),
     }));
 
+    // Step 1c: Hub memories search (when sharing is enabled and hub_memories exist)
+    let hubMemFtsRanked: Array<{ id: string; score: number }> = [];
+    let hubMemVecRanked: Array<{ id: string; score: number }> = [];
+    let hubMemPatternRanked: Array<{ id: string; score: number }> = [];
+    if (query && this.ctx.config.sharing?.enabled) {
+      try {
+        const hubFtsHits = this.store.searchHubMemories(query, { maxResults: candidatePool });
+        hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => ({
+          id: `hubmem:${hit.id}`, score: 1 / (i + 1),
+        }));
+      } catch { /* hub_memories table may not exist */ }
+      if (shortTerms.length > 0) {
+        try {
+          const hubPatternHits = this.store.hubMemoryPatternSearch(shortTerms, { limit: candidatePool });
+          hubMemPatternRanked = hubPatternHits.map((h, i) => ({
+            id: `hubmem:${h.memoryId}`, score: 1 / (i + 1),
+          }));
+        } catch { /* best-effort */ }
+      }
+      try {
+        const hubMemEmbs = this.store.getVisibleHubMemoryEmbeddings("");
+        if (hubMemEmbs.length > 0) {
+          const qv = await this.embedder.embedQuery(query).catch(() => null);
+          if (qv) {
+            const scored: Array<{ id: string; score: number }> = [];
+            for (const e of hubMemEmbs) {
+              let dot = 0, nA = 0, nB = 0;
+              for (let i = 0; i < qv.length && i < e.vector.length; i++) {
+                dot += qv[i] * e.vector[i]; nA += qv[i] * qv[i]; nB += e.vector[i] * e.vector[i];
+              }
+              const sim = nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
+              if (sim > 0.3) {
+                scored.push({ id: `hubmem:${e.memoryId}`, score: sim });
+              }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            hubMemVecRanked = scored.slice(0, candidatePool);
+          }
+        }
+      } catch { /* best-effort */ }
+      const hubTotal = hubMemFtsRanked.length + hubMemVecRanked.length + hubMemPatternRanked.length;
+      if (hubTotal > 0) {
+        this.ctx.log.debug(`recall: hub_memories candidates: fts=${hubMemFtsRanked.length}, vec=${hubMemVecRanked.length}, pattern=${hubMemPatternRanked.length}`);
+      }
+    }
+
     // Step 2: RRF fusion
     const ftsRanked = ftsCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
     const vecRanked = vecCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
-    const rrfScores = rrfFuse([ftsRanked, vecRanked, patternRanked], recallCfg.rrfK);
+    const allRankedLists = [ftsRanked, vecRanked, patternRanked];
+    if (hubMemFtsRanked.length > 0) allRankedLists.push(hubMemFtsRanked);
+    if (hubMemVecRanked.length > 0) allRankedLists.push(hubMemVecRanked);
+    if (hubMemPatternRanked.length > 0) allRankedLists.push(hubMemPatternRanked);
+    const rrfScores = rrfFuse(allRankedLists, recallCfg.rrfK);
 
     if (rrfScores.size === 0) {
       this.recordQuery(query, maxResults, minScore, 0);
@@ -101,6 +151,11 @@ export class RecallEngine {
 
     // Step 4: Time decay
     const withTs = mmrResults.map((r) => {
+      if (r.id.startsWith("hubmem:")) {
+        const memId = r.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        return { ...r, createdAt: mem?.createdAt ?? 0 };
+      }
       const chunk = this.store.getChunk(r.id);
       return { ...r, createdAt: chunk?.createdAt ?? 0 };
     });
@@ -128,6 +183,34 @@ export class RecallEngine {
     const hits: SearchHit[] = [];
     for (const candidate of normalized) {
       if (hits.length >= maxResults) break;
+
+      if (candidate.id.startsWith("hubmem:")) {
+        const memId = candidate.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        if (!mem) continue;
+        if (roleFilter && mem.role !== roleFilter) continue;
+        hits.push({
+          summary: mem.summary || mem.content.slice(0, 200),
+          original_excerpt: mem.content,
+          ref: {
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+            chunkId: mem.id,
+            turnId: "",
+            seq: 0,
+          },
+          score: Math.round(candidate.score * 1000) / 1000,
+          taskId: null,
+          skillId: null,
+          owner: `hub-user:${mem.sourceUserId}`,
+          source: {
+            ts: mem.createdAt,
+            role: (mem.role || "assistant") as any,
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+          },
+        });
+        continue;
+      }
+
       const chunk = this.store.getChunk(candidate.id);
       if (!chunk) continue;
       if (roleFilter && chunk.role !== roleFilter) continue;

package/src/shared/llm-call.ts

@@ -1,6 +1,34 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, PluginContext, OpenClawAPI } from "../types";
+import type { SummarizerConfig, SummaryProvider, Logger, PluginContext, OpenClawAPI } from "../types";
+
+/**
+ * Detect provider type from provider key name or base URL.
+ */
+function detectProvider(providerKey: string | undefined, baseUrl: string): SummaryProvider {
+  const key = providerKey?.toLowerCase() ?? "";
+  const url = baseUrl.toLowerCase();
+  if (key.includes("anthropic") || url.includes("anthropic")) return "anthropic";
+  if (key.includes("gemini") || url.includes("generativelanguage.googleapis.com")) {
+    return "gemini";
+  }
+  if (key.includes("bedrock") || url.includes("bedrock")) return "bedrock";
+  return "openai_compatible";
+}
+
+/**
+ * Return the correct default endpoint for a given provider.
+ */
+function defaultEndpointForProvider(provider: SummaryProvider, baseUrl: string): string {
+  const stripped = baseUrl.replace(/\/+$/, "");
+  if (provider === "anthropic") {
+    if (stripped.endsWith("/v1/messages")) return stripped;
+    return `${stripped}/v1/messages`;
+  }
+  if (stripped.endsWith("/chat/completions")) return stripped;
+  if (stripped.endsWith("/completions")) return stripped;
+  return `${stripped}/chat/completions`;
+}
 
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
@@ -30,13 +58,12 @@ export function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | unde
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const endpoint = baseUrl.endsWith("/chat/completions")
-      ? baseUrl
-      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+    const provider = detectProvider(providerKey, baseUrl);
+    const endpoint = defaultEndpointForProvider(provider, baseUrl);
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
     return {
-      provider: "openai_compatible",
+      provider,
       endpoint,
       apiKey,
       model: modelId,
@@ -70,23 +97,34 @@ export interface LLMCallOptions {
   openclawAPI?: OpenClawAPI;
 }
 
-function normalizeEndpoint(url: string): string {
+function normalizeOpenAIEndpoint(url: string): string {
   const stripped = url.replace(/\/+$/, "");
   if (stripped.endsWith("/chat/completions")) return stripped;
   if (stripped.endsWith("/completions")) return stripped;
   return `${stripped}/chat/completions`;
 }
 
+function normalizeAnthropicEndpoint(url: string): string {
+  const stripped = url.replace(/\/+$/, "");
+  if (stripped.endsWith("/v1/messages")) return stripped;
+  if (stripped.endsWith("/messages")) return stripped;
+  return `${stripped}/v1/messages`;
+}
+
+function isAnthropicProvider(cfg: SummarizerConfig): boolean {
+  return cfg.provider === "anthropic";
+}
+
 /**
  * Make a single LLM call with the given config. Throws on failure.
  * When cfg.provider === "openclaw", delegates to the OpenClaw host completion API.
+ * Dispatches to Anthropic or OpenAI-compatible format based on provider.
  */
 export async function callLLMOnce(
   cfg: SummarizerConfig,
   prompt: string,
   opts: LLMCallOptions = {},
 ): Promise<string> {
-  // Handle openclaw provider via host completion API
   if (cfg.provider === "openclaw") {
     const api = opts.openclawAPI;
     if (!api) {
@@ -101,7 +139,57 @@ export async function callLLMOnce(
     return response.text.trim();
   }
 
-  const endpoint = normalizeEndpoint(cfg.endpoint ?? "https://api.openai.com/v1/chat/completions");
+  if (isAnthropicProvider(cfg)) {
+    return callLLMOnceAnthropic(cfg, prompt, opts);
+  }
+  return callLLMOnceOpenAI(cfg, prompt, opts);
+}
+
+async function callLLMOnceAnthropic(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeAnthropicEndpoint(
+    cfg.endpoint ?? "https://api.anthropic.com/v1/messages",
+  );
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      temperature: opts.temperature ?? 0.1,
+      max_tokens: opts.maxTokens ?? 1024,
+      messages: [{ role: "user", content: prompt }],
+    }),
+    signal: AbortSignal.timeout(opts.timeoutMs ?? 30_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`LLM call failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  return json.content.find((c) => c.type === "text")?.text?.trim() ?? "";
+}
+
+async function callLLMOnceOpenAI(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeOpenAIEndpoint(
+    cfg.endpoint ?? "https://api.openai.com/v1/chat/completions",
+  );
   const model = cfg.model ?? "gpt-4o-mini";
   const headers: Record<string, string> = {
     "Content-Type": "application/json",

package/src/sharing/types.ts

@@ -12,7 +12,7 @@ import type {
 export type HubScope = "local" | "group" | "all";
 export type SharedVisibility = "group" | "public";
 export type UserRole = "admin" | "member";
-export type UserStatus = "pending" | "active" | "blocked" | "rejected";
+export type UserStatus = "pending" | "active" | "blocked" | "rejected" | "removed";
 
 export type { ClientModeConfig, HubModeConfig, SharingCapabilities, SharingConfig, SharingRole };
 

package/src/skill/evolver.ts

@@ -12,6 +12,8 @@ import { SkillUpgrader } from "./upgrader";
 import { SkillInstaller } from "./installer";
 import { buildSkillConfigChain, callLLMWithFallback } from "../shared/llm-call";
 
+export type SkillEvolvedCallback = (skillName: string, upgradeType: "created" | "upgraded") => void;
+
 export class SkillEvolver {
   private evaluator: SkillEvaluator;
   private generator: SkillGenerator;
@@ -19,6 +21,7 @@ export class SkillEvolver {
   private installer: SkillInstaller;
   private processing = false;
   private queue: Task[] = [];
+  onSkillEvolved: SkillEvolvedCallback | null = null;
 
   constructor(
     private store: SqliteStore,
@@ -279,6 +282,7 @@ Use selectedIndex 0 when none is highly relevant.`;
       if (upgraded) {
         this.store.linkTaskSkill(task.id, freshSkill.id, "evolved_from", freshSkill.version + 1);
         this.installer.syncIfInstalled(freshSkill.name);
+        this.onSkillEvolved?.(freshSkill.name, "upgraded");
       } else {
         this.store.linkTaskSkill(task.id, freshSkill.id, "applied_to", freshSkill.version);
       }
@@ -307,6 +311,7 @@ Use selectedIndex 0 when none is highly relevant.`;
       this.markChunksWithSkill(chunks, skill.id);
       this.store.linkTaskSkill(task.id, skill.id, "generated_from", 1);
       this.store.setTaskSkillMeta(task.id, { skillStatus: "generated", skillReason: evalResult.reason });
+      this.onSkillEvolved?.(skill.name, "created");
 
       const autoInstall = this.ctx.config.skillEvolution?.autoInstall ?? DEFAULTS.skillAutoInstall;
       if (autoInstall && skill.status === "active") {

package/src/storage/ensure-binding.ts

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, copyFileSync } from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import { createRequire } from "module";
+
+/**
+ * Ensure the better-sqlite3 native binary is available.
+ *
+ * OpenClaw installs plugins with `--ignore-scripts`, which skips
+ * the native compilation step. This function checks for the binary
+ * and restores it from bundled prebuilds if missing.
+ */
+export function ensureSqliteBinding(log?: { info: (msg: string) => void; warn: (msg: string) => void }): void {
+  const _req = typeof require !== "undefined" ? require : createRequire(__filename);
+  const bsqlPkg = _req.resolve("better-sqlite3/package.json");
+  const bsqlDir = path.dirname(bsqlPkg);
+  const bindingPath = path.join(bsqlDir, "build", "Release", "better_sqlite3.node");
+
+  if (existsSync(bindingPath)) return;
+
+  const platform = `${process.platform}-${process.arch}`;
+  const pluginRoot = path.resolve(__dirname, "..", "..");
+  const prebuildSrc = path.join(pluginRoot, "prebuilds", platform, "better_sqlite3.node");
+
+  if (existsSync(prebuildSrc)) {
+    log?.info(`[ensure-binding] Copying prebuild for ${platform}...`);
+    mkdirSync(path.dirname(bindingPath), { recursive: true });
+    copyFileSync(prebuildSrc, bindingPath);
+    log?.info(`[ensure-binding] Prebuild installed successfully.`);
+    return;
+  }
+
+  log?.warn(`[ensure-binding] No prebuild for ${platform}, attempting npm rebuild...`);
+  try {
+    const installDir = path.resolve(bsqlDir, "..", "..");
+    execSync("npm rebuild better-sqlite3", {
+      cwd: installDir,
+      stdio: "pipe",
+      timeout: 180_000,
+    });
+    if (existsSync(bindingPath)) {
+      log?.info(`[ensure-binding] Rebuilt better-sqlite3 successfully.`);
+      return;
+    }
+  } catch { /* fall through */ }
+
+  throw new Error(
+    `better-sqlite3 native binary not found for ${platform}.\n` +
+    `Prebuild not bundled and npm rebuild failed.\n` +
+    `Fix: cd ${path.resolve(bsqlDir, "..", "..")} && npm rebuild better-sqlite3`,
+  );
+}