@openviking/openclaw-plugin 2026.9.1 → 2026.9.4-1

package/openclaw.plugin.json

@@ -80,14 +80,14 @@
       "help": "HTTP URL when mode is remote (or ${OPENVIKING_BASE_URL})"
     },
     "peer_role": {
-      "label": "Peer Role",
-      "placeholder": "assistant",
-      "help": "Controls which messages include peer_id: none, assistant, or person. New installs default to assistant."
+      "label": "Memory Scope (peer_role)",
+      "placeholder": "none",
+      "help": "Where peer-scoped memories are stored. none (default): viking://user/<user_id>/memories. assistant: viking://user/<user_id>/peers/<assistant_id>/memories. sender: viking://user/<user_id>/peers/<sender_id>/memories. Legacy person is accepted as sender."
     },
     "peer_prefix": {
       "label": "Peer Prefix",
       "placeholder": "optional-prefix",
-      "help": "Optional prefix for assistant peer_id values derived from OpenClaw runtime agent IDs."
+      "help": "Only used when Memory Scope is assistant. Prefix added to the peer id derived from the OpenClaw agent id."
     },
     "apiKey": {
       "label": "OpenViking API Key",
@@ -144,9 +144,9 @@
     },
     "autoRecallTimeoutMs": {
       "label": "Auto-Recall Timeout (ms)",
-      "placeholder": "5000",
+      "placeholder": "15000",
       "advanced": true,
-      "help": "Outer time budget for the whole auto-recall flow, including search, ranking, and memory reads."
+      "help": "Outer time budget for the server-assembled context search, including session-aware query expansion."
     },
     "recallResources": {
       "label": "Recall Resources",
@@ -279,10 +279,11 @@
         "enum": [
           "none",
           "assistant",
+          "sender",
           "person"
         ],
-        "default": "assistant",
-        "description": "Controls which session messages include peer_id."
+        "default": "none",
+        "description": "Memory scope. none: shared user memory. assistant: peer memory keyed by OpenClaw assistant id. sender: peer memory keyed by sender id. person is a legacy alias for sender. Also controls which session messages include peer_id."
       },
       "peer_prefix": {
         "type": "string",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/openclaw-plugin",
-  "version": "2026.9.1",
+  "version": "2026.9.4-1",
   "displayName": "OpenViking",
   "description": "OpenClaw context-engine plugin — OpenViking AI memory, long-term memory, knowledge base, semantic search, RAG, context engine. 长期记忆 · 知识库 · 语义检索 · 上下文引擎",
   "type": "module",
@@ -26,6 +26,7 @@
     "config/feature-gates.json",
     "registries/",
     "routing/",
+    "shared/",
     "plugin/",
     "services/",
     "!vitest.config.ts",

package/plugin/openviking-client-runtime.ts

@@ -9,7 +9,7 @@ type Logger = {
 type ClientRuntimeConfig = {
   baseUrl: string;
   apiKey: string;
-  peer_role: "none" | "assistant" | "person";
+  peer_role: "none" | "assistant" | "sender";
   peer_prefix: string;
   timeoutMs: number;
   accountId?: string;

package/plugin/openviking-memory-tools.ts

@@ -114,7 +114,7 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
           const peerId = resolveOpenVikingMessagePeerId({
             peerRole: deps.peerRole,
             role,
-            personPeerId: session.actorPeerId,
+            senderPeerId: session.actorPeerId,
             assistantPeerId: session.actorPeerId,
           });
           await client.addSessionMessage(

package/plugin/openviking-session-routing-runtime.ts

@@ -34,7 +34,7 @@ export function createOpenVikingSessionRoutingRuntime(options: {
   logFindRequests: boolean;
   logger: Logger;
 }) {
-  const peerRole = options.peerRole ?? "assistant";
+  const peerRole = options.peerRole ?? "none";
   const sessionAgentResolver = createSessionAgentResolver(options.peerPrefix);
 
   const rememberSessionAgentId = (ctx: SessionAgentLookup) => {
@@ -97,7 +97,7 @@ export function createOpenVikingSessionRoutingRuntime(options: {
       agentId,
       actorPeerId: resolveOpenVikingActorPeerId({
         peerRole,
-        personPeerId: sanitizeOpenVikingPeerId(ctx?.requesterSenderId ?? ctx?.senderId),
+        senderPeerId: sanitizeOpenVikingPeerId(ctx?.requesterSenderId ?? ctx?.senderId),
         assistantPeerId: agentId,
       }),
     };

package/routing/identity-routing.ts

@@ -15,7 +15,7 @@ export type SessionAgentLookup = {
   ovSessionId?: string;
 };
 
-export type OpenVikingPeerRole = "none" | "assistant" | "person";
+export type OpenVikingPeerRole = "none" | "assistant" | "sender";
 
 export function sanitizeOpenVikingPeerId(raw?: string): string | undefined {
   const normalized = raw
@@ -29,11 +29,11 @@ export function sanitizeOpenVikingPeerId(raw?: string): string | undefined {
 export function resolveOpenVikingMessagePeerId(params: {
   peerRole: OpenVikingPeerRole;
   role?: string;
-  personPeerId?: string;
+  senderPeerId?: string;
   assistantPeerId?: string;
 }): string | undefined {
-  if (params.peerRole === "person" && params.role === "user") {
-    return params.personPeerId;
+  if (params.peerRole === "sender" && params.role === "user") {
+    return params.senderPeerId;
   }
   if (params.peerRole === "assistant" && params.role === "assistant") {
     return params.assistantPeerId;
@@ -43,15 +43,15 @@ export function resolveOpenVikingMessagePeerId(params: {
 
 export function resolveOpenVikingActorPeerId(params: {
   peerRole: OpenVikingPeerRole;
-  personPeerId?: string;
+  senderPeerId?: string;
   assistantPeerId?: string;
 }): string | undefined {
   const actorPeerId = resolveOpenVikingMessagePeerId({
     ...params,
-    role: params.peerRole === "person" ? "user" : "assistant",
+    role: params.peerRole === "sender" ? "user" : "assistant",
   });
-  if (params.peerRole === "person" && !actorPeerId) {
-    throw new Error("openviking: peer_role=person requires a sender identity");
+  if (params.peerRole === "sender" && !actorPeerId) {
+    throw new Error("openviking: peer_role=sender requires a sender identity");
   }
   return actorPeerId;
 }

package/services/context-lifecycle-service.ts

@@ -497,8 +497,8 @@ export async function assembleOpenVikingSession({
       const routingRef = sessionId ?? sessionKey ?? ovSessionId;
       const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
       const actorPeerId = resolveOpenVikingActorPeerId({
-        peerRole: cfg.peer_role ?? "assistant",
-        personPeerId: sanitizeOpenVikingPeerId(sender.senderId),
+        peerRole: cfg.peer_role ?? "none",
+        senderPeerId: sanitizeOpenVikingPeerId(sender.senderId),
         assistantPeerId: agentId,
       });
       const queryConfig = await queryConfigStore?.getEffective({
@@ -910,9 +910,9 @@ export async function afterTurnOpenVikingSession({
           undefined,
           createdAt,
           resolveOpenVikingMessagePeerId({
-            peerRole: cfg.peer_role ?? "assistant",
+            peerRole: cfg.peer_role ?? "none",
             role: msg.role,
-            personPeerId: senderRoleId,
+            senderPeerId: senderRoleId,
             assistantPeerId: agentId,
           }),
         );

package/services/setup/setup-flow.ts

@@ -13,6 +13,8 @@ import {
 
 export type { SetupIO, SlotActivationResult };
 
+type SetupPeerRole = "none" | "assistant" | "sender" | "person";
+
 export type VersionCompatibility = "compatible" | "server_too_old" | "server_too_new" | "unknown";
 
 export type HealthResult = {
@@ -38,7 +40,7 @@ export type SetupResult = {
     mode: string;
     baseUrl: string;
     apiKey?: string;
-    peer_role?: "none" | "assistant" | "person";
+    peer_role?: SetupPeerRole;
     peer_prefix?: string;
     accountId?: string;
     userId?: string;
@@ -57,7 +59,7 @@ export type StatusResult = {
     mode: string;
     baseUrl: string;
     hasApiKey: boolean;
-    peer_role?: "none" | "assistant" | "person";
+    peer_role?: SetupPeerRole;
     peer_prefix?: string;
     hasAccountId: boolean;
     hasUserId: boolean;
@@ -71,7 +73,7 @@ export type SetupParams = {
   baseUrl: string;
   apiKey?: string;
   headers?: OpenVikingRequestHeaders;
-  peerRole?: "none" | "assistant" | "person";
+  peerRole?: SetupPeerRole;
   peerPrefix?: string;
   accountId?: string;
   userId?: string;
@@ -85,7 +87,7 @@ export type InteractiveRemoteConfigParams = {
   baseUrl: string;
   apiKey?: string;
   headers?: OpenVikingRequestHeaders;
-  peerRole?: "none" | "assistant" | "person";
+  peerRole?: SetupPeerRole;
   peerPrefix?: string;
   accountId?: string;
   userId?: string;
@@ -315,7 +317,7 @@ export function createOpenVikingSetupService({
           baseUrl,
           ...(apiKey ? { apiKey: maskKey(apiKey) } : {}),
           ...(headers ? { headers } : {}),
-          ...(existing.peer_role ? { peer_role: String(existing.peer_role) as "none" | "assistant" | "person" } : {}),
+          ...(existing.peer_role ? { peer_role: String(existing.peer_role) as SetupPeerRole } : {}),
           ...(existing.peer_prefix ? { peer_prefix: String(existing.peer_prefix) } : {}),
           ...(existing.accountId ? { accountId: String(existing.accountId) } : {}),
           ...(existing.userId ? { userId: String(existing.userId) } : {}),
@@ -346,7 +348,7 @@ export function createOpenVikingSetupService({
           mode: String(existing.mode ?? "remote"),
           baseUrl,
           hasApiKey: !!existing.apiKey,
-          ...(existing.peer_role ? { peer_role: String(existing.peer_role) as "none" | "assistant" | "person" } : {}),
+          ...(existing.peer_role ? { peer_role: String(existing.peer_role) as SetupPeerRole } : {}),
           ...(existing.peer_prefix ? { peer_prefix: String(existing.peer_prefix) } : {}),
           hasAccountId: !!existing.accountId,
           hasUserId: !!existing.userId,

package/shared/recall-compress-core.mjs

@@ -0,0 +1,195 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export const NO_RELEVANT_MEMORY = "NO_RELEVANT_MEMORY";
+export const DIGEST_HEADER = "OpenViking memory digest:";
+const COMPRESS_OK = "ok";
+const COMPRESS_EMPTY = "empty";
+const COMPRESS_FAILED = "failed";
+
+// Medium-constraint prompt: state the goal and two structural floors, but no hard
+// bullet-length contract. Hard per-bullet limits pin the digest to headline
+// density; leaving it unconstrained lets small models rewrite long URIs into dead
+// links, which the URI repair below cleans up.
+export function buildRecallCompressionPrompt({ query, rendered, maxBullets = 6 }) {
+  return `You are a memory relevance compressor utility.
+Do not use any tools. Do not investigate. Only transform the given text.
+
+User query:
+${query}
+
+Retrieved OpenViking context fragments:
+${rendered}
+
+Write a memory digest for a coding agent about to answer that query. Keep the
+concrete facts (paths, identifiers, decisions, constraints); drop pleasantries
+and conversational filler.
+
+Format rules:
+- Group related facts by topic, one bullet per topic, at most ${maxBullets} bullets.
+- Start every bullet with "- ".
+- End every bullet with its source, copied verbatim from the fragments above:
+  "来源：viking://..." or "source: viking://...". Never edit, shorten, or invent a URI.
+- Output the digest body only. No preamble, no closing remark.
+
+If nothing above is relevant to the query, output exactly: ${NO_RELEVANT_MEMORY}`;
+}
+
+function editDistance(a, b) {
+  if (a === b) return 0;
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  let prev = Array.from({ length: cols }, (_, i) => i);
+  for (let i = 1; i < rows; i += 1) {
+    const cur = [i];
+    for (let j = 1; j < cols; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      cur[j] = Math.min(cur[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    prev = cur;
+  }
+  return prev[cols - 1];
+}
+
+function nearestUri(candidate, validUris) {
+  let best = "";
+  let bestDistance = Infinity;
+  for (const uri of validUris) {
+    const distance = editDistance(candidate, uri);
+    if (distance < bestDistance) {
+      best = uri;
+      bestDistance = distance;
+    }
+  }
+  // Only repair near-misses; an unrelated hallucination is dropped instead.
+  const tolerance = Math.max(4, Math.floor(candidate.length * 0.25));
+  return bestDistance <= tolerance ? best : "";
+}
+
+/**
+ * Small models occasionally mangle long URIs. Snap every cited URI back onto the
+ * set the server actually returned, and drop bullets whose citation cannot be
+ * recovered so the digest never carries a dead link.
+ */
+export function repairDigestUris(digest, validUris = []) {
+  const text = String(digest || "");
+  if (!text) return "";
+  const valid = validUris.map((uri) => String(uri || "").trim()).filter(Boolean);
+  if (!valid.length) return text;
+  const validSet = new Set(valid);
+
+  const lines = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim().startsWith("- ")) {
+      lines.push(line);
+      continue;
+    }
+    let dropped = false;
+    const repaired = line.replace(/viking:\/\/[^\s<>"')\]]+/g, (uri) => {
+      if (validSet.has(uri)) return uri;
+      const nearest = nearestUri(uri, valid);
+      if (nearest) return nearest;
+      dropped = true;
+      return uri;
+    });
+    if (!dropped) lines.push(repaired);
+  }
+  return lines.join("\n").trim();
+}
+
+export function normalizeCompressedContext(raw, maxChars = 4000, maxBullets = 6) {
+  const text = String(raw || "").trim();
+  if (!text) return null;
+  if (text.toUpperCase() === NO_RELEVANT_MEMORY) return "";
+  const bullets = text.split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => /^[-*]\s+/.test(line) && line.includes("viking://"))
+    .slice(0, Math.max(1, maxBullets))
+    .map((line) => `- ${line.replace(/^[-*]\s+/, "").slice(0, 500).trim()}`);
+  if (!bullets.length) return null;
+  return (`${DIGEST_HEADER}\n${bullets.join("\n")}`).slice(0, Math.max(100, maxChars));
+}
+
+export function recallDigestCacheKey({
+  query = "",
+  rendered = "",
+  entries = [],
+  maxInputChars = 18000,
+  maxBullets = 6,
+} = {}) {
+  const uris = entries.map((entry) => String(entry?.uri || "").trim()).filter(Boolean).sort();
+  const source = JSON.stringify({
+    version: 2,
+    query: String(query),
+    rendered: String(rendered).slice(0, maxInputChars),
+    uris,
+    maxInputChars,
+    maxBullets,
+  });
+  return createHash("sha256").update(source).digest("hex");
+}
+
+async function readCache(path) {
+  if (!path) return null;
+  try { return JSON.parse(await readFile(path, "utf8")); } catch { return null; }
+}
+
+async function writeCache(path, value) {
+  if (!path) return;
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp`;
+    await writeFile(tmp, JSON.stringify(value));
+    await rename(tmp, path);
+  } catch { /* best effort */ }
+}
+
+export async function compressRecallContext({
+  query,
+  rendered,
+  entries = [],
+  cfg = {},
+  runCompressor,
+  cachePath = "",
+  now = 0,
+}) {
+  const input = String(rendered || "").trim();
+  if (!input) return { status: COMPRESS_EMPTY, context: "" };
+  const minChars = Math.max(0, Number(cfg.recallCompressMinInputChars ?? 1500));
+  if (input.length < minChars) return { status: COMPRESS_OK, context: input };
+
+  const maxInputChars = Math.max(1000, Number(cfg.recallCompressMaxInputChars || 18000));
+  const maxBullets = Math.max(1, Number(cfg.recallCompressMaxBullets || 6));
+  const key = recallDigestCacheKey({
+    query,
+    rendered: input,
+    entries,
+    maxInputChars,
+    maxBullets,
+  });
+  const cached = await readCache(cachePath);
+  if (cached?.key === key && typeof cached.digest === "string") {
+    return { status: COMPRESS_OK, context: cached.digest };
+  }
+
+  const prompt = buildRecallCompressionPrompt({
+    query,
+    rendered: input.slice(0, maxInputChars),
+    maxBullets,
+  });
+  const raw = await runCompressor(prompt);
+  const normalized = normalizeCompressedContext(raw, 4000, maxBullets);
+  if (normalized === null) return { status: COMPRESS_FAILED, context: "" };
+  if (!normalized) return { status: COMPRESS_EMPTY, context: "" };
+
+  const validUris = entries.map((entry) => entry?.uri).filter(Boolean);
+  const digest = repairDigestUris(normalized, validUris.length
+    ? validUris
+    : (input.match(/viking:\/\/[^\s<>"']+/g) || []));
+  if (!digest) return { status: COMPRESS_FAILED, context: "" };
+
+  await writeCache(cachePath, { key, digest, updatedAt: now || 0 });
+  return { status: COMPRESS_OK, context: digest };
+}

package/shared/recall-core.d.mts

@@ -0,0 +1,39 @@
+export type ContextSearchBody = {
+  query: string;
+  mode: "context";
+  purpose: "coding";
+  score_threshold: number;
+  quotas?: Record<string, number>;
+  max_tokens?: number;
+  peer_scope?: "actor";
+  session_id?: string;
+  query_expansion?: "off" | "auto";
+  dedup_turns?: number;
+  exclude_uris?: string[];
+  rewrite?: boolean | "auto";
+  rewrite_max_bullets?: number;
+};
+
+export type NormalizedContextEntry = {
+  uri: string;
+  category: string;
+  detail: string;
+  score: number;
+  text: string;
+};
+
+export function buildContextSearchBody(
+  cfg?: Record<string, unknown>,
+  options?: {
+    sessionId?: string;
+    excludeUris?: string[];
+    localCompressorAvailable?: boolean;
+  },
+): ContextSearchBody;
+
+export function contextRequestTimeoutMs(
+  cfg?: Record<string, unknown>,
+  body?: Record<string, unknown>,
+): number | undefined;
+
+export function normalizeContextEntry(entry?: unknown): NormalizedContextEntry;