@openviking/openclaw-plugin 2026.6.18 → 2026.7.15

package/dist/commands/setup.js

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 import { getEnv } from "../runtime-utils.js";
+import { cleanOpenVikingRequestHeaders, resolveOpenVikingRequestHeaders, } from "../request-headers.js";
 const HOME = os.homedir();
 const OPENCLAW_DIR = getEnv("OPENCLAW_STATE_DIR") || path.join(HOME, ".openclaw");
 const DEFAULT_REMOTE_URL = "http://127.0.0.1:1933";
@@ -55,6 +56,7 @@ const PLUGIN_VERSION = readPluginVersion();
 const { min: COMPATIBLE_SERVER_MIN, max: COMPATIBLE_SERVER_MAX } = readCompatRangeFromManifest();
 const CONFIG_KEYS_TO_PRESERVE = [
     "targetUri",
+    "headers",
     "timeoutMs",
     "autoCapture",
     "captureMode",
@@ -68,7 +70,7 @@ const CONFIG_KEYS_TO_PRESERVE = [
     "recallMaxContentChars",
     "recallPreferAbstract",
     "recallTokenBudget",
-    "commitTokenThreshold",
+    "commitTokenThresholdRatio",
     "commitKeepRecentCount",
     "bypassSessionPatterns",
     "emitStandardDiagnostics",
@@ -84,6 +86,10 @@ function maskKey(key) {
         return "****";
     return `${key.slice(0, 4)}...${key.slice(-4)}`;
 }
+function nonEmptyOpenVikingRequestHeaders(value) {
+    const headers = cleanOpenVikingRequestHeaders(value);
+    return Object.keys(headers).length > 0 ? headers : undefined;
+}
 function isValidPeerPrefixInput(value) {
     const trimmed = value.trim();
     return !trimmed || /^[a-zA-Z0-9_-]+$/.test(trimmed);
@@ -234,14 +240,17 @@ function formatCompatRange() {
         return `<= ${COMPATIBLE_SERVER_MAX}`;
     return "any";
 }
-async function probeApiKeyType(baseUrl, apiKey) {
+async function probeApiKeyType(baseUrl, apiKey, configuredHeaders) {
     if (!apiKey)
         return { keyType: "no_key", needsAccountId: false, needsUserId: false, detail: "No API key configured" };
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10_000);
     const sessionsUrl = `${baseUrl.replace(/\/+$/, "")}/api/v1/sessions?limit=1`;
     try {
-        const headers = { "X-API-Key": apiKey };
+        const configuredRequestHeaders = resolveOpenVikingRequestHeaders({ headers: configuredHeaders });
+        const headers = {};
+        headers["X-API-Key"] = apiKey;
+        Object.assign(headers, configuredRequestHeaders);
         const response = await fetch(sessionsUrl, {
             headers,
             signal: controller.signal,
@@ -278,6 +287,7 @@ async function probeApiKeyType(baseUrl, apiKey) {
                     "X-API-Key": apiKey,
                     "X-OpenViking-Account": "__probe__",
                     "X-OpenViking-User": "__probe__",
+                    ...configuredRequestHeaders,
                 };
                 const probe2 = await fetch(sessionsUrl, {
                     headers: probeHeaders,
@@ -307,13 +317,16 @@ async function probeApiKeyType(baseUrl, apiKey) {
         clearTimeout(timeoutId);
     }
 }
-async function checkServiceHealth(baseUrl, apiKey) {
+async function checkServiceHealth(baseUrl, apiKey, configuredHeaders) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10_000);
     try {
+        const configuredRequestHeaders = resolveOpenVikingRequestHeaders({ headers: configuredHeaders });
         const headers = {};
-        if (apiKey)
+        if (apiKey) {
             headers["X-API-Key"] = apiKey;
+        }
+        Object.assign(headers, configuredRequestHeaders);
         const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/health`, {
             headers,
             signal: controller.signal,
@@ -602,8 +615,9 @@ function printCompatibilityWarning(zh, health) {
 async function runRemoteCheck(zh, existing) {
     const baseUrl = String(existing.baseUrl ?? DEFAULT_REMOTE_URL);
     const apiKey = existing.apiKey ? String(existing.apiKey) : undefined;
+    const headers = nonEmptyOpenVikingRequestHeaders(existing.headers);
     console.log(tr(zh, `Testing connectivity to ${baseUrl}...`, `正在测试连接 ${baseUrl}...`));
-    const health = await checkServiceHealth(baseUrl, apiKey);
+    const health = await checkServiceHealth(baseUrl, apiKey, headers);
     if (health.ok) {
         const ver = health.version ? ` (version: ${health.version})` : "";
         console.log(`  ✓ ${tr(zh, `Connected successfully${ver}`, `连接成功${ver}`)}`);
@@ -771,8 +785,9 @@ async function getStatus(configPath) {
     }
     const baseUrl = String(existing.baseUrl ?? DEFAULT_REMOTE_URL);
     const apiKey = existing.apiKey ? String(existing.apiKey) : undefined;
-    const health = await checkServiceHealth(baseUrl, apiKey);
-    const keyProbe = health.ok ? await probeApiKeyType(baseUrl, apiKey) : undefined;
+    const headers = nonEmptyOpenVikingRequestHeaders(existing.headers);
+    const health = await checkServiceHealth(baseUrl, apiKey, headers);
+    const keyProbe = health.ok ? await probeApiKeyType(baseUrl, apiKey, headers) : undefined;
     const peerPrefix = resolveExistingPeerPrefix(existing);
     return {
         configured: true,
@@ -858,13 +873,14 @@ async function setupRemote(zh, configPath, existing, q) {
     const defaultApiKey = existing?.apiKey ? String(existing.apiKey) : "";
     const defaultPeerRole = resolveExistingPeerRole(existing);
     const defaultPeerPrefix = resolveExistingPeerPrefix(existing);
+    const headers = nonEmptyOpenVikingRequestHeaders(existing?.headers);
     const baseUrl = await q(tr(zh, "OpenViking server URL", "OpenViking 服务器地址"), defaultUrl);
     const apiKey = await q(tr(zh, "API Key (optional)", "API Key（可选）"), defaultApiKey);
     let accountId = existing?.accountId ? String(existing.accountId) : "";
     let userId = existing?.userId ? String(existing.userId) : "";
     if (apiKey) {
         console.log(tr(zh, "  Detecting API key type...", "  正在检测 API Key 类型..."));
-        const probe = await probeApiKeyType(baseUrl, apiKey);
+        const probe = await probeApiKeyType(baseUrl, apiKey, headers);
         if (probe.keyType === "root_key") {
             console.log(tr(zh, "  ⚠ Root API key detected. accountId and userId are required.", "  ⚠ 检测到 Root API Key，需要提供 accountId 和 userId。"));
             accountId = await q(tr(zh, "Account ID (required for root key)", "Account ID（root key 必填）"), accountId);
@@ -880,7 +896,7 @@ async function setupRemote(zh, configPath, existing, q) {
         : "";
     console.log("");
     console.log(tr(zh, `Testing connectivity to ${baseUrl}...`, `正在测试连接 ${baseUrl}...`));
-    const health = await checkServiceHealth(baseUrl, apiKey || undefined);
+    const health = await checkServiceHealth(baseUrl, apiKey || undefined, headers);
     if (health.ok) {
         const ver = health.version ? ` (version: ${health.version})` : "";
         console.log(`  ✓ ${tr(zh, `Connected successfully${ver}`, `连接成功${ver}`)}`);

package/dist/config.js

@@ -11,7 +11,7 @@ const DEFAULT_RECALL_SCORE_THRESHOLD = 0.15;
 const DEFAULT_RECALL_MAX_CONTENT_CHARS = 5000;
 const DEFAULT_RECALL_PREFER_ABSTRACT = false;
 const DEFAULT_RECALL_MAX_INJECTED_CHARS = 4000;
-const DEFAULT_COMMIT_TOKEN_THRESHOLD = 20000;
+const DEFAULT_COMMIT_TOKEN_THRESHOLD_RATIO = 0.5;
 const DEFAULT_COMMIT_KEEP_RECENT_COUNT = 10;
 const DEFAULT_BYPASS_SESSION_PATTERNS = [];
 const DEFAULT_EMIT_STANDARD_DIAGNOSTICS = false;
@@ -168,6 +168,23 @@ function toRecord(value) {
         ? value
         : {};
 }
+function toStringRecord(value, label) {
+    if (value === undefined || value === null) {
+        return {};
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    const record = value;
+    const out = {};
+    for (const [key, val] of Object.entries(record)) {
+        if (typeof val !== "string") {
+            throw new Error(`${label}.${key} must be a string`);
+        }
+        out[key] = val;
+    }
+    return out;
+}
 function expandToolSelectors(value, fallback, label) {
     const entries = toStringArray(value, fallback);
     const seen = new Set();
@@ -250,6 +267,7 @@ export const memoryOpenVikingConfigSchema = {
             "peer_prefix",
             "serverAuthMode",
             "apiKey",
+            "headers",
             "accountId",
             "userId",
             "targetUri",
@@ -267,6 +285,7 @@ export const memoryOpenVikingConfigSchema = {
             "recallPreferAbstract",
             "recallTokenBudget",
             "commitTokenThreshold",
+            "commitTokenThresholdRatio",
             "commitKeepRecentCount",
             "bypassSessionPatterns",
             "ingestReplyAssist",
@@ -324,6 +343,7 @@ export const memoryOpenVikingConfigSchema = {
             peer_role: peerRole,
             peer_prefix: peerPrefix,
             apiKey: rawApiKey ? resolveEnvVars(rawApiKey) : "",
+            headers: toStringRecord(cfg.headers, "openviking config headers"),
             accountId,
             userId,
             targetUri: typeof cfg.targetUri === "string" ? cfg.targetUri : DEFAULT_TARGET_URI,
@@ -342,7 +362,7 @@ export const memoryOpenVikingConfigSchema = {
                 : DEFAULT_RECALL_PREFER_ABSTRACT,
             recallMaxInjectedChars,
             recallTokenBudget: recallMaxInjectedChars,
-            commitTokenThreshold: Math.max(0, Math.min(100_000, Math.floor(toNumber(cfg.commitTokenThreshold, DEFAULT_COMMIT_TOKEN_THRESHOLD)))),
+            commitTokenThresholdRatio: Math.max(0, Math.min(1, toNumber(cfg.commitTokenThresholdRatio, DEFAULT_COMMIT_TOKEN_THRESHOLD_RATIO))),
             commitKeepRecentCount: Math.max(0, Math.min(1_000, Math.floor(toNumber(cfg.commitKeepRecentCount, DEFAULT_COMMIT_KEEP_RECENT_COUNT)))),
             bypassSessionPatterns: toStringArray(cfg.bypassSessionPatterns, toStringArray(cfg.ingestReplyAssistIgnoreSessionPatterns, DEFAULT_BYPASS_SESSION_PATTERNS)),
             emitStandardDiagnostics: typeof cfg.emitStandardDiagnostics === "boolean"
@@ -405,6 +425,11 @@ export const memoryOpenVikingConfigSchema = {
             placeholder: "${OPENVIKING_API_KEY}",
             help: "Optional API key for OpenViking server",
         },
+        headers: {
+            label: "Headers",
+            advanced: true,
+            help: "Optional HTTP headers merged into every OpenViking request.",
+        },
         accountId: {
             label: "Account ID",
             placeholder: "(derived from API key)",
@@ -503,11 +528,11 @@ export const memoryOpenVikingConfigSchema = {
             help: "Completely bypass OpenViking for matching session keys. Use * within one segment and ** across segments.",
             advanced: true,
         },
-        commitTokenThreshold: {
-            label: "Commit Token Threshold",
-            placeholder: String(DEFAULT_COMMIT_TOKEN_THRESHOLD),
+        commitTokenThresholdRatio: {
+            label: "Commit Token Threshold Ratio",
+            placeholder: String(DEFAULT_COMMIT_TOKEN_THRESHOLD_RATIO),
             advanced: true,
-            help: "Minimum estimated pending tokens before auto-commit triggers. Set to 0 to commit every turn.",
+            help: "Auto-commit triggers once estimated pending tokens reach this fraction (0-1) of the model context window (e.g. 0.5 = 50%). Set to 0 to commit every turn.",
         },
         commitKeepRecentCount: {
             label: "Commit Keep Recent Count",

package/dist/context-engine.js

@@ -135,7 +135,6 @@ export function createMemoryOpenVikingContextEngine(params) {
             getClient,
             logger,
             rememberSessionAgentId,
-            resolveAgentId,
             isBypassedSession,
         });
     }
@@ -204,12 +203,14 @@ export function createMemoryOpenVikingContextEngine(params) {
             });
         },
         async afterTurn(afterTurnParams) {
+            const tokenBudget = validTokenBudget(afterTurnParams.tokenBudget) ?? 128_000;
             await afterTurnOpenVikingSession({
                 sessionId: afterTurnParams.sessionId,
                 sessionKey: resolveSessionKey(afterTurnParams),
                 messages: afterTurnParams.messages,
                 prePromptMessageCount: afterTurnParams.prePromptMessageCount,
                 isHeartbeat: afterTurnParams.isHeartbeat,
+                tokenBudget,
                 runtimeContext: afterTurnParams.runtimeContext,
                 cfg,
                 getClient,

package/dist/index.js

@@ -25,8 +25,8 @@ import { registerOpenVikingRecallTraceTools } from "./plugin/openviking-recall-t
 import { createOpenVikingRuntimeState } from "./plugin/openviking-runtime-state.js";
 import { createOpenVikingSessionRoutingRuntime } from "./plugin/openviking-session-routing-runtime.js";
 import { registerOpenVikingToolResultTools } from "./plugin/openviking-tool-result-tools.js";
-import { boundTraceQuery, createMemoryStoreTempSessionId, createTraceId, extractToolSenderId, inferRecallResourceType, makeBypassedToolResult, previewText, } from "./plugin/openviking-runtime-utils.js";
-import { formatMessageFaithful, toRoleId } from "./services/context-message-adapter.js";
+import { boundTraceQuery, createMemoryStoreTempSessionId, createTraceId, inferRecallResourceType, makeBypassedToolResult, previewText, } from "./plugin/openviking-runtime-utils.js";
+import { formatMessageFaithful } from "./services/context-message-adapter.js";
 import { clampScore, postProcessMemories, pickMemoriesForInjection, } from "./memory-ranking.js";
 import { createMemoryOpenVikingContextEngine, } from "./context-engine.js";
 import { openClawSessionRefToOvStorageId, openClawSessionToOvStorageId, } from "./routing/identity-routing.js";
@@ -80,6 +80,7 @@ const contextEnginePlugin = {
             logger: api.logger,
         });
         const { rememberSessionAgentId, resolveAgentId, resolvePluginSessionRouting, toQueryConfigContext, } = createOpenVikingSessionRoutingRuntime({
+            peerRole: cfg.peer_role,
             peerPrefix: cfg.peer_prefix,
             logFindRequests: cfg.logFindRequests,
             logger: api.logger,
@@ -182,8 +183,7 @@ const contextEnginePlugin = {
             getClient,
             normalizeSessionId: openClawSessionRefToOvStorageId,
             createTempSessionId: createMemoryStoreTempSessionId,
-            extractSenderId: extractToolSenderId,
-            toRoleId,
+            peerRole: cfg.peer_role,
             resolvePluginSessionRouting,
             isBypassedSession,
             makeBypassedToolResult,

package/dist/plugin/openviking-archive-tools.js

@@ -55,7 +55,6 @@ export function registerOpenVikingArchiveTools(deps) {
                 const result = await client.grepSessionArchives(ovSessionId, escapedQuery, {
                     archiveId,
                     caseInsensitive: true,
-                    agentId,
                 });
                 const traceResults = (result.matches ?? []).slice(0, deps.traceRecallMaxResultsPerSearch).map((match) => ({
                     uri: match.uri,
@@ -175,7 +174,7 @@ export function registerOpenVikingArchiveTools(deps) {
             }
             try {
                 const client = await deps.getClient();
-                const detail = await client.getSessionArchive(session.ovSessionId, archiveId, session.agentId);
+                const detail = await client.getSessionArchive(session.ovSessionId, archiveId);
                 const header = [
                     `## ${detail.archive_id}`,
                     detail.abstract ? `**Summary**: ${detail.abstract}` : "",

package/dist/plugin/openviking-client-runtime.js

@@ -1,4 +1,5 @@
 import { OpenVikingClient } from "../client.js";
+import { resolveOpenVikingRequestHeaders } from "../request-headers.js";
 export function createOpenVikingClientRuntime(options) {
     const { cfg, logger } = options;
     if (cfg.logFindRequests) {
@@ -19,7 +20,12 @@ export function createOpenVikingClientRuntime(options) {
             logger.info(msg);
         }
         : undefined;
-    const clientPromise = Promise.resolve(new OpenVikingClient(cfg.baseUrl, cfg.apiKey, cfg.peer_prefix, cfg.timeoutMs, cfg.accountId, cfg.userId, routingDebugLog, { transport: options.transport }));
+    const clientPromise = Promise.resolve(new OpenVikingClient(cfg.baseUrl, cfg.apiKey, cfg.peer_prefix, cfg.timeoutMs, cfg.accountId, cfg.userId, routingDebugLog, {
+        transport: options.transport,
+        headers: resolveOpenVikingRequestHeaders({
+            headers: cfg.headers,
+        }),
+    }));
     const getClient = () => clientPromise;
     return {
         getClient,

package/dist/plugin/openviking-command-definitions.js

@@ -124,7 +124,7 @@ export function createOpenVikingCommandDefinitions(deps) {
                     }
                     const session = deps.resolvePluginSessionRouting(ctx);
                     const input = deps.parseAddResourceCommandArgs(ctx.args ?? "");
-                    return toCommandResult(await deps.addResourceOpenViking(input, session.agentId));
+                    return toCommandResult(await deps.addResourceOpenViking(input, session.actorPeerId));
                 }
                 catch (err) {
                     return { text: `OpenViking add resource failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -142,7 +142,7 @@ export function createOpenVikingCommandDefinitions(deps) {
                     }
                     const session = deps.resolvePluginSessionRouting(ctx);
                     const input = deps.parseAddSkillCommandArgs(ctx.args ?? "");
-                    return toCommandResult(await deps.addSkillOpenViking(input, session.agentId));
+                    return toCommandResult(await deps.addSkillOpenViking(input, session.actorPeerId));
                 }
                 catch (err) {
                     return { text: `OpenViking add skill failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -160,7 +160,7 @@ export function createOpenVikingCommandDefinitions(deps) {
                     }
                     const session = deps.resolvePluginSessionRouting(ctx);
                     const input = deps.parseOVSearchCommandArgs(ctx.args ?? "");
-                    return toCommandResult(await deps.searchOpenViking(input, session.agentId, session));
+                    return toCommandResult(await deps.searchOpenViking(input, session.actorPeerId, session));
                 }
                 catch (err) {
                     return { text: `OpenViking search failed: ${err instanceof Error ? err.message : String(err)}` };

package/dist/plugin/openviking-import-tools.js

@@ -40,7 +40,7 @@ export function registerOpenVikingImportTools(deps) {
                     instruction: typeof params.instruction === "string" ? params.instruction : undefined,
                     wait: typeof params.wait === "boolean" ? params.wait : undefined,
                     timeout: typeof params.timeout === "number" ? params.timeout : undefined,
-                }, session.agentId);
+                }, session.actorPeerId);
                 return {
                     content: [{ type: "text", text: formatResourceImportText(result) }],
                     details: {
@@ -73,7 +73,7 @@ export function registerOpenVikingImportTools(deps) {
                 data: params.data,
                 wait: typeof params.wait === "boolean" ? params.wait : undefined,
                 timeout: typeof params.timeout === "number" ? params.timeout : undefined,
-            }, session.agentId);
+            }, session.actorPeerId);
             return {
                 content: [{ type: "text", text: formatSkillImportText(result) }],
                 details: {

package/dist/plugin/openviking-memory-recall-tools.js

@@ -47,7 +47,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
             const requestLimit = queryConfig.candidateLimit;
             const recallClient = await deps.getClient();
             if (deps.cfg.logFindRequests) {
-                deps.logger.info?.(`openviking: memory_recall X-OpenViking-Actor-Peer="${session.agentId}" ` +
+                deps.logger.info?.(`openviking: memory_recall X-OpenViking-Actor-Peer="${session.actorPeerId ?? "none"}" ` +
                     `(plugin defaultAgentId="${recallClient.getDefaultAgentId()}" is unused when session context is present)`);
             }
             let result;
@@ -57,7 +57,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
                     targetUri,
                     limit: requestLimit,
                     scoreThreshold: 0,
-                    actorPeerId: session.agentId,
+                    actorPeerId: session.actorPeerId,
                 });
                 const traceResults = [
                     ...(result.memories ?? []).map((item) => toTraceResult(item, "memory", deps)),
@@ -84,7 +84,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
                     limit: requestLimit,
                     scoreThreshold: 0,
                     contextType: search.contextType,
-                    actorPeerId: session.agentId,
+                    actorPeerId: session.actorPeerId,
                 })));
                 const allMemories = [];
                 for (let index = 0; index < settled.length; index += 1) {
@@ -188,7 +188,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
                     details: { count: 0, total: result.total ?? 0, scoreThreshold },
                 };
             }
-            const { lines: memoryLines } = await deps.buildMemoryLinesWithBudget(memories, (uri) => recallClient.read(uri, session.agentId), {
+            const { lines: memoryLines } = await deps.buildMemoryLinesWithBudget(memories, (uri) => recallClient.read(uri, session.actorPeerId), {
                 recallPreferAbstract: false,
                 recallMaxInjectedChars: queryConfig.maxInjectedChars,
             });

package/dist/plugin/openviking-memory-tools.js

@@ -1,5 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import { clampScore, postProcessMemories } from "../memory-ranking.js";
+import { resolveOpenVikingMessagePeerId, } from "../routing/identity-routing.js";
 import { isMemoryUri } from "../routing/memory-uri.js";
 function totalCommitMemories(r) {
     const m = r.memories_extracted;
@@ -11,7 +12,7 @@ export function registerOpenVikingMemoryTools(deps) {
     deps.registerTool((ctx) => ({
         name: "memory_store",
         label: "Memory Store (OpenViking)",
-        description: "Store text in OpenViking memory pipeline by writing to a session and running memory extraction.",
+        description: "Store text in OpenViking memory pipeline by writing to a session and running memory extraction. Use when the user explicitly asks to remember, save, or store an important long-term fact, preference, project, or decision; automatic capture is threshold/commit dependent.",
         parameters: Type.Object({
             text: Type.String({ description: "Information to store as memory source text" }),
             role: Type.Optional(Type.String({ description: "Session role, default user" })),
@@ -41,11 +42,15 @@ export function registerOpenVikingMemoryTools(deps) {
                     sessionId = deps.createTempSessionId();
                     usedTempSession = true;
                 }
-                const roleId = role === "user" ? deps.toRoleId(deps.extractSenderId(ctx)) : undefined;
-                await client.addSessionMessage(sessionId, role, [{ type: "text", text }], session.agentId, undefined, roleId);
+                const peerId = resolveOpenVikingMessagePeerId({
+                    peerRole: deps.peerRole,
+                    role,
+                    personPeerId: session.actorPeerId,
+                    assistantPeerId: session.actorPeerId,
+                });
+                await client.addSessionMessage(sessionId, role, [{ type: "text", text }], undefined, undefined, peerId);
                 const commitResult = await client.commitSession(sessionId, {
                     wait: true,
-                    agentId: session.agentId,
                     keepRecentCount: 0,
                 });
                 const memoriesCount = totalCommitMemories(commitResult);
@@ -130,7 +135,7 @@ export function registerOpenVikingMemoryTools(deps) {
                         details: { action: "rejected", uri },
                     };
                 }
-                await client.deleteUri(uri, session.agentId);
+                await client.deleteUri(uri, session.actorPeerId);
                 return {
                     content: [{ type: "text", text: `Forgotten: ${uri}` }],
                     details: { action: "deleted", uri },
@@ -157,7 +162,7 @@ export function registerOpenVikingMemoryTools(deps) {
                 targetUri,
                 limit: requestLimit,
                 scoreThreshold: 0,
-            }, session.agentId);
+            }, session.actorPeerId);
             const candidates = postProcessMemories(result.memories ?? [], {
                 limit: requestLimit,
                 scoreThreshold,
@@ -176,7 +181,7 @@ export function registerOpenVikingMemoryTools(deps) {
             }
             const top = candidates[0];
             if (candidates.length === 1 && clampScore(top.score) >= 0.85) {
-                await client.deleteUri(top.uri, session.agentId);
+                await client.deleteUri(top.uri, session.actorPeerId);
                 return {
                     content: [{ type: "text", text: `Forgotten: ${top.uri}` }],
                     details: { action: "deleted", uri: top.uri, score: top.score ?? 0 },

package/dist/plugin/openviking-query-runtime.js

@@ -337,7 +337,7 @@ export function createOpenVikingQueryRuntime(deps) {
             sessionId: traceCtx?.sessionId,
             sessionKey: traceCtx?.sessionKey,
             ovSessionId: traceCtx?.ovSessionId,
-            agentId,
+            agentId: traceCtx?.agentId,
             source: "ov_search",
             operationType: "semantic_find",
             resourceTypes: [...new Set(searches.map((search) => search.resourceType).filter((resourceType) => resourceType !== "archive"))],

package/dist/plugin/openviking-query-tools.js

@@ -21,7 +21,7 @@ export function registerOpenVikingQueryTools(deps) {
                 query: String(params.query ?? ""),
                 uri: typeof params.uri === "string" ? params.uri : undefined,
                 limit: typeof params.limit === "number" ? params.limit : undefined,
-            }, session.agentId, session);
+            }, session.actorPeerId, session);
         },
     }), { name: "ov_search" });
     deps.registerTool((ctx) => ({
@@ -41,7 +41,7 @@ export function registerOpenVikingQueryTools(deps) {
             const session = deps.resolvePluginSessionRouting(ctx);
             return deps.readOpenVikingContent({
                 uri: String(params.uri ?? ""),
-            }, session.agentId);
+            }, session.actorPeerId);
         },
     }), { name: "ov_read" });
     deps.registerTool((ctx) => ({
@@ -62,7 +62,7 @@ export function registerOpenVikingQueryTools(deps) {
             const uris = Array.isArray(params.uris)
                 ? params.uris.map((uri) => String(uri))
                 : [];
-            return deps.multiReadOpenVikingContent({ uris }, session.agentId);
+            return deps.multiReadOpenVikingContent({ uris }, session.actorPeerId);
         },
     }), { name: "ov_multi_read" });
     deps.registerTool((ctx) => ({
@@ -85,7 +85,7 @@ export function registerOpenVikingQueryTools(deps) {
                 recursive: typeof params.recursive === "boolean" ? params.recursive : undefined,
                 simple: typeof params.simple === "boolean" ? params.simple : undefined,
                 limit: typeof params.limit === "number" ? params.limit : undefined,
-            }, session.agentId);
+            }, session.actorPeerId);
         },
     }), { name: "ov_list" });
 }

package/dist/plugin/openviking-recall-trace-runtime.js

@@ -157,11 +157,11 @@ export function createOpenVikingRecallTraceRuntime(deps) {
             for (const fallbackQuery of fallbackIdentities) {
                 const fallback = await deps.traceRecorder.queryWithFallback(fallbackQuery);
                 if (fallback.entries.length > 0) {
-                    return enrichTraceEntriesWithContent(fallback, shouldIncludeTraceContent(input), session.agentId);
+                    return enrichTraceEntriesWithContent(fallback, shouldIncludeTraceContent(input), session.actorPeerId);
                 }
             }
         }
-        return enrichTraceEntriesWithContent(base, shouldIncludeTraceContent(input), session.agentId);
+        return enrichTraceEntriesWithContent(base, shouldIncludeTraceContent(input), session.actorPeerId);
     };
     const handleUriDetail = async (request) => {
         const query = toQueryObject(request);
@@ -206,7 +206,7 @@ export function createOpenVikingRecallTraceRuntime(deps) {
         }
         try {
             const client = await deps.getClient();
-            const content = await client.read(uri, toString(query.agentId) ?? session.agentId);
+            const content = await client.read(uri, session.actorPeerId);
             const text = typeof content === "string" ? content : JSON.stringify(content, null, 2);
             const chars = Array.from(text);
             const slice = chars.slice(offset, offset + contentLimit).join("");

package/dist/plugin/openviking-session-routing-runtime.js

@@ -1,5 +1,6 @@
-import { createSessionAgentResolver, openClawSessionToOvStorageId, } from "../routing/identity-routing.js";
+import { createSessionAgentResolver, openClawSessionToOvStorageId, resolveOpenVikingActorPeerId, sanitizeOpenVikingPeerId, } from "../routing/identity-routing.js";
 export function createOpenVikingSessionRoutingRuntime(options) {
+    const peerRole = options.peerRole ?? "assistant";
     const sessionAgentResolver = createSessionAgentResolver(options.peerPrefix);
     const rememberSessionAgentId = (ctx) => {
         sessionAgentResolver.remember(ctx);
@@ -39,11 +40,17 @@ export function createOpenVikingSessionRoutingRuntime(options) {
             ovSessionId: ovSessionId || undefined,
         };
         rememberSessionAgentId(session);
+        const agentId = resolveAgentId(session.sessionId, session.sessionKey, session.ovSessionId);
         return {
             sessionId: session.sessionId,
             sessionKey: session.sessionKey,
             ovSessionId: session.ovSessionId,
-            agentId: resolveAgentId(session.sessionId, session.sessionKey, session.ovSessionId),
+            agentId,
+            actorPeerId: resolveOpenVikingActorPeerId({
+                peerRole,
+                personPeerId: sanitizeOpenVikingPeerId(ctx?.requesterSenderId ?? ctx?.senderId),
+                assistantPeerId: agentId,
+            }),
         };
     };
     const toQueryConfigContext = (session) => ({

package/dist/plugin/openviking-tool-result-tools.js

@@ -83,7 +83,7 @@ export function registerOpenVikingToolResultTools({ registerTool, getClient, res
             }
             try {
                 const client = await getClient();
-                const result = await client.readToolResult(session.ovSessionId, parsed.toolResultId, { offset, limit, includeMetadata: true }, session.agentId);
+                const result = await client.readToolResult(session.ovSessionId, parsed.toolResultId, { offset, limit, includeMetadata: true });
                 const returnedChars = result.content.length;
                 const nextOffset = result.offset + returnedChars;
                 const text = result.content || "(empty tool result chunk)";
@@ -167,7 +167,7 @@ export function registerOpenVikingToolResultTools({ registerTool, getClient, res
             const contextChars = Math.max(0, getOptionalInteger(params.context_chars ?? params.contextChars, 300));
             try {
                 const client = await getClient();
-                const result = await client.searchToolResult(session.ovSessionId, parsed.toolResultId, query, { limit, contextChars }, session.agentId);
+                const result = await client.searchToolResult(session.ovSessionId, parsed.toolResultId, query, { limit, contextChars });
                 const matches = result.matches ?? [];
                 const text = matches.length
                     ? [
@@ -227,7 +227,7 @@ export function registerOpenVikingToolResultTools({ registerTool, getClient, res
             const limit = getPositiveInteger(params.limit, 50);
             try {
                 const client = await getClient();
-                const result = await client.listToolResults(session.ovSessionId, { toolName, limit }, session.agentId);
+                const result = await client.listToolResults(session.ovSessionId, { toolName, limit });
                 const items = result.tool_results ?? [];
                 const text = items.length
                     ? [

package/dist/query-config.js

@@ -171,7 +171,13 @@ export class RuntimeQueryConfigStore {
         const { params, warnings } = normalizeRuntimeQueryParams(patch);
         const key = this.keyForScope(scope, ctx);
         const bucket = scope === "claw" ? this.data.claws : this.data.sessions;
-        bucket[key] = { params, updatedAt: Date.now(), updatedBy: "command", peerId: ctx.peerId };
+        const previous = bucket[key];
+        bucket[key] = {
+            params: { ...(previous?.params ?? {}), ...params },
+            updatedAt: Date.now(),
+            updatedBy: "command",
+            peerId: ctx.peerId,
+        };
         this.data.updatedAt = Date.now();
         await this.persist();
         return { warnings };

package/dist/request-headers.js

@@ -0,0 +1,19 @@
+export function resolveOpenVikingRequestHeaders(options = {}) {
+    return cleanOpenVikingRequestHeaders(options.headers);
+}
+export function cleanOpenVikingRequestHeaders(headers) {
+    if (headers === undefined || headers === null) {
+        return {};
+    }
+    if (typeof headers !== "object" || Array.isArray(headers)) {
+        throw new Error("openviking request headers must be an object");
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value !== "string") {
+            throw new Error(`openviking request header ${key} must be a string`);
+        }
+        out[key] = value;
+    }
+    return out;
+}