@openviking/openclaw-plugin 2026.6.2 → 2026.6.17-dev.1

package/dist/client.js

@@ -5,6 +5,11 @@ import { mkdtemp, readdir, readFile, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
 import { Zip, ZipDeflate } from "fflate";
+import { defaultHttpTransport } from "./adapters/http-transport.js";
+import { defaultResourcePackager, } from "./adapters/resource-packager.js";
+function userSessionUri(sessionId) {
+    return `viking://user/sessions/${encodeURIComponent(sessionId)}`;
+}
 const DEFAULT_WAIT_REQUEST_TIMEOUT_MS = 120_000;
 export const DEFAULT_PHASE2_POLL_TIMEOUT_MS = 300_000;
 const WAIT_REQUEST_TIMEOUT_BUFFER_MS = 5_000;
@@ -12,18 +17,8 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 const MEMORY_URI_PATTERNS = [
-    /^viking:\/\/user\/(?:[^/]+(?:\/agent\/[^/]+)?\/)?memories(?:\/|$)/,
-    /^viking:\/\/agent\/(?:[^/]+(?:\/user\/[^/]+)?\/)?memories(?:\/|$)/,
+    /^viking:\/\/user\/(?:[^/]+\/)?memories(?:\/|$)/,
 ];
-const USER_STRUCTURE_DIRS = new Set(["memories", "profile.md", ".abstract.md", ".overview.md"]);
-const AGENT_STRUCTURE_DIRS = new Set([
-    "memories",
-    "skills",
-    "instructions",
-    "workspaces",
-    ".abstract.md",
-    ".overview.md",
-]);
 const REMOTE_RESOURCE_PREFIXES = ["http://", "https://", "git@", "ssh://", "git://"];
 export function isMemoryUri(uri) {
     return MEMORY_URI_PATTERNS.some((pattern) => pattern.test(uri));
@@ -55,14 +50,15 @@ export class OpenVikingClient {
     accountId;
     userId;
     routingDebugLog;
-    isolateUserScopeByAgent;
-    isolateAgentScopeByUser;
-    identityCache = new Map();
+    transport;
+    now;
+    sleep;
+    resourcePackager;
     constructor(baseUrl, apiKey, defaultAgentId, timeoutMs, 
     /** When set, sent so ROOT keys or trusted deployments can select tenant identity. */
     accountId = "", userId = "", 
     /** When set, logs routing for find + session writes (tenant headers + paths; never apiKey). */
-    routingDebugLog, isolateUserScopeByAgent = false, isolateAgentScopeByUser = true) {
+    routingDebugLog, optionsOrLegacyUserScope = {}, _legacyAgentScope, legacyOptions) {
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
         this.defaultAgentId = defaultAgentId;
@@ -70,23 +66,17 @@ export class OpenVikingClient {
         this.accountId = accountId;
         this.userId = userId;
         this.routingDebugLog = routingDebugLog;
-        this.isolateUserScopeByAgent = isolateUserScopeByAgent;
-        this.isolateAgentScopeByUser = isolateAgentScopeByUser;
+        const options = typeof optionsOrLegacyUserScope === "object" && optionsOrLegacyUserScope !== null
+            ? optionsOrLegacyUserScope
+            : (legacyOptions ?? {});
+        this.transport = options.transport ?? defaultHttpTransport;
+        this.now = options.now ?? Date.now;
+        this.sleep = options.sleep ?? sleep;
+        this.resourcePackager = options.resourcePackager ?? defaultResourcePackager;
     }
     getDefaultAgentId() {
         return this.defaultAgentId;
     }
-    resolveEffectiveAgentId(agentId) {
-        const explicit = agentId?.trim();
-        if (explicit) {
-            return explicit;
-        }
-        const prefix = this.defaultAgentId.trim();
-        return prefix ? `${prefix}_main` : "main";
-    }
-    async getResolvedIdentity(agentId) {
-        return this.getRuntimeIdentity(agentId);
-    }
     resolveTenantHeaders() {
         const apiKey = this.apiKey.trim();
         const accountId = this.accountId.trim();
@@ -97,27 +87,32 @@ export class OpenVikingClient {
             ...(userId ? { userId } : {}),
         };
     }
-    async emitRoutingDebug(label, detail, agentId) {
+    resolveActorPeerHeader(actorPeerId) {
+        const value = actorPeerId?.trim();
+        return value || undefined;
+    }
+    resolveDefaultActorPeerHeader() {
+        const peerPrefix = this.defaultAgentId.trim();
+        return peerPrefix ? `${peerPrefix}_main` : "main";
+    }
+    async emitRoutingDebug(label, detail, actorPeerId) {
         if (!this.routingDebugLog) {
             return;
         }
-        const effectiveAgentId = this.resolveEffectiveAgentId(agentId);
-        const identity = await this.getRuntimeIdentity(agentId);
         const tenantHeaders = this.resolveTenantHeaders();
+        const actorPeerHeader = this.resolveActorPeerHeader(actorPeerId);
         this.routingDebugLog(`openviking: ${label} ` +
             JSON.stringify({
                 ...detail,
-                X_OpenViking_Agent: effectiveAgentId,
                 X_OpenViking_Account: tenantHeaders.accountId ?? null,
                 X_OpenViking_User: tenantHeaders.userId ?? null,
-                resolved_user_id: identity.userId,
+                X_OpenViking_Actor_Peer: actorPeerHeader ?? null,
                 session_vfs_hint: detail.sessionId
-                    ? `viking://session/${String(detail.sessionId)}`
+                    ? userSessionUri(String(detail.sessionId))
                     : undefined,
             }));
     }
-    async request(path, init = {}, agentId, requestTimeoutMs) {
-        const effectiveAgentId = this.resolveEffectiveAgentId(agentId);
+    async request(path, init = {}, requestTimeoutMs, actorPeerId) {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), requestTimeoutMs ?? this.timeoutMs);
         try {
@@ -132,13 +127,14 @@ export class OpenVikingClient {
             if (tenantHeaders.userId) {
                 headers.set("X-OpenViking-User", tenantHeaders.userId);
             }
-            if (effectiveAgentId) {
-                headers.set("X-OpenViking-Agent", effectiveAgentId);
+            const actorPeerHeader = this.resolveActorPeerHeader(actorPeerId);
+            if (actorPeerHeader) {
+                headers.set("X-OpenViking-Actor-Peer", actorPeerHeader);
             }
             if (init.body && !(init.body instanceof FormData) && !headers.has("Content-Type")) {
                 headers.set("Content-Type", "application/json");
             }
-            const response = await fetch(`${this.baseUrl}${path}`, {
+            const response = await this.transport(`${this.baseUrl}${path}`, {
                 ...init,
                 headers,
                 signal: controller.signal,
@@ -155,97 +151,78 @@ export class OpenVikingClient {
             clearTimeout(timer);
         }
     }
-    async healthCheck(agentId, requestTimeoutMs) {
-        await this.request("/health", {}, agentId, requestTimeoutMs);
+    async healthCheck(requestTimeoutMs, actorPeerId) {
+        await this.request("/health", {}, requestTimeoutMs, actorPeerId ?? this.resolveDefaultActorPeerHeader());
     }
-    async getRuntimeIdentity(agentId) {
-        const effectiveAgentId = this.resolveEffectiveAgentId(agentId);
-        const cached = this.identityCache.get(effectiveAgentId);
-        if (cached) {
-            return cached;
-        }
-        const fallback = { userId: "default", agentId: effectiveAgentId };
-        try {
-            const status = await this.request("/api/v1/system/status", {}, agentId);
-            const userId = typeof status.user === "string" && status.user.trim() ? status.user.trim() : "default";
-            const identity = { userId, agentId: effectiveAgentId };
-            this.identityCache.set(effectiveAgentId, identity);
-            return identity;
-        }
-        catch {
-            this.identityCache.set(effectiveAgentId, fallback);
-            return fallback;
+    async createSession(sessionId, options) {
+        const body = { session_id: sessionId };
+        if (options?.memoryPolicy) {
+            body.memory_policy = options.memoryPolicy;
         }
+        return this.request("/api/v1/sessions", { method: "POST", body: JSON.stringify(body) });
     }
-    async buildCanonicalRoot(scope, agentId) {
-        const identity = await this.getRuntimeIdentity(agentId);
-        if (scope === "user") {
-            const root = this.isolateUserScopeByAgent
-                ? `viking://user/${identity.userId}/agent/${identity.agentId}`
-                : `viking://user/${identity.userId}`;
-            return root;
-        }
-        const root = this.isolateAgentScopeByUser
-            ? `viking://agent/${identity.agentId}/user/${identity.userId}`
-            : `viking://agent/${identity.agentId}`;
-        return root;
-    }
-    async normalizeTargetUri(targetUri, agentId) {
-        const trimmed = targetUri.trim().replace(/\/+$/, "");
-        const match = trimmed.match(/^viking:\/\/(user|agent)(?:\/(.*))?$/);
-        if (!match) {
-            return trimmed;
-        }
-        const scope = match[1];
-        const rawRest = (match[2] ?? "").trim();
-        if (!rawRest) {
-            return trimmed;
-        }
-        const parts = rawRest.split("/").filter(Boolean);
-        if (parts.length === 0) {
-            return trimmed;
+    async ensureSession(sessionId, options) {
+        try {
+            await this.createSession(sessionId, options);
+            return true;
         }
-        const reservedDirs = scope === "user" ? USER_STRUCTURE_DIRS : AGENT_STRUCTURE_DIRS;
-        if (!reservedDirs.has(parts[0])) {
-            return trimmed;
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes("[ALREADY_EXISTS]")) {
+                return false;
+            }
+            throw err;
         }
-        const root = await this.buildCanonicalRoot(scope, agentId);
-        return `${root}/${parts.join("/")}`;
     }
-    async find(query, options, agentId) {
-        const normalizedTargetUri = await this.normalizeTargetUri(options.targetUri, agentId);
+    async find(query, options, legacyActorPeerId) {
+        const targetUri = options.targetUri?.trim().replace(/\/+$/, "") ?? "";
         const body = {
             query,
-            target_uri: normalizedTargetUri,
             limit: options.limit,
             score_threshold: options.scoreThreshold,
+            context_type: options.contextType,
         };
-        const effectiveAgentId = this.resolveEffectiveAgentId(agentId);
-        const identity = await this.getRuntimeIdentity(agentId);
+        if (targetUri) {
+            body.target_uri = targetUri;
+        }
+        const actorPeerId = this.resolveActorPeerHeader(options.actorPeerId ?? legacyActorPeerId);
         const tenantHeaders = this.resolveTenantHeaders();
         this.routingDebugLog?.(`openviking: find POST ${this.baseUrl}/api/v1/search/find ` +
             JSON.stringify({
-                X_OpenViking_Agent: effectiveAgentId,
                 X_OpenViking_Account: tenantHeaders.accountId ?? null,
                 X_OpenViking_User: tenantHeaders.userId ?? null,
-                resolved_user_id: identity.userId,
-                target_uri: normalizedTargetUri,
+                X_OpenViking_Actor_Peer: actorPeerId ?? null,
+                target_uri: targetUri || null,
                 target_uri_input: options.targetUri,
                 query: query.length > 4000
                     ? `${query.slice(0, 4000)}…(+${query.length - 4000} more chars)`
                     : query,
                 limit: body.limit,
                 score_threshold: body.score_threshold ?? null,
+                context_type: body.context_type ?? null,
             }));
         return this.request("/api/v1/search/find", {
             method: "POST",
             body: JSON.stringify(body),
-        }, agentId);
+        }, undefined, actorPeerId);
     }
-    async read(uri, agentId) {
-        return this.request(`/api/v1/content/read?uri=${encodeURIComponent(uri)}`, {}, agentId);
+    async read(uri, actorPeerId) {
+        return this.request(`/api/v1/content/read?uri=${encodeURIComponent(uri)}`, {}, undefined, actorPeerId);
     }
-    async readToolResult(sessionId, toolResultId, options, agentId) {
+    async list(uri, options) {
+        const normalizedUri = uri.trim().replace(/\/+$/, "");
+        const params = new URLSearchParams({
+            uri: normalizedUri,
+            recursive: String(options?.recursive ?? false),
+            simple: String(options?.simple ?? false),
+            output: options?.output ?? "agent",
+            abs_limit: String(options?.absLimit ?? 256),
+            show_all_hidden: String(options?.showAllHidden ?? false),
+            node_limit: String(options?.nodeLimit ?? 1000),
+        });
+        return this.request(`/api/v1/fs/ls?${params.toString()}`, {}, undefined, options?.actorPeerId);
+    }
+    async readToolResult(sessionId, toolResultId, options) {
         const params = new URLSearchParams();
         if (options?.offset !== undefined)
             params.set("offset", String(options.offset));
@@ -255,31 +232,29 @@ export class OpenVikingClient {
             params.set("include_metadata", String(options.includeMetadata));
         }
         const query = params.toString();
-        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results/${encodeURIComponent(toolResultId)}${query ? `?${query}` : ""}`, {}, agentId);
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results/${encodeURIComponent(toolResultId)}${query ? `?${query}` : ""}`, {});
     }
-    async searchToolResult(sessionId, toolResultId, queryText, options, agentId) {
+    async searchToolResult(sessionId, toolResultId, queryText, options) {
         const params = new URLSearchParams({ q: queryText });
         if (options?.limit !== undefined)
             params.set("limit", String(options.limit));
         if (options?.contextChars !== undefined) {
             params.set("context_chars", String(options.contextChars));
         }
-        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results/${encodeURIComponent(toolResultId)}/search?${params.toString()}`, {}, agentId);
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results/${encodeURIComponent(toolResultId)}/search?${params.toString()}`, {});
     }
-    async listToolResults(sessionId, options, agentId) {
+    async listToolResults(sessionId, options) {
         const params = new URLSearchParams();
         if (options?.toolName)
             params.set("tool_name", options.toolName);
         if (options?.limit !== undefined)
             params.set("limit", String(options.limit));
         const query = params.toString();
-        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results${query ? `?${query}` : ""}`, {}, agentId);
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results${query ? `?${query}` : ""}`, {});
     }
-    async uploadTempFile(filePath, agentId) {
-        const fileBytes = await readFile(filePath);
-        const form = new FormData();
-        form.append("file", new Blob([toBlobPart(fileBytes)], { type: "application/octet-stream" }), basename(filePath));
-        const result = await this.request("/api/v1/resources/temp_upload", { method: "POST", body: form }, agentId);
+    async uploadTempFile(filePath, actorPeerId) {
+        const form = await this.resourcePackager.createTempUploadBody(filePath);
+        const result = await this.request("/api/v1/resources/temp_upload", { method: "POST", body: form }, undefined, actorPeerId);
         if (!result.temp_file_id) {
             throw new Error("OpenViking temp upload did not return temp_file_id");
         }
@@ -340,7 +315,7 @@ export class OpenVikingClient {
         }
         return zipPath;
     }
-    async addResource(input, agentId) {
+    async addResource(input, actorPeerId) {
         const pathOrUrl = input.pathOrUrl.trim();
         if (!pathOrUrl) {
             throw new Error("pathOrUrl is required");
@@ -363,32 +338,26 @@ export class OpenVikingClient {
         if (typeof input.preserveStructure === "boolean") {
             body.preserve_structure = input.preserveStructure;
         }
-        let cleanupPath;
+        let packagedSource;
         const requestTimeoutMs = input.wait ? resolveWaitRequestTimeoutMs(this.timeoutMs, input.timeout) : undefined;
         try {
-            if (isRemoteResourceSource(pathOrUrl)) {
-                body.path = pathOrUrl;
+            packagedSource = await this.resourcePackager.prepareResourceSource(pathOrUrl);
+            if (packagedSource.kind === "remote") {
+                body.path = packagedSource.path;
             }
             else {
-                const localStats = await stat(pathOrUrl);
-                let uploadPath = pathOrUrl;
-                if (localStats.isDirectory()) {
-                    uploadPath = await this.zipDirectoryForUpload(pathOrUrl);
-                    cleanupPath = uploadPath;
-                    body.source_name = basename(pathOrUrl);
-                }
-                else if (!localStats.isFile()) {
-                    throw new Error(`Path is not a file or directory: ${pathOrUrl}`);
+                if (packagedSource.sourceName) {
+                    body.source_name = packagedSource.sourceName;
                 }
-                body.temp_file_id = await this.uploadTempFile(uploadPath, agentId);
+                body.temp_file_id = await this.uploadTempFile(packagedSource.uploadPath, actorPeerId);
             }
-            return this.request("/api/v1/resources", { method: "POST", body: JSON.stringify(body) }, agentId, requestTimeoutMs);
+            return this.request("/api/v1/resources", { method: "POST", body: JSON.stringify(body) }, requestTimeoutMs, actorPeerId);
         }
         finally {
-            await cleanupUploadTempPath(cleanupPath);
+            await this.resourcePackager.cleanup(packagedSource);
         }
     }
-    async addSkill(input, agentId) {
+    async addSkill(input, actorPeerId) {
         const hasPath = typeof input.path === "string" && input.path.trim().length > 0;
         const hasData = input.data !== undefined && input.data !== null;
         if (hasPath === hasData) {
@@ -398,32 +367,27 @@ export class OpenVikingClient {
             wait: input.wait ?? false,
             timeout: input.timeout,
         };
-        let cleanupPath;
+        let packagedSource;
         const requestTimeoutMs = input.wait ? resolveWaitRequestTimeoutMs(this.timeoutMs, input.timeout) : undefined;
         try {
             if (hasPath) {
                 const skillPath = input.path.trim();
-                const localStats = await stat(skillPath);
-                let uploadPath = skillPath;
-                if (localStats.isDirectory()) {
-                    uploadPath = await this.zipDirectoryForUpload(skillPath);
-                    cleanupPath = uploadPath;
-                }
-                else if (!localStats.isFile()) {
+                packagedSource = await this.resourcePackager.prepareLocalUploadSource(skillPath);
+                if (packagedSource.kind !== "upload") {
                     throw new Error(`Path is not a file or directory: ${skillPath}`);
                 }
-                body.temp_file_id = await this.uploadTempFile(uploadPath, agentId);
+                body.temp_file_id = await this.uploadTempFile(packagedSource.uploadPath, actorPeerId);
             }
             else {
                 body.data = input.data;
             }
-            return this.request("/api/v1/skills", { method: "POST", body: JSON.stringify(body) }, agentId, requestTimeoutMs);
+            return this.request("/api/v1/skills", { method: "POST", body: JSON.stringify(body) }, requestTimeoutMs, actorPeerId);
         }
         finally {
-            await cleanupUploadTempPath(cleanupPath);
+            await this.resourcePackager.cleanup(packagedSource);
         }
     }
-    async addSessionMessage(sessionId, role, parts, agentId, createdAt, roleId) {
+    async addSessionMessage(sessionId, role, parts, actorPeerId, createdAt, roleId) {
         const body = { role, parts };
         if (createdAt) {
             body.created_at = createdAt;
@@ -438,15 +402,15 @@ export class OpenVikingClient {
             role_id: roleId ?? null,
             partCount: parts.length,
             created_at: createdAt ?? null,
-        }, agentId);
+        }, actorPeerId);
         await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/messages`, {
             method: "POST",
             body: JSON.stringify(body),
-        }, agentId);
+        }, undefined, actorPeerId);
     }
     /** GET session — server auto-creates if absent; returns session meta including message stats and token usage. */
-    async getSession(sessionId, agentId) {
-        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}`, { method: "GET" }, agentId);
+    async getSession(sessionId, actorPeerId) {
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}`, { method: "GET" }, undefined, actorPeerId);
     }
     /**
      * Commit a session: archive (Phase 1) and extract memories (Phase 2).
@@ -469,15 +433,15 @@ export class OpenVikingClient {
         if (keepRecentCount > 0) {
             body.keep_recent_count = keepRecentCount;
         }
-        const result = await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/commit`, { method: "POST", body: JSON.stringify(body) }, options?.agentId);
+        const result = await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/commit`, { method: "POST", body: JSON.stringify(body) }, undefined, options?.agentId);
         if (!options?.wait || !result.task_id) {
             return result;
         }
         // Client-side poll until Phase 2 finishes
-        const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_PHASE2_POLL_TIMEOUT_MS);
+        const deadline = this.now() + (options.timeoutMs ?? DEFAULT_PHASE2_POLL_TIMEOUT_MS);
         const pollInterval = 500;
-        while (Date.now() < deadline) {
-            await sleep(pollInterval);
+        while (this.now() < deadline) {
+            await this.sleep(pollInterval);
             const task = await this.getTask(result.task_id, options.agentId).catch(() => null);
             if (!task)
                 break;
@@ -498,17 +462,17 @@ export class OpenVikingClient {
         return result;
     }
     /** Poll a background task by ID. */
-    async getTask(taskId, agentId) {
-        return this.request(`/api/v1/tasks/${encodeURIComponent(taskId)}`, { method: "GET" }, agentId);
+    async getTask(taskId, actorPeerId) {
+        return this.request(`/api/v1/tasks/${encodeURIComponent(taskId)}`, { method: "GET" }, undefined, actorPeerId);
     }
-    async getSessionContext(sessionId, tokenBudget = 128_000, agentId) {
-        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/context?token_budget=${tokenBudget}`, { method: "GET" }, agentId);
+    async getSessionContext(sessionId, tokenBudget = 128_000, actorPeerId) {
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/context?token_budget=${tokenBudget}`, { method: "GET" }, undefined, actorPeerId);
     }
-    async getSessionArchive(sessionId, archiveId, agentId) {
-        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/archives/${encodeURIComponent(archiveId)}`, { method: "GET" }, agentId);
+    async getSessionArchive(sessionId, archiveId, actorPeerId) {
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/archives/${encodeURIComponent(archiveId)}`, { method: "GET" }, undefined, actorPeerId);
     }
     async grepSessionArchives(sessionId, pattern, options = {}) {
-        const baseUri = `viking://session/${sessionId}/history`;
+        const baseUri = `${userSessionUri(sessionId)}/history`;
         const uri = options.archiveId ? `${baseUri}/${options.archiveId}` : baseUri;
         return this.request("/api/v1/search/grep", {
             method: "POST",
@@ -519,14 +483,14 @@ export class OpenVikingClient {
                 ...(options.nodeLimit !== undefined ? { node_limit: options.nodeLimit } : {}),
                 ...(options.levelLimit !== undefined ? { level_limit: options.levelLimit } : {}),
             }),
-        }, options.agentId);
+        });
     }
-    async deleteSession(sessionId, agentId) {
-        await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}`, { method: "DELETE" }, agentId);
+    async deleteSession(sessionId) {
+        await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}`, { method: "DELETE" });
     }
-    async deleteUri(uri, agentId) {
+    async deleteUri(uri, actorPeerId) {
         await this.request(`/api/v1/fs?uri=${encodeURIComponent(uri)}&recursive=false`, {
             method: "DELETE",
-        }, agentId);
+        }, undefined, actorPeerId);
     }
 }