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

package/dist/adapters/http-transport.js

@@ -0,0 +1 @@
+export const defaultHttpTransport = (url, init) => fetch(url, init);

package/dist/adapters/resource-packager.js

@@ -0,0 +1,114 @@
+import { randomUUID } from "node:crypto";
+import { once } from "node:events";
+import { createWriteStream } from "node:fs";
+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";
+const REMOTE_RESOURCE_PREFIXES = ["http://", "https://", "git@", "ssh://", "git://"];
+function toBlobPart(value) {
+    return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+}
+export function isRemoteResourceSource(source) {
+    return REMOTE_RESOURCE_PREFIXES.some((prefix) => source.startsWith(prefix));
+}
+export async function cleanupUploadTempPath(path) {
+    if (!path) {
+        return;
+    }
+    await rm(path, { force: true }).catch(() => undefined);
+    await rm(dirname(path), { recursive: true, force: true }).catch(() => undefined);
+}
+export async function zipDirectoryForUpload(dirPath) {
+    const rootStats = await stat(dirPath);
+    if (!rootStats.isDirectory()) {
+        throw new Error(`Not a directory: ${dirPath}`);
+    }
+    const zipDir = await mkdtemp(join(tmpdir(), "openviking-openclaw-upload-"));
+    const zipPath = join(zipDir, `${basename(dirPath).replace(/[^a-zA-Z0-9._-]/g, "_")}-${randomUUID()}.zip`);
+    const output = createWriteStream(zipPath);
+    const outputClosed = once(output, "close");
+    const outputErrored = once(output, "error").then(([err]) => Promise.reject(err));
+    const zip = new Zip((err, chunk, final) => {
+        if (err) {
+            output.destroy(err);
+            return;
+        }
+        if (chunk?.length) {
+            output.write(Buffer.from(chunk));
+        }
+        if (final) {
+            output.end();
+        }
+    });
+    const walk = async (currentDir) => {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            const relPath = relative(dirPath, fullPath).split("\\").join("/");
+            if (!relPath || relPath.startsWith("../") || relPath.includes("/../")) {
+                throw new Error(`Unsafe relative path while zipping: ${relPath}`);
+            }
+            const file = new ZipDeflate(relPath);
+            zip.add(file);
+            file.push(new Uint8Array(await readFile(fullPath)), true);
+        }
+    };
+    try {
+        await walk(dirPath);
+        zip.end();
+        await Promise.race([outputClosed, outputErrored]);
+    }
+    catch (err) {
+        zip.terminate();
+        output.destroy(err);
+        await cleanupUploadTempPath(zipPath);
+        throw err;
+    }
+    return zipPath;
+}
+async function prepareLocalUploadSource(path, includeSourceName = false) {
+    const localStats = await stat(path);
+    if (localStats.isDirectory()) {
+        const uploadPath = await zipDirectoryForUpload(path);
+        return {
+            kind: "upload",
+            uploadPath,
+            cleanupPath: uploadPath,
+            ...(includeSourceName ? { sourceName: basename(path) } : {}),
+        };
+    }
+    if (!localStats.isFile()) {
+        throw new Error(`Path is not a file or directory: ${path}`);
+    }
+    return { kind: "upload", uploadPath: path };
+}
+export const defaultResourcePackager = {
+    async prepareResourceSource(pathOrUrl) {
+        if (isRemoteResourceSource(pathOrUrl)) {
+            return { kind: "remote", path: pathOrUrl };
+        }
+        return prepareLocalUploadSource(pathOrUrl, true);
+    },
+    async prepareLocalUploadSource(path) {
+        return prepareLocalUploadSource(path, false);
+    },
+    async createTempUploadBody(uploadPath) {
+        const fileBytes = await readFile(uploadPath);
+        const form = new FormData();
+        form.append("file", new Blob([toBlobPart(fileBytes)], { type: "application/octet-stream" }), basename(uploadPath));
+        return form;
+    },
+    async cleanup(source) {
+        if (source?.kind === "upload") {
+            await cleanupUploadTempPath(source.cleanupPath);
+        }
+    },
+};

package/dist/auto-recall.js

@@ -1,9 +1,18 @@
 import { pickMemoriesForInjection, postProcessMemories, summarizeInjectionMemories, toJsonLog, } from "./memory-ranking.js";
 import { quickRecallPrecheck, withTimeout } from "./process-manager.js";
+import { resolveRecallSearchPlan, } from "./registries/recall-resource-types.js";
 import { sanitizeUserTextForCapture } from "./text-utils.js";
+import { estimateTextTokens } from "./token-estimator.js";
 const AUTO_RECALL_TIMEOUT_MS = 5_000;
 const RECALL_QUERY_MAX_CHARS = 4_000;
 export const AUTO_RECALL_SOURCE_MARKER = "Source: openviking-auto-recall";
+const WRITE_OR_EFFECT_RE = /\b(write|edit|modify|delete|remove|migrate|deploy|release|publish|configure|patch)\b|写|改|修改|删除|迁移|部署|发布|配置|打补丁/i;
+const EXECUTION_RE = /\b(fix|debug|test|build|run|implement|refactor|integrate|repair|troubleshoot)\b|修复|调试|测试|构建|运行|实现|重构|对接|排查/i;
+const FAILURE_RE = /\b(error|exception|traceback|failed|failure|retry|exit code|test failed)\b|报错|异常|失败|重试|挂了|不通过/i;
+const ENGINEERING_OBJECT_RE = /(?:^|\s)(?:[\w.-]+\/[\w./-]+|[\w./-]+\.(?:ts|tsx|js|jsx|py|go|rs|java|md|json|ya?ml|toml|sh|sql))\b|`[^`]+`|\b(?:repo|workspace|plugin|service|component|hook|api|tool|package|module)\b|仓库|工作区|插件|服务|组件|接口|工具|模块|文件/i;
+const EXPERIENCE_INTENT_RE = /经验|踩坑|最佳实践|不要再|按之前|avoid|best practice|lesson|pitfall/i;
+const QUESTION_ONLY_RE = /^(?:什么是|是什么|区别|解释|讲讲|怎么看|为什么|如何理解|where is|what is|explain|difference between)\b|[?？]$/i;
+const CASUAL_RE = /闲聊|翻译|总结当前对话|天气|笑话|hello|hi\b|你好/i;
 export function prepareRecallQuery(rawText) {
     const sanitized = sanitizeUserTextForCapture(rawText).trim();
     const originalChars = sanitized.length;
@@ -25,11 +34,29 @@ export function prepareRecallQuery(rawText) {
         finalChars: query.length,
     };
 }
-/** Estimate token count using chars/4 heuristic for diagnostics. */
+/** Estimate token count using the shared CJK-aware fallback for diagnostics. */
 export function estimateTokenCount(text) {
-    if (!text)
-        return 0;
-    return Math.ceil(text.length / 4);
+    return estimateTextTokens(text);
+}
+function memoryCategory(item) {
+    return item.category?.trim() || "memory";
+}
+function indentContent(content) {
+    return content
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n");
+}
+function formatMemoryLine(item, content, options) {
+    const category = memoryCategory(item);
+    if (!options.includeUri) {
+        return `- [${category}] ${content}`;
+    }
+    return [
+        `- [${category}]`,
+        `  <uri>${item.uri}</uri>`,
+        indentContent(content),
+    ].join("\n");
 }
 async function resolveMemoryContent(item, readFn, options) {
     let content;
@@ -57,7 +84,7 @@ export async function buildMemoryLines(memories, readFn, options) {
     const lines = [];
     for (const item of memories) {
         const content = await resolveMemoryContent(item, readFn, options);
-        lines.push(`- [${item.category ?? "memory"}] ${content}`);
+        lines.push(formatMemoryLine(item, content, options));
     }
     return lines;
 }
@@ -78,7 +105,7 @@ export async function buildMemoryLinesWithBudget(memories, readFn, options) {
             break;
         }
         const content = await resolveMemoryContent(item, readFn, options);
-        const line = `- [${item.category ?? "memory"}] ${content}`;
+        const line = formatMemoryLine(item, content, options);
         const separatorChars = lines.length > 0 ? 1 : 0;
         const projectedChars = totalChars + separatorChars + line.length;
         if (projectedChars > charBudget) {
@@ -100,68 +127,237 @@ export function buildRecallContextBlock(memoryLines) {
         "</relevant-memories>",
     ].join("\n");
 }
+function newTraceId() {
+    return `recall_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function preview(value, maxChars) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.length > maxChars ? trimmed.slice(0, maxChars) : trimmed;
+}
+function toTraceResults(items, resourceType) {
+    return items.map((item) => ({
+        uri: item.uri,
+        resourceType,
+        category: item.category,
+        score: item.score,
+        level: item.level,
+        abstractPreview: preview(item.abstract ?? item.overview, 240),
+        resultType: resourceType === "resource" ? "resource" : "memory",
+    }));
+}
+function boundTraceQuery(query, maxChars) {
+    if (query.length <= maxChars) {
+        return { query };
+    }
+    return { query: query.slice(0, maxChars), queryTruncated: true };
+}
+function runtimeFlag(runtimeContext, key) {
+    return runtimeContext && typeof runtimeContext === "object"
+        ? runtimeContext[key]
+        : undefined;
+}
+export function isCronSession(sessionKey, runtimeContext) {
+    return Boolean(sessionKey?.includes(":cron:") ||
+        runtimeFlag(runtimeContext, "isCron") === true ||
+        runtimeFlag(runtimeContext, "automationKind") === "cron");
+}
+export function shouldRecallAgentExperience(input) {
+    const text = sanitizeUserTextForCapture(input.latestUserText).trim();
+    const minQueryChars = input.minQueryChars ?? 12;
+    if (input.isBypassed) {
+        return { recall: false, score: 0, reason: "session_bypassed" };
+    }
+    if (!text || text.length < minQueryChars) {
+        return { recall: false, score: 0, reason: "query_too_short" };
+    }
+    if (/<openviking-context\b/i.test(input.latestUserText)) {
+        return { recall: false, score: 0, reason: "already_injected" };
+    }
+    const trigger = input.triggerHint ?? (isCronSession(input.sessionKey, input.runtimeContext) ? "cron_start" : "task_start");
+    if (trigger !== "task_start") {
+        return { recall: true, trigger, score: 99, reason: "forced_trigger" };
+    }
+    let score = 0;
+    if (WRITE_OR_EFFECT_RE.test(text))
+        score += 3;
+    if (EXECUTION_RE.test(text))
+        score += 2;
+    if (FAILURE_RE.test(text))
+        score += 2;
+    if (ENGINEERING_OBJECT_RE.test(text))
+        score += 2;
+    if (EXPERIENCE_INTENT_RE.test(text))
+        score += 1;
+    if (CASUAL_RE.test(text))
+        score -= 3;
+    if (QUESTION_ONLY_RE.test(text) && !ENGINEERING_OBJECT_RE.test(text) && !EXECUTION_RE.test(text)) {
+        score -= 2;
+    }
+    if (score >= 3) {
+        return { recall: true, trigger: "task_start", score, reason: "task_execution" };
+    }
+    return { recall: false, score, reason: score < 0 ? "non_execution" : "below_threshold" };
+}
 export async function buildAutoRecallContext(params) {
     const { cfg, client, agentId, queryText, logger, verbose } = params;
+    const queryConfig = params.queryConfig;
     if (!cfg.autoRecall || queryText.length < 5) {
         return { memoryCount: 0, estimatedTokens: 0 };
     }
-    const precheck = await quickRecallPrecheck(cfg.baseUrl);
+    const precheck = await quickRecallPrecheck(client, agentId);
     if (!precheck.ok) {
         verbose?.(`openviking: skipping auto-recall because precheck failed (${precheck.reason})`);
         return { memoryCount: 0, estimatedTokens: 0 };
     }
     return withTimeout((async () => {
-        const candidateLimit = Math.max(cfg.recallLimit * 4, 20);
-        const autoRecallPromises = [
-            client.find(queryText, {
-                targetUri: "viking://user/memories",
-                limit: candidateLimit,
-                scoreThreshold: 0,
-            }, agentId),
-            client.find(queryText, {
-                targetUri: "viking://agent/memories",
-                limit: candidateLimit,
-                scoreThreshold: 0,
-            }, agentId),
-        ];
-        if (cfg.recallResources) {
-            autoRecallPromises.push(client.find(queryText, {
-                targetUri: "viking://resources",
+        const candidateLimit = queryConfig?.candidateLimit ?? Math.max(cfg.recallLimit * 4, 20);
+        const scoreThreshold = queryConfig?.scoreThreshold ?? cfg.recallScoreThreshold;
+        const recallLimit = queryConfig?.recallLimit ?? cfg.recallLimit;
+        const maxInjectedChars = queryConfig?.maxInjectedChars ?? cfg.recallMaxInjectedChars;
+        const recallPreferAbstract = queryConfig?.recallPreferAbstract ?? cfg.recallPreferAbstract;
+        const searchPlan = resolveRecallSearchPlan(params.resourceTypes ?? queryConfig?.resourceTypes ?? cfg.recallTargetTypes, {
+            ovSessionId: params.ovSessionId,
+            agentId,
+        });
+        const traceSearches = searchPlan.skipped.map((skipped) => ({
+            resourceType: skipped.resourceType,
+            limit: candidateLimit,
+            scoreThreshold: 0,
+            durationMs: 0,
+            total: 0,
+            results: [],
+            error: skipped.reason,
+        }));
+        const autoRecallPromises = searchPlan.searches.map(async (search) => {
+            const start = Date.now();
+            const result = await client.find(queryText, {
+                targetUri: search.targetUri,
                 limit: candidateLimit,
                 scoreThreshold: 0,
-            }, agentId));
-        }
+                contextType: search.contextType,
+                actorPeerId: agentId,
+            });
+            return {
+                resourceType: search.resourceType,
+                targetUri: search.targetUri,
+                result,
+                durationMs: Date.now() - start,
+            };
+        });
         const autoRecallSettled = await Promise.allSettled(autoRecallPromises);
         const allMemories = [];
         for (const s of autoRecallSettled) {
             if (s.status === "fulfilled") {
-                allMemories.push(...(s.value.memories ?? []), ...(s.value.resources ?? []));
+                const result = s.value.result ?? {};
+                const memories = result.memories ?? [];
+                const resources = result.resources ?? [];
+                allMemories.push(...memories, ...resources);
+                traceSearches.push({
+                    resourceType: s.value.resourceType,
+                    targetUriInput: s.value.targetUri,
+                    limit: candidateLimit,
+                    scoreThreshold: 0,
+                    durationMs: s.value.durationMs,
+                    total: result.total ?? memories.length + resources.length + (result.skills?.length ?? 0),
+                    results: [
+                        ...toTraceResults(memories, s.value.resourceType),
+                        ...toTraceResults(resources, "resource"),
+                        ...(result.skills ?? []).map((item) => ({
+                            uri: item.uri,
+                            resourceType: s.value.resourceType,
+                            category: item.category,
+                            score: item.score,
+                            level: item.level,
+                            abstractPreview: preview(item.abstract ?? item.overview, 240),
+                            resultType: "skill",
+                        })),
+                    ].slice(0, cfg.traceRecallMaxResultsPerSearch),
+                });
             }
             else {
                 logger.warn?.(`openviking: auto-recall search failed: ${String(s.reason)}`);
+                const failedIndex = traceSearches.length;
+                const search = searchPlan.searches[failedIndex - searchPlan.skipped.length];
+                traceSearches.push({
+                    resourceType: search?.resourceType ?? "user",
+                    targetUriInput: search?.targetUri,
+                    limit: candidateLimit,
+                    scoreThreshold: 0,
+                    durationMs: 0,
+                    total: 0,
+                    results: [],
+                    error: String(s.reason),
+                });
             }
         }
         const uniqueMemories = allMemories.filter((memory, index, self) => index === self.findIndex((m) => m.uri === memory.uri));
         const leafOnly = uniqueMemories.filter((m) => !m.level || m.level === 2);
         const processed = postProcessMemories(leafOnly, {
             limit: candidateLimit,
-            scoreThreshold: cfg.recallScoreThreshold,
+            scoreThreshold,
         });
-        const memories = pickMemoriesForInjection(processed, cfg.recallLimit, queryText);
+        const memories = pickMemoriesForInjection(processed, recallLimit, queryText, scoreThreshold, queryConfig ? {
+            weights: queryConfig.rankingWeights,
+            categoryWeights: queryConfig.categoryWeights,
+            resourceTypeWeights: queryConfig.resourceTypeWeights,
+        } : undefined);
+        const recordTrace = async (injectedMemories, injectedCount, estimatedTokens) => {
+            const entry = {
+                schemaVersion: "1.0",
+                traceId: newTraceId(),
+                ts: Date.now(),
+                sessionId: params.sessionId,
+                sessionKey: params.sessionKey,
+                ovSessionId: params.ovSessionId,
+                agentId,
+                source: "auto_recall",
+                operationType: "semantic_find",
+                resourceTypes: searchPlan.resourceTypes,
+                trigger: {
+                    rawUserTextPreview: params.rawUserTextPreview,
+                    ...boundTraceQuery(queryText, cfg.traceRecallQueryMaxChars),
+                    derivedKeywords: [],
+                    queryTruncated: params.queryTruncated || queryText.length > cfg.traceRecallQueryMaxChars,
+                },
+                searches: traceSearches,
+                selected: injectedMemories.map((memory) => ({
+                    uri: memory.uri,
+                    resourceType: memory.uri.startsWith("viking://resources") ? "resource" : undefined,
+                    category: memory.category,
+                    score: memory.score,
+                    abstractPreview: preview(memory.abstract ?? memory.overview, cfg.traceRecallPreviewChars),
+                    injected: true,
+                })),
+                stats: {
+                    candidateCount: allMemories.length,
+                    selectedCount: injectedMemories.length,
+                    injectedCount,
+                    estimatedTokens,
+                },
+            };
+            // Trace persistence is diagnostic best-effort; never put JSONL flush latency on the auto-recall critical path.
+            params.traceRecorder?.record(entry);
+        };
         if (memories.length === 0) {
+            await recordTrace([], 0, 0);
             return { memoryCount: 0, estimatedTokens: 0 };
         }
         const { lines: memoryLines, estimatedTokens } = await buildMemoryLinesWithBudget(memories, (uri) => client.read(uri, agentId), {
-            recallPreferAbstract: cfg.recallPreferAbstract,
-            recallMaxInjectedChars: cfg.recallMaxInjectedChars,
+            recallPreferAbstract,
+            recallMaxInjectedChars: maxInjectedChars,
+            includeUri: true,
         });
         if (memoryLines.length === 0) {
-            verbose?.(`openviking: skipping auto-recall injection; no complete memories fit maxInjectedChars=${cfg.recallMaxInjectedChars}`);
+            verbose?.(`openviking: skipping auto-recall injection; no complete memories fit maxInjectedChars=${maxInjectedChars}`);
+            await recordTrace([], 0, 0);
             return { memoryCount: 0, estimatedTokens: 0 };
         }
         const block = buildRecallContextBlock(memoryLines);
-        verbose?.(`openviking: injecting ${memoryLines.length} memories (${block.length} chars, ~${estimatedTokens} tokens, maxInjectedChars=${cfg.recallMaxInjectedChars})`);
+        verbose?.(`openviking: injecting ${memoryLines.length} memories (${block.length} chars, ~${estimatedTokens} tokens, maxInjectedChars=${maxInjectedChars})`);
         verbose?.(`openviking: inject-detail ${toJsonLog({ count: memories.length, memories: summarizeInjectionMemories(memories) })}`);
+        await recordTrace(memories.slice(0, memoryLines.length), memoryLines.length, estimatedTokens);
         return { block, memoryCount: memoryLines.length, estimatedTokens };
     })(), AUTO_RECALL_TIMEOUT_MS, "openviking: auto-recall search timeout");
 }